Skip to content

refactor!: remove the Block Tune tool kind - #193

Merged
gohabereg merged 30 commits into
mainfrom
feat/remove-block-tunes
Nov 8, 2026
Merged

gohabereg merged 30 commits into
mainfrom
feat/remove-block-tunes

Conversation

@gohabereg

Copy link
Copy Markdown
Member

Implements the remove-block-tunes change from #189. Stacked on #192 — this diff is only the tool-kind removal.

The Block Tune tool kind is dead weight. A registered tune gets a BlockTuneFacade built and sorted into ToolsManager.blockTunes, and then nothing ever reads it: no adapter, no rendering, no core wiring. So deleting it breaks no working feature — it just removes the half-wired second way to build what plugins now do, and with it the extension point #157 grew an adapter and a manager around.

What's in it

  • SDK. Deletes ToolType.Tune, the BlockTune* entity exports and BlockTuneFacade, plus everything referencing them: BaseToolFacade#isTune(), ToolsCollection#blockTunes (its only consumer), BlockTuneConstructor from ToolConstructable, BlockTuneFacade from ToolFacadeClass, ToolTypeToOptions[ToolType.Tune], BlockToolOptionKey.Tunes and its BlockToolOptions member, UserToolOptions.EnabledBlockTunes, and BlockToolFacade#tunes/#enabledBlockTunes.
  • Core. Removes the Tune branch from Core#use, the getAll(ToolType.Tune) preparation step, the Tune case in ToolsFactory, and ToolsManager#blockTunes.
  • shortcuts-plugin. Its dead #processBlockTune and the BlockTuneFacade import go with the facade.

"Tune" becomes a UI term only: a former tune is written as a plugin that uses plugin data and the block-settings API.

How the removals are tested

Each deleted name is guarded by a @ts-expect-error on its import specifier. Under ts-jest a stale directive is itself a diagnostic (TS2578), so every one of these fails the suite the moment its name comes back — the assertions are live, not decorative. I verified that by temporarily pointing one directive at an existing export and confirming it fired.

One name resisted: BlockToolOptions['tunes'] can't be asserted gone, because the interface carries an open [key: string]: unknown index signature for tool-author options, so any key resolves. BlockToolOptionKey.Tunes is the removable surface and is asserted instead; the spec notes this.

New specs for ToolsCollection and ToolsFactory. The latter had zero coverage, which let a mutant collapsing the remaining Inline case survive — it's now at 100% mutation score.

Breaking (pre-1.0)

Anything that registers a tune via core.use() or sets a tool's tunes option. The model layer's tune vocabulary is renamed by #192, not here.

Notes for review

Task 4.5 — commenting on #157 to point at the three replacement changes — is left unchecked on purpose; that's a public comment on someone else's PR and wants a human to send it.

Verified: yarn build and yarn lint clean, 1,048 tests passing, openspec validate remove-block-tunes --type change passes, archive gate OK.

🤖 Generated with Claude Code

@github-actions

github-actions Bot commented Oct 4, 2026 •

Copy link
Copy Markdown
Contributor

Unit Tests

Package Coverage Delta
@editorjs/ot-server 20% 0% ⚪️
@editorjs/collaboration-manager 87.58% 0% ⚪️
@editorjs/dom-adapters 86.95% 0% ⚪️
@editorjs/shortcuts-plugin 100% 0% ⚪️
@editorjs/clipboard-plugin 66.66% 0% ⚪️
@editorjs/editorjs 100% 0% ⚪️
@editorjs/core 77.77% +1.08% 🟢
@editorjs/model N/A N/A
@editorjs/model-types N/A N/A

Mutation Tests

Package Mutation score Dashboard URL
@editorjs/dom-adapters No files to mutate found.
@editorjs/collaboration-manager No files to mutate found.
@editorjs/clipboard-plugin No files to mutate found.
@editorjs/shortcuts-plugin 96.15% 🟢 Dashboard
@editorjs/core 33.61% 🔴 Dashboard

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🟢 Approval recommended

The intentional breaking removal is consistent across contracts, core wiring, dependents, and regression tests, with no blocking issues identified.

0 open findings

What changed in this PR

Removes the unused Block Tune tool kind, continuing #189’s move toward plugin-based block settings. Model-layer changes remain in #192.

Changes:

  • Removes tune contracts, facades, options, and registration paths.
  • Adds removal guards and coverage for remaining tool kinds.
  • Updates documentation and implementation tasks.
File Description
packages/​sdk/​src/​tools/​ToolsCollection.ts Removes the tune collection view.
packages/​sdk/​src/​tools/​ToolsCollection.spec.ts Tests remaining views and tune removal.
packages/​sdk/​src/​tools/​facades/​index.ts Removes tune facade exports and union member.
packages/​sdk/​src/​tools/​facades/​BlockTuneFacade.ts Deletes the unused facade.
packages/​sdk/​src/​tools/​facades/​BlockToolFacade.ts Removes tune collections and options.
packages/​sdk/​src/​tools/​facades/​BaseToolFacade.ts Removes tune types and predicate.
packages/​sdk/​src/​tools/​facades/​BaseToolFacade.spec.ts Guards removed SDK APIs.
packages/​sdk/​src/​entities/​MenuConfig.ts Updates menu documentation.
packages/​sdk/​src/​entities/​index.ts Removes tune contract exports.
packages/​sdk/​src/​entities/​EntityType.ts Removes ToolType.Tune.
packages/​sdk/​src/​entities/​BlockTune.ts Deletes tune contracts.
packages/​sdk/​src/​entities/​BlockTool.ts Removes the tune option.
packages/​sdk/​src/​entities/​BaseTool.ts Narrows option types to remaining kinds.
packages/​sdk/​src/​api/​BlocksAPI.ts Removes tune references from commented API.
packages/​plugins/​shortcuts-plugin/​src/​index.ts Removes unused tune shortcut stub.
packages/​core/​src/​tools/​ToolsManager.ts Removes the tune collection getter.
packages/​core/​src/​tools/​ToolsFactory.ts Removes tune facade construction.
packages/​core/​src/​tools/​ToolsFactory.spec.ts Tests factory behavior for remaining kinds.
packages/​core/​src/​index.ts Removes tune registration and preparation.
packages/​core/​src/​index.spec.ts Tests plugin routing and collection removal.
openspec/​changes/​remove-block-tunes/​tasks.md Records completed implementation tasks.
docs/​README.md Updates supported tool contracts.
docs/​plugins.md Explains plugin-based tune replacement.
docs/​diagrams/​plugin-lifecycle-flow.mmd Removes tune lifecycle paths.

🧠 Review effort: Balanced


💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

@gohabereg
gohabereg force-pushed the feat/plugin-block-data branch from dd75828 to d555032 Compare October 16, 2026 23:01
@gohabereg
gohabereg force-pushed the feat/remove-block-tunes branch 3 times, most recently from 119c8bf to 36fa683 Compare October 17, 2026 18:52
@gohabereg
gohabereg force-pushed the feat/plugin-block-data branch from 24efab2 to 7aefa42 Compare October 17, 2026 18:52
gohabereg and others added 11 commits November 5, 2026 01:19
Renames the model's tune vocabulary so per-block extra data belongs to
plugins rather than to a dedicated Block Tune entity:

- BlockTune entity -> PluginDataNode, with key deletion when a value is set
  to undefined and an isEmpty getter
- TuneIndex -> PluginDataIndex, serialized as {"k":"plugin",...,"plugin":...}
- TuneModifiedEvent -> PluginDataModifiedEvent, BlockTuneEvents ->
  PluginDataEvents
- BlockTuneName/BlockTuneSerialized -> PluginDataName/PluginDataSerialized
- the serialized block key `tunes` -> `plugins`

Behavior changes beyond the rename:

- BlockNode.updatePluginData creates a missing entry instead of throwing. The
  node is created empty and its listener attached before the first update,
  because PluginDataNode dispatches synchronously.
- entries live in a null-prototype record, and an empty plugin name throws, so
  a document-supplied name like __proto__ is stored as plain data
- empty entries are left out of serialization
- EditorDocument.modifyData applies a Modified change addressed by a
  PluginDataIndex, so undo/redo and remote operations can replay plugin data
- the bubbled event carries the acting user from the context instead of a
  hardcoded 'user'

BREAKING CHANGE: the serialized block key `tunes` is now `plugins`, and the
serialized index kind "tune" is now "plugin".

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
- re-export the renamed model types (PluginDataName, PluginDataSerialized,
  PluginDataIndex, PluginDataModifiedEvent, createPluginDataName)
- declare EditorjsPluginDataMap, a third augmentable map alongside
  EditorjsPluginApiMap and ToolPluginOptionsMap, and resolve a plugin's data
  shape through PluginDataFor<Id>. An undeclared id falls back to a plain
  record rather than never, since per-block data is often stored by a plugin
  that has no reason to publish its shape.
- add BlocksAPI.getPluginData / updatePluginData and a `plugins` map on insert

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
- BlocksAPI.getPluginData / updatePluginData, backed by BlocksManager, with
  the acting user defaulting to the configured one
- insert() accepts a `plugins` map, and convert() carries plugin data over to
  the converted block
- fix insert() dropping the block's data: BlocksManager spread `...data` into
  the block init while BlockNode reads a nested `data` key, so inserting with
  data silently produced an empty block. `plugins` is passed as its own key.
- fix BlocksAPI.insert not forwarding `focus`, `plugins` and `userId`
- add UndoRedoManager integration tests over a real model: undoing a first
  write removes the entry, redo restores it, and undoing one key leaves the
  plugin's other keys untouched
- fix the BlocksAPI integration spec wiring a second, empty model into the API,
  which made every direct model read in it see an empty document

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
- map PluginDataModifiedEvent to a Modify operation carrying the new and
  previous values, instead of logging it as an unknown event type
- add a PluginDataIndex branch to OperationsTransformer#applyTransformation,
  which dispatches on the against-operation's index kind and previously threw
  'Unsupported index type'. Without it the first remote plugin data change
  threw in OTClient's pending-operation reduce, in transformStacks for every
  remote event, and in ot-server's conflicting-operation reduce.
- widen ModifyOperationData's payload from Record<any, any> to unknown, so a
  scalar plugin data value is representable, and narrow the two payload length
  reads that relied on the old type
- move the ot-server fixtures off the `tunes` key

Two concurrent writes to the same key stay untransformed: server order decides
and the last applied one wins.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Mutation testing (scoped to the changed files, as CI does) pointed at four
real gaps:

- BlocksManager.insert: nothing asserted that block data is nested under a
  `data` key rather than spread, nor that the plugins map is forwarded and
  omitted when absent
- convertBlock: nothing covered carrying plugin data to the converted block
- EditorDocument.modifyData: the PluginDataIndex branch had no model-level test
- BlockNode: the initial-data path of plugin node creation was unasserted

Fixing the last one surfaced a bug in BlockNode.serialized: it assigned entries
into a plain object, so a plugin named `__proto__` set the object's prototype
instead of becoming a key and vanished from the serialized block. The entry map
is now built with Object.fromEntries. The previous test only passed because its
expected literal was broken the same way — writing the key as a computed
property, to satisfy the naming-convention lint rule, is what exposed it.

Scores for the changed files: model 90.38 (threshold 75), core 86.72,
collaboration-manager 52.08 (threshold 0, unchanged file-level scores). No
surviving mutants remain on lines this branch touched.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
composeDataFromVersion2 dropped each v2 block's `tunes` silently. It now maps
them onto the v3 `plugins` key:

- names are kept verbatim, so a v3 plugin that adopts a v2 tune's name finds
  its data without a rename table
- object data is copied key by key
- a primitive, an array or null goes under the `value` key, since a plugin entry
  is a key/value map while v2 tune data is any JSON value
- a block with no tunes, or an empty map, produces no `plugins` key
- the entry map is built with Object.fromEntries, so a tune named `__proto__`
  survives instead of setting a prototype

Adds the file's first spec, including the converter's existing data handling,
and an integration test taking a v2 document through the converter into the
model and reading it back with api.blocks.getPluginData.

The spec stubs DOMParser, which the pre-existing inline-fragment extraction
needs and this package's node test environment lacks. That extraction stays
untested, so the file's mutation score is low (25%, threshold 0) — it simply
had no spec at all before.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
- model.md, events.md, index-serialization.md: PluginDataNode,
  PluginDataIndex (`k: "plugin"` with `plugin`/`key` fields),
  PluginDataModifiedEvent, and Index.pluginData
- plugins.md: a new "Per-block plugin data" section for plugin authors — the
  two API calls, the EditorjsPluginDataMap augmentation, and the behaviors that
  bite (key removal, per-key undo granularity, last-writer-wins on the same
  key, preserved data for unregistered plugins, move/convert/split, v2 carry
  over) — plus the two new api.blocks rows and the third type map
- diagrams: model-tree-structure, events-catalog, architecture-overview
- docs-updater agent: map the renamed model entity to docs/model.md

Mentions of the Block Tune *tool kind* stay: they belong to remove-block-tunes.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Every task is done except the final one, which is the ready-to-archive signal:
leaving it unchecked keeps the archive gate quiet until a maintainer comments
/archive on the PR, per CONTRIBUTING.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Six comments added by this change ran to three. Same content, tightened:
the v2 tune mapping, the BlockNode class doc and its `#plugins` field, the
`updatePluginData` contract and `PluginDataFor`'s fallback.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
`PluginDataNode.update` dispatched unconditionally, carried over from
`BlockTune`, where it was nearly harmless because tunes were rarely
written. `updatePluginData` is now a public API that plugins call on every
toggle, and each event becomes an operation for collaborators and a step on
the undo stack — so re-applying the state a plugin just read filled the undo
stack with entries that undo nothing.

Storing the value a key already holds, or removing a key that is not there,
now returns before dispatching. The removal case needs the extra clause:
both sides are `undefined` whether the key is absent or present holding
`undefined`, and only the latter is a real change.

Also locks down the wire format for a removal, which has no test today: the
payload is `undefined`, `JSON.stringify` drops the key outright, and the
removal survives only because reading a missing key gives `undefined` back.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Two clients writing the same plugin data key left one of them on a value
the server does not hold. Remote operations are transformed against the
pending local ones, and the plugin data path returned them untouched, so
the client with an unsent write applied the incoming value over its own --
and since its operation is never echoed back to it, nothing restored what
the server ended up with.

The rule is now the one #transformAgainstDataOperation already applies to
data values: an against-operation with no revision counts as the later of
the two, and the operation being transformed becomes Neutral. It is scoped
to the same block, plugin and key, since nothing else describes the same
value.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
gohabereg and others added 6 commits November 5, 2026 01:19
Plugin names and the keys inside an entry are document data, and both
could collide with the prototype.

PluginDataNode kept its keys on a plain object while the block's own
plugin store already used a null prototype. A `__proto__` key loaded from
a document reached the prototype setter instead of becoming an own
property and vanished from serialization; a first write to a key like
`toString` read the inherited function as its previous value and put that
on the undo stack and the wire. The record is now copied onto a null
prototype, as the outer store is.

`serialized` handed out the live record, so `getPluginData` and
`api.document.data` both exposed an untracked write path into the Model.
Read, change, write back -- the obvious way to use the two methods
together -- changed the document on the read and then emitted nothing,
because the no-op guard found the value already updated. Callers get a
detached copy.

BlocksManager.getPluginData indexed the serialized map directly, so a
plugin named toString or constructor read back as the inherited function
rather than undefined. It checks for an own entry first.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
The cases asserting that a plugin data operation is left alone checked
only that its type was still Modify. That says it was not neutralised and
nothing more: with the untransformed branch returning an operation whose
block index was shifted by 99, all thirty cases still passed. Comparing
the serialized form covers the index, both payloads, the user and the
revision in one assertion.

The two serialization cases were named after a metaphor rather than what
they do, which is a JSON round-trip standing in for what reaches the OT
server.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
A plugin that wrote an object kept a reference into the Model: editing it moved the document
with no write at all, and the write-back that should have announced the change found the value
unchanged and emitted nothing -- no operation for collaborators, no step to undo. The data a
node was constructed with was shared the same way, down from a loaded document.

Incoming values are now cloned on the way in and for the event payload, since an operation and
an undo step both outlive the call that recorded them. Because what is stored is therefore a
copy, the no-op guard compares structurally; `deepEqual` moves into its own util for
`isSameInlineData` to share, and reports a value whose state is not in its own keys -- a `Date`,
a `Map` -- as different rather than as equal to any other of its kind.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
`againstRevision > operation.rev!` was false whenever the left side came off an undo or redo
stack, because those entries are built from model events and never carry a revision. The entry
survived, so undoing a local first write to a key a collaborator had since overwritten wrote
`prevPayload` over their value and deleted it.

An operation with no revision of its own now loses to whatever it is transformed against, which
in that path is only ever an operation the model has already applied. Server operations always
carry a revision, so nothing else reaches the comparison without one.

`#transformAgainstDataOperation` has the same hole for `data` values on `main`; it belongs with
the other pre-existing OT defects on the board rather than in this PR.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…ata follow-ups

The spec change for the stack is merged, so this round's delta specs land here, with the code
that implements them, rather than in a spec PR of their own.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
@gohabereg
gohabereg force-pushed the feat/remove-block-tunes branch from 36fa683 to 973d1c7 Compare November 5, 2026 01:55
@gohabereg
gohabereg force-pushed the feat/plugin-block-data branch from 7aefa42 to 384329c Compare November 5, 2026 01:55
Scoped mutation runs over the files this round touched left six survivors. Four are now dead:

- The array-vs-record kind check in `deepEqual` was only tested with `[]` against `{}`, which
  returns `false` either way. An array and an array-like record agree on `length` and on every
  index, so `{ length: 0 }` is the case that tells the branch apart.
- Array lengths were only compared for arrays that also differed in content, so a matching
  prefix of a longer array went untested.
- The `||` in the kind guard short-circuits the same way as `&&` when neither side is keyed,
  which is all the `Date`-against-`Date` cases did. Mixed sides are what it guards.
- Removing a key that is present and explicitly holds `undefined` -- which only a loaded
  document can produce -- is a real change that no test covered, though the comment beside the
  no-op guard has described it since the write-that-changes-nothing round.

The four left on `copyValue`'s guard all amount to cloning when nothing needs it, which is
observable only for a value that cannot be cloned at all. Tightening that is a contract change
rather than a test gap, so it stays as it is. `model` scores 94% over these files against a
threshold of 75%, with `deepEqual.ts` and `isSameInlineData.ts` at 100%.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
@gohabereg
gohabereg force-pushed the feat/remove-block-tunes branch from 973d1c7 to e163fa1 Compare November 5, 2026 02:02
gohabereg and others added 7 commits November 8, 2026 13:43
… acknowledged

`#sendNextOperation` shifted an operation off `#pendingOperations` in order to send it, and only
pushed it to `#resolvedOperations` -- which nothing reads -- once the server acknowledged it. For
the whole round trip the operation was in neither place, and `#onMessage` transforms incoming
operations against `#pendingOperations` alone: a collaborator's write to the same value arriving
in that window was transformed against nothing, applied over the local one, and never corrected,
since a client's own operations are not echoed back to it.

The convergence rule added earlier covered only the window before an operation is sent, which is
a microtask, while this one is a full round trip -- so it is the window a simultaneous pair of
`updatePluginData` calls actually lands in. `openspec/specs/collaboration-manager/spec.md` already
required this behaviour; the code did not conform.

Safety rests on the server ordering its messages: while an acknowledgement is outstanding, every
remote operation delivered was ordered before the local one, so neutralising it is correct, and
once it arrives, everything after it was ordered later and applies normally.

Reading the head without removing it meant two concurrent `send` calls would both read the same
operation and send it twice, so `#awaitingAcknowledgement` is now claimed before the first await.
The guard on the acknowledgement handler also carries more weight than it did: mistaking a remote
operation for the acknowledgement would now drop a still-in-flight operation from the pending
list, reopening the window this closes, so it has a test of its own.

The tests also close a hole they uncovered: nothing checked that sending ever resumes after an
acknowledgement, only that a queued operation is held back while one is in flight -- so the
acknowledgement gate could have latched shut permanently with the suite still green.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
…ta follow-ups

The convergence rule said "unsent" where it meant "unacknowledged", which is the distinction the
round turned on.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
A registered tune got a `BlockTuneFacade` built and sorted into
`ToolsManager.blockTunes`, and nothing ever read it — no adapter, no
rendering, no model wiring. It was a second, half-built way to do what a
plugin now does, so it goes rather than stays as an alternative to
document around.

Removed from `sdk`: `ToolType.Tune`, the `BlockTune*` contracts and
`BlockTuneFacade`, `BaseToolFacade#isTune()`, `ToolsCollection#blockTunes`,
`ToolTypeToOptions[ToolType.Tune]`, and the tune members of the
`ToolConstructable`/`ToolFacadeClass` unions. The per-tool allow-list goes
too — `BlockToolOptionKey.Tunes`, `UserToolOptions.EnabledBlockTunes`,
`BlockToolFacade#enabledBlockTunes` and `BlockToolFacade#tunes` — because
per-tool filtering belongs to the providers, which get `tool` in their
context. If integrators want the allow-list back it returns through
`options.plugins['block-settings']`, not as a member of the tool contract.

Removed from `core`: the Tune branch of `use()`, the
`getAll(ToolType.Tune)` preparation step, the Tune case in `ToolsFactory`
and `ToolsManager#blockTunes`. `shortcuts-plugin` loses its never-called
`#processBlockTune`.

The removal is guarded by compile-time assertions rather than runtime
ones: under `ts-jest` a stale `@ts-expect-error` is itself a diagnostic,
so each directive fails the suite while the name it points at exists.
`BlockToolOptions['tunes']` is the one member that cannot be asserted —
the interface carries an open index signature for tool-author options, so
every key resolves.

BREAKING CHANGE: registering a tune through `core.use()` or setting a
tool's `tunes` option no longer compiles. Write a plugin instead: it puts
an item in the block settings menu and stores state as per-block plugin
data.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
`docs/plugins.md` loses the registration-table row and gains a line
pointing a would-be tune author at the block settings menu and per-block
plugin data instead; `docs/README.md` and the plugin-lifecycle diagram
drop their `BlockTune` / `ToolType.Tune` / `blockTunes` mentions.

Two live specs are hand-edited because the mechanical archive fold only
rewrites `### Requirement:` blocks: the `sdk` **Purpose** preamble, and
the `shortcuts-plugin` reserved-work note, which now reserves shortcuts
for block settings items rather than for block tunes.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
`ToolsFactory#getConstructor` had no coverage at all, so the switch this
branch removed the Tune case from was unguarded: a mutant collapsing the
remaining Inline case survived. The new spec pins both remaining kinds to
their facades, along with the `defaultBlock` flag, the options handed to
the facade, and the unregistered-tool error. `ToolsFactory.ts` now scores
100 on mutation testing, up from 40.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Task 4.5 stays open: closing PR #157 with links to its three replacement
changes is a public comment, so it waits for the maintainer.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
`MenuConfig` still advertised itself as the shape for "Block Tune's
render()", the last reference in shipped source to the tool kind this
change removes.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
@gohabereg
gohabereg force-pushed the feat/remove-block-tunes branch from e163fa1 to e2760fa Compare November 8, 2026 13:47
Base automatically changed from feat/plugin-block-data to main November 8, 2026 15:51
@gohabereg

Copy link
Copy Markdown
Member Author

/archive plugin-block-data

@github-actions

github-actions Bot commented Nov 8, 2026

Copy link
Copy Markdown
Contributor

❌ openspec archive failed — see the workflow run.

gohabereg and others added 3 commits November 8, 2026 16:11
Archive the change implemented in #192 and sync its delta specs into
the main specs. Restore the original title of the sdk "Plugin package
augments both maps" scenario in the delta so the archive does not read
the rename as a dropped scenario, and fill the Purpose of the new
plugin-block-data spec from the proposal.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TffpCm82NH5xXR1yeBew6Q
Archive the change and sync its core and sdk deltas into the main
specs. The sdk Purpose preamble was already updated by hand earlier in
this PR, as the proposal asked.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TffpCm82NH5xXR1yeBew6Q
@gohabereg
gohabereg added this pull request to the merge queue Nov 8, 2026
Merged via the queue into main with commit 4c027fe Nov 8, 2026
80 checks passed
@gohabereg
gohabereg deleted the feat/remove-block-tunes branch November 8, 2026 16:30
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Projects

None yet

Development

Successfully merging this pull request may close these issues.

4 participants