@vgai/sdk 0.5.2 → 0.5.3

package/src/project/component-operations.ts

@@ -1,337 +0,0 @@
-/**
- * `project.scene.component.*` (B2, §8 B2 "component list/add/update/remove").
- *
- * A component's identity within an entity is its NAME (the key in
- * `entity.components`, a `Record<string, Record<string, ComponentValue>>` —
- * see `packages/engine/src/scene/schema/entity.ts`'s `ComponentsSchema`) — so
- * "id-aware" here means addressed by that name, never by e.g. iteration
- * order. Every mutation reuses the exact same path as
- * `project.scene.entity.update`: read the entity (by stable id), compute a
- * new `components` record, hand the FULL merged entity to applyDiff's
- * `update` op. No separate component-patching logic exists.
- */
-
-import type { SceneEntity } from '@vgai/engine/scene/scene-types';
-import { z } from 'zod';
-import { ToolError } from '../errors.js';
-import { defineTool, type ToolRegistry } from '../registry.js';
-import { finalizeSceneMutation } from './entity-operations.js';
-import {
-  APPLY_DIFF_FAILED_ERROR,
-  applyDiffOrThrow,
-  readAndParseScene,
-  SCENE_INVALID_ERROR,
-} from './scene-operations.js';
-import {
-  BaseHashField,
-  CONFLICT_ERROR,
-  checkNotStale,
-  DryRunField,
-  ENTITY_NOT_FOUND_ERROR,
-  FILE_NOT_FOUND_ERROR,
-  mutationResultSchema,
-  NO_PROJECT_ROOT_ERROR,
-  PATH_OUTSIDE_PROJECT_ERROR,
-  requireEntityById,
-  requireProjectRoot,
-} from './shared.js';
-
-const ComponentDataValueSchema = z.union([
-  z.number(),
-  z.string(),
-  z.boolean(),
-  z.array(z.number()),
-  z.array(z.string()),
-  z.array(z.boolean()),
-]);
-const ComponentDataSchema = z.record(z.string(), ComponentDataValueSchema);
-
-export const COMPONENT_NOT_FOUND_ERROR = {
-  code: 'COMPONENT_NOT_FOUND',
-  summary: 'No component with the given name is attached to this entity.',
-  data: z.object({ entityId: z.string(), componentName: z.string() }),
-} as const;
-
-export const COMPONENT_ALREADY_EXISTS_ERROR = {
-  code: 'COMPONENT_ALREADY_EXISTS',
-  summary:
-    'A component with this name is already attached to the entity — use component.update instead.',
-  data: z.object({ entityId: z.string(), componentName: z.string() }),
-} as const;
-
-/** Build the full entity payload applyDiff's `update` op needs, with `components` replaced by `newComponents`. */
-function entityWithComponents(
-  entity: SceneEntity,
-  newComponents: Record<string, Record<string, unknown>>,
-): SceneEntity {
-  const { id: _id, children: _children, ...fields } = entity;
-  return { ...fields, components: newComponents } as SceneEntity;
-}
-
-// ---------------------------------------------------------------------------
-// project.scene.component.list
-// ---------------------------------------------------------------------------
-
-const ProjectSceneComponentListInput = z.object({
-  scenePath: z.string().describe('Project-relative path to the .vscn.json scene file.'),
-  entityId: z.string().describe('Entity to list components for.'),
-});
-
-export const projectSceneComponentList = defineTool({
-  name: 'project.scene.component.list',
-  summary: 'List every component (by name) attached to an entity.',
-  description: 'Read-only. Resolves the entity by stable id.',
-  input: ProjectSceneComponentListInput,
-  result: z.object({
-    entityId: z.string(),
-    components: z
-      .record(z.string(), ComponentDataSchema)
-      .describe('Component name -> its data record.'),
-  }),
-  errors: [
-    NO_PROJECT_ROOT_ERROR,
-    PATH_OUTSIDE_PROJECT_ERROR,
-    FILE_NOT_FOUND_ERROR,
-    SCENE_INVALID_ERROR,
-    ENTITY_NOT_FOUND_ERROR,
-  ],
-  requires: { project: true },
-  host: 'node',
-  mutates: false,
-  supportsDryRun: false,
-  permission: { risk: 'read', summary: 'Reads a scene file; no writes.' },
-  async impl(input, ctx) {
-    const projectRoot = requireProjectRoot(ctx);
-    const { scene } = readAndParseScene(projectRoot, input.scenePath);
-    const entity = requireEntityById(scene.entities, input.entityId);
-    return { entityId: input.entityId, components: entity.components ?? {} };
-  },
-});
-
-// ---------------------------------------------------------------------------
-// project.scene.component.add
-// ---------------------------------------------------------------------------
-
-const ProjectSceneComponentAddInput = z.object({
-  scenePath: z.string().describe('Project-relative path to the .vscn.json scene file.'),
-  entityId: z.string().describe('Entity to attach the component to.'),
-  componentName: z.string().describe('Component name (record key).'),
-  data: ComponentDataSchema.describe('Initial component data.'),
-  dryRun: DryRunField,
-  baseHash: BaseHashField,
-});
-
-const ComponentAfterSchema = z.object({
-  entityId: z.string(),
-  componentName: z.string(),
-  data: z.unknown(),
-});
-
-export const projectSceneComponentAdd = defineTool({
-  name: 'project.scene.component.add',
-  summary: 'Attach a new named component to an entity.',
-  description:
-    'Delegates to applyDiff’s `update` op with a merged components record — same reused write path as project.scene.entity.update.',
-  input: ProjectSceneComponentAddInput,
-  result: mutationResultSchema(ComponentAfterSchema),
-  errors: [
-    NO_PROJECT_ROOT_ERROR,
-    PATH_OUTSIDE_PROJECT_ERROR,
-    FILE_NOT_FOUND_ERROR,
-    SCENE_INVALID_ERROR,
-    APPLY_DIFF_FAILED_ERROR,
-    CONFLICT_ERROR,
-    ENTITY_NOT_FOUND_ERROR,
-    COMPONENT_ALREADY_EXISTS_ERROR,
-  ],
-  requires: { project: true },
-  host: 'node',
-  mutates: true,
-  supportsDryRun: true,
-  permission: { risk: 'write', summary: 'Writes the target scene file.' },
-  async impl(input, ctx) {
-    const projectRoot = requireProjectRoot(ctx);
-    const { absPath, hash, scene } = readAndParseScene(projectRoot, input.scenePath);
-    checkNotStale(absPath, hash, input.baseHash);
-
-    const entity = requireEntityById(scene.entities, input.entityId);
-    const existing = entity.components ?? {};
-    if (input.componentName in existing) {
-      throw new ToolError(
-        'COMPONENT_ALREADY_EXISTS',
-        `Entity "${input.entityId}" already has a component named "${input.componentName}" — use project.scene.component.update instead.`,
-        { entityId: input.entityId, componentName: input.componentName },
-      );
-    }
-    const newComponents = { ...existing, [input.componentName]: input.data };
-
-    const result = applyDiffOrThrow(scene, {
-      ops: [
-        { type: 'update', id: input.entityId, entity: entityWithComponents(entity, newComponents) },
-      ],
-      environmentChanged: false,
-      metaChanged: false,
-    });
-
-    return finalizeSceneMutation(absPath, input.scenePath, result, input.dryRun ?? false, null, {
-      entityId: input.entityId,
-      componentName: input.componentName,
-      data: input.data,
-    });
-  },
-});
-
-// ---------------------------------------------------------------------------
-// project.scene.component.update — merge new fields onto the existing component's data.
-// ---------------------------------------------------------------------------
-
-const ProjectSceneComponentUpdateInput = z.object({
-  scenePath: z.string().describe('Project-relative path to the .vscn.json scene file.'),
-  entityId: z.string().describe('Entity the component is attached to.'),
-  componentName: z.string().describe('Component name (record key) to update.'),
-  data: ComponentDataSchema.describe(
-    'Fields to overlay onto the component’s current data (a merge).',
-  ),
-  dryRun: DryRunField,
-  baseHash: BaseHashField,
-});
-
-export const projectSceneComponentUpdate = defineTool({
-  name: 'project.scene.component.update',
-  summary: 'Merge field changes onto an existing named component.',
-  description: 'Delegates to applyDiff’s `update` op with a merged components record.',
-  input: ProjectSceneComponentUpdateInput,
-  result: mutationResultSchema(ComponentAfterSchema),
-  errors: [
-    NO_PROJECT_ROOT_ERROR,
-    PATH_OUTSIDE_PROJECT_ERROR,
-    FILE_NOT_FOUND_ERROR,
-    SCENE_INVALID_ERROR,
-    APPLY_DIFF_FAILED_ERROR,
-    CONFLICT_ERROR,
-    ENTITY_NOT_FOUND_ERROR,
-    COMPONENT_NOT_FOUND_ERROR,
-  ],
-  requires: { project: true },
-  host: 'node',
-  mutates: true,
-  supportsDryRun: true,
-  permission: { risk: 'write', summary: 'Writes the target scene file.' },
-  async impl(input, ctx) {
-    const projectRoot = requireProjectRoot(ctx);
-    const { absPath, hash, scene } = readAndParseScene(projectRoot, input.scenePath);
-    checkNotStale(absPath, hash, input.baseHash);
-
-    const entity = requireEntityById(scene.entities, input.entityId);
-    const existing = entity.components ?? {};
-    const currentData = existing[input.componentName];
-    if (currentData === undefined) {
-      throw new ToolError(
-        'COMPONENT_NOT_FOUND',
-        `Entity "${input.entityId}" has no component named "${input.componentName}".`,
-        { entityId: input.entityId, componentName: input.componentName },
-      );
-    }
-    const mergedData = { ...currentData, ...input.data };
-    const newComponents = { ...existing, [input.componentName]: mergedData };
-
-    const result = applyDiffOrThrow(scene, {
-      ops: [
-        { type: 'update', id: input.entityId, entity: entityWithComponents(entity, newComponents) },
-      ],
-      environmentChanged: false,
-      metaChanged: false,
-    });
-
-    return finalizeSceneMutation(
-      absPath,
-      input.scenePath,
-      result,
-      input.dryRun ?? false,
-      { entityId: input.entityId, componentName: input.componentName, data: currentData },
-      { entityId: input.entityId, componentName: input.componentName, data: mergedData },
-    );
-  },
-});
-
-// ---------------------------------------------------------------------------
-// project.scene.component.remove
-// ---------------------------------------------------------------------------
-
-const ProjectSceneComponentRemoveInput = z.object({
-  scenePath: z.string().describe('Project-relative path to the .vscn.json scene file.'),
-  entityId: z.string().describe('Entity the component is attached to.'),
-  componentName: z.string().describe('Component name (record key) to remove.'),
-  dryRun: DryRunField,
-  baseHash: BaseHashField,
-});
-
-export const projectSceneComponentRemove = defineTool({
-  name: 'project.scene.component.remove',
-  summary: 'Detach a named component from an entity.',
-  description:
-    'Delegates to applyDiff’s `update` op with the component key deleted from the components record.',
-  input: ProjectSceneComponentRemoveInput,
-  result: mutationResultSchema(ComponentAfterSchema),
-  errors: [
-    NO_PROJECT_ROOT_ERROR,
-    PATH_OUTSIDE_PROJECT_ERROR,
-    FILE_NOT_FOUND_ERROR,
-    SCENE_INVALID_ERROR,
-    APPLY_DIFF_FAILED_ERROR,
-    CONFLICT_ERROR,
-    ENTITY_NOT_FOUND_ERROR,
-    COMPONENT_NOT_FOUND_ERROR,
-  ],
-  requires: { project: true },
-  host: 'node',
-  mutates: true,
-  supportsDryRun: true,
-  permission: {
-    risk: 'destructive',
-    summary: 'Removes a component from an entity in the target scene file.',
-  },
-  async impl(input, ctx) {
-    const projectRoot = requireProjectRoot(ctx);
-    const { absPath, hash, scene } = readAndParseScene(projectRoot, input.scenePath);
-    checkNotStale(absPath, hash, input.baseHash);
-
-    const entity = requireEntityById(scene.entities, input.entityId);
-    const existing = entity.components ?? {};
-    const currentData = existing[input.componentName];
-    if (currentData === undefined) {
-      throw new ToolError(
-        'COMPONENT_NOT_FOUND',
-        `Entity "${input.entityId}" has no component named "${input.componentName}".`,
-        { entityId: input.entityId, componentName: input.componentName },
-      );
-    }
-    const newComponents = { ...existing };
-    delete newComponents[input.componentName];
-
-    const result = applyDiffOrThrow(scene, {
-      ops: [
-        { type: 'update', id: input.entityId, entity: entityWithComponents(entity, newComponents) },
-      ],
-      environmentChanged: false,
-      metaChanged: false,
-    });
-
-    return finalizeSceneMutation(
-      absPath,
-      input.scenePath,
-      result,
-      input.dryRun ?? false,
-      { entityId: input.entityId, componentName: input.componentName, data: currentData },
-      { entityId: input.entityId, componentName: input.componentName, data: null },
-    );
-  },
-});
-
-/** Register every B2 `project.scene.component.*` operation onto `registry`. */
-export function registerComponentOperations(registry: ToolRegistry): void {
-  registry.register(projectSceneComponentList);
-  registry.register(projectSceneComponentAdd);
-  registry.register(projectSceneComponentUpdate);
-  registry.register(projectSceneComponentRemove);
-}

package/src/project/entity-operations.ts

@@ -1,366 +0,0 @@
-/**
- * `project.scene.entity.*` (B2, §8 B2 "entity add/update/move/remove").
- *
- * ID-AWARE BY CONSTRUCTION: every op here targets an entity by its stable
- * `id` (never an array index) and builds exactly one `DiffOp`
- * (`@vgai/engine/scene/scene-diff-types`) for `applyDiff`
- * (`@vgai/engine/scene/scene-apply`) to execute — the SAME op-ordering/
- * placement machinery `project.scene.apply` and `vgai apply-diff` use. This
- * module only assembles the single-op `SceneDiff`; it never walks/splices the
- * entity tree itself.
- *
- * `entity.update` is a convenience MERGE over applyDiff's `update` op (which
- * is itself a full field replace — see scene-apply.ts's jsdoc): the impl
- * reads the entity's current fields, overlays the caller's `fields` on top,
- * and hands the FULL merged object to applyDiff as the update payload — so a
- * caller can patch just `{ transform: { position: [...] } }` without
- * re-stating every other field, while applyDiff still only ever sees (and
- * only ever needs to implement) a full-replace update.
- */
-
-import { parseSceneFile, SceneParseError } from '@vgai/engine/scene/parse';
-import type { applyDiff } from '@vgai/engine/scene/scene-apply';
-import type { SceneEntity } from '@vgai/engine/scene/scene-types';
-import { SceneEntitySchema } from '@vgai/engine/scene/schema/entity';
-import { z } from 'zod';
-import { ToolError } from '../errors.js';
-import { defineTool, type ToolRegistry } from '../registry.js';
-import {
-  APPLY_DIFF_FAILED_ERROR,
-  applyDiffOrThrow,
-  readAndParseScene,
-  SCENE_INVALID_ERROR,
-} from './scene-operations.js';
-import {
-  BaseHashField,
-  CONFLICT_ERROR,
-  checkNotStale,
-  DryRunField,
-  ENTITY_NOT_FOUND_ERROR,
-  FILE_NOT_FOUND_ERROR,
-  findEntityById,
-  mutationResultSchema,
-  NO_PROJECT_ROOT_ERROR,
-  PATH_OUTSIDE_PROJECT_ERROR,
-  requireEntityById,
-  requireProjectRoot,
-  writeFileAtomic,
-} from './shared.js';
-
-const EntityAfterSchema = z.object({
-  entity: z
-    .unknown()
-    .describe('The affected entity after the change (or that WOULD result), by id.'),
-});
-
-/**
- * Shared write tail: re-validate the whole document, honor dryRun, write via
- * checkNotStale-guarded atomic write, and shape the mutation envelope.
- * `before`/`after` are passed through AS GIVEN (not wrapped) — callers shape
- * them to match their own op's declared `after` result schema (entity ops
- * wrap as `{ entity }`; component-operations.ts's callers pass their own
- * `{ entityId, componentName, data }` shape directly).
- */
-function finalizeSceneMutation<TBefore, TAfter>(
-  absPath: string,
-  scenePath: string,
-  result: SceneFileLike,
-  dryRun: boolean,
-  before: TBefore,
-  after: TAfter,
-) {
-  try {
-    parseSceneFile(result, scenePath);
-  } catch (err) {
-    if (err instanceof SceneParseError) {
-      throw new ToolError('SCENE_INVALID', `Result fails validation: ${err.message}`, {
-        issues: err.issues.map((i) => `${i.path.join('.')}: ${i.message}`),
-      });
-    }
-    throw err;
-  }
-  if (!dryRun) {
-    writeFileAtomic(absPath, `${JSON.stringify(result, null, 2)}\n`);
-  }
-  return { dryRun, written: !dryRun, filesChanged: [absPath], before, after };
-}
-
-// SceneFile is only used structurally here (applyDiff's return type) — avoid
-// a second import cycle by aliasing via the already-imported applyDiff's own
-// parameter type through a small local type alias.
-type SceneFileLike = ReturnType<typeof applyDiff>;
-
-// ---------------------------------------------------------------------------
-// project.scene.entity.add
-// ---------------------------------------------------------------------------
-
-const ProjectSceneEntityAddInput = z.object({
-  scenePath: z.string().describe('Project-relative path to the .vscn.json scene file.'),
-  parentId: z.string().nullable().describe('Parent entity id, or null for a top-level entity.'),
-  index: z.number().int().min(0).describe('Target position among the (new) parent’s children.'),
-  entity: SceneEntitySchema.describe('The entity to insert (id auto-generated if omitted).'),
-  dryRun: DryRunField,
-  baseHash: BaseHashField,
-});
-
-export const projectSceneEntityAdd = defineTool({
-  name: 'project.scene.entity.add',
-  summary: 'Insert a new entity into a scene, by parent id + index.',
-  description:
-    'Builds a single `add` DiffOp and delegates to applyDiff — the same insertion/placement logic project.scene.apply uses.',
-  input: ProjectSceneEntityAddInput,
-  result: mutationResultSchema(EntityAfterSchema),
-  errors: [
-    NO_PROJECT_ROOT_ERROR,
-    PATH_OUTSIDE_PROJECT_ERROR,
-    FILE_NOT_FOUND_ERROR,
-    SCENE_INVALID_ERROR,
-    APPLY_DIFF_FAILED_ERROR,
-    CONFLICT_ERROR,
-  ],
-  requires: { project: true },
-  host: 'node',
-  mutates: true,
-  supportsDryRun: true,
-  permission: { risk: 'write', summary: 'Writes the target scene file.' },
-  async impl(input, ctx) {
-    const projectRoot = requireProjectRoot(ctx);
-    const { absPath, hash, scene } = readAndParseScene(projectRoot, input.scenePath);
-    checkNotStale(absPath, hash, input.baseHash);
-
-    const result = applyDiffOrThrow(scene, {
-      ops: [
-        {
-          type: 'add',
-          entity: input.entity as SceneEntity,
-          parentId: input.parentId,
-          index: input.index,
-        },
-      ],
-      environmentChanged: false,
-      metaChanged: false,
-    });
-
-    // Report the entity as it landed (id may have been auto-generated).
-    const after = input.entity.id
-      ? findEntityById(result.entities, input.entity.id)
-      : findEntityById(result.entities, findNewestSiblingId(result, input.parentId, input.index));
-
-    return finalizeSceneMutation(
-      absPath,
-      input.scenePath,
-      result,
-      input.dryRun ?? false,
-      { entity: null },
-      { entity: after ?? null },
-    );
-  },
-});
-
-/** Best-effort: when the caller omitted `id`, look up whatever landed at the target position after the add. */
-function findNewestSiblingId(scene: SceneFileLike, parentId: string | null, index: number): string {
-  const siblings =
-    parentId === null ? scene.entities : (findEntityById(scene.entities, parentId)?.children ?? []);
-  const clamped = Math.min(index, siblings.length - 1);
-  return siblings[clamped]?.id ?? '';
-}
-
-// ---------------------------------------------------------------------------
-// project.scene.entity.update — merge-onto-full-replace convenience.
-// ---------------------------------------------------------------------------
-
-const ProjectSceneEntityUpdateInput = z.object({
-  scenePath: z.string().describe('Project-relative path to the .vscn.json scene file.'),
-  id: z.string().describe('Id of the entity to update (never an array index).'),
-  fields: z
-    .record(z.string(), z.unknown())
-    .describe(
-      'Fields to overlay onto the entity’s CURRENT fields (a merge, not a full replace — ' +
-        'unlike the underlying applyDiff `update` op, which this is built on top of). `id` and ' +
-        '`children` are ignored if present.',
-    ),
-  dryRun: DryRunField,
-  baseHash: BaseHashField,
-});
-
-export const projectSceneEntityUpdate = defineTool({
-  name: 'project.scene.entity.update',
-  summary: 'Merge field changes onto an existing entity, addressed by stable id.',
-  description:
-    'ID-aware — resolves the target by `id` regardless of its position/reordering in the ' +
-    'entities array. Reads the entity’s current fields, overlays `fields`, and hands the merged ' +
-    'whole object to applyDiff’s `update` op (a full replace under the hood) so nothing the ' +
-    'caller did not mention is lost.',
-  input: ProjectSceneEntityUpdateInput,
-  result: mutationResultSchema(EntityAfterSchema),
-  errors: [
-    NO_PROJECT_ROOT_ERROR,
-    PATH_OUTSIDE_PROJECT_ERROR,
-    FILE_NOT_FOUND_ERROR,
-    SCENE_INVALID_ERROR,
-    APPLY_DIFF_FAILED_ERROR,
-    CONFLICT_ERROR,
-    ENTITY_NOT_FOUND_ERROR,
-  ],
-  requires: { project: true },
-  host: 'node',
-  mutates: true,
-  supportsDryRun: true,
-  permission: { risk: 'write', summary: 'Writes the target scene file.' },
-  async impl(input, ctx) {
-    const projectRoot = requireProjectRoot(ctx);
-    const { absPath, hash, scene } = readAndParseScene(projectRoot, input.scenePath);
-    checkNotStale(absPath, hash, input.baseHash);
-
-    const current = requireEntityById(scene.entities, input.id);
-    const { id: _id, children: _children, ...currentFields } = current;
-    const {
-      id: _fid,
-      children: _fchildren,
-      ...overlayFields
-    } = input.fields as Record<string, unknown>;
-    const merged = { ...currentFields, ...overlayFields };
-
-    const result = applyDiffOrThrow(scene, {
-      ops: [{ type: 'update', id: input.id, entity: merged as SceneEntity }],
-      environmentChanged: false,
-      metaChanged: false,
-    });
-
-    const after = findEntityById(result.entities, input.id) ?? null;
-    return finalizeSceneMutation(
-      absPath,
-      input.scenePath,
-      result,
-      input.dryRun ?? false,
-      { entity: current },
-      { entity: after },
-    );
-  },
-});
-
-// ---------------------------------------------------------------------------
-// project.scene.entity.move
-// ---------------------------------------------------------------------------
-
-const ProjectSceneEntityMoveInput = z.object({
-  scenePath: z.string().describe('Project-relative path to the .vscn.json scene file.'),
-  id: z.string().describe('Id of the entity to move.'),
-  parentId: z.string().nullable().describe('New parent entity id, or null for top-level.'),
-  index: z.number().int().min(0).describe('Target position among the new parent’s children.'),
-  dryRun: DryRunField,
-  baseHash: BaseHashField,
-});
-
-export const projectSceneEntityMove = defineTool({
-  name: 'project.scene.entity.move',
-  summary: 'Reparent and/or reorder an existing entity, addressed by stable id.',
-  description: 'Builds a single `move` DiffOp and delegates to applyDiff.',
-  input: ProjectSceneEntityMoveInput,
-  result: mutationResultSchema(EntityAfterSchema),
-  errors: [
-    NO_PROJECT_ROOT_ERROR,
-    PATH_OUTSIDE_PROJECT_ERROR,
-    FILE_NOT_FOUND_ERROR,
-    SCENE_INVALID_ERROR,
-    APPLY_DIFF_FAILED_ERROR,
-    CONFLICT_ERROR,
-    ENTITY_NOT_FOUND_ERROR,
-  ],
-  requires: { project: true },
-  host: 'node',
-  mutates: true,
-  supportsDryRun: true,
-  permission: { risk: 'write', summary: 'Writes the target scene file.' },
-  async impl(input, ctx) {
-    const projectRoot = requireProjectRoot(ctx);
-    const { absPath, hash, scene } = readAndParseScene(projectRoot, input.scenePath);
-    checkNotStale(absPath, hash, input.baseHash);
-
-    const before = requireEntityById(scene.entities, input.id);
-    const result = applyDiffOrThrow(scene, {
-      ops: [{ type: 'move', id: input.id, parentId: input.parentId, index: input.index }],
-      environmentChanged: false,
-      metaChanged: false,
-    });
-    const after = findEntityById(result.entities, input.id) ?? null;
-
-    return finalizeSceneMutation(
-      absPath,
-      input.scenePath,
-      result,
-      input.dryRun ?? false,
-      { entity: before },
-      { entity: after },
-    );
-  },
-});
-
-// ---------------------------------------------------------------------------
-// project.scene.entity.remove
-// ---------------------------------------------------------------------------
-
-const ProjectSceneEntityRemoveInput = z.object({
-  scenePath: z.string().describe('Project-relative path to the .vscn.json scene file.'),
-  id: z.string().describe('Id of the entity (and its subtree) to remove.'),
-  dryRun: DryRunField,
-  baseHash: BaseHashField,
-});
-
-export const projectSceneEntityRemove = defineTool({
-  name: 'project.scene.entity.remove',
-  summary: 'Delete an entity (and its subtree), addressed by stable id.',
-  description: 'Builds a single `remove` DiffOp and delegates to applyDiff.',
-  input: ProjectSceneEntityRemoveInput,
-  result: mutationResultSchema(EntityAfterSchema),
-  errors: [
-    NO_PROJECT_ROOT_ERROR,
-    PATH_OUTSIDE_PROJECT_ERROR,
-    FILE_NOT_FOUND_ERROR,
-    SCENE_INVALID_ERROR,
-    APPLY_DIFF_FAILED_ERROR,
-    CONFLICT_ERROR,
-    ENTITY_NOT_FOUND_ERROR,
-  ],
-  requires: { project: true },
-  host: 'node',
-  mutates: true,
-  supportsDryRun: true,
-  permission: {
-    risk: 'destructive',
-    summary: 'Deletes an entity subtree from the target scene file.',
-  },
-  async impl(input, ctx) {
-    const projectRoot = requireProjectRoot(ctx);
-    const { absPath, hash, scene } = readAndParseScene(projectRoot, input.scenePath);
-    checkNotStale(absPath, hash, input.baseHash);
-
-    const before = requireEntityById(scene.entities, input.id);
-    const result = applyDiffOrThrow(scene, {
-      ops: [{ type: 'remove', id: input.id }],
-      environmentChanged: false,
-      metaChanged: false,
-    });
-
-    return finalizeSceneMutation(
-      absPath,
-      input.scenePath,
-      result,
-      input.dryRun ?? false,
-      { entity: before },
-      { entity: null },
-    );
-  },
-});
-
-/** Register every B2 `project.scene.entity.*` operation onto `registry`. */
-export function registerEntityOperations(registry: ToolRegistry): void {
-  registry.register(projectSceneEntityAdd);
-  registry.register(projectSceneEntityUpdate);
-  registry.register(projectSceneEntityMove);
-  registry.register(projectSceneEntityRemove);
-}
-
-// Re-exported for component-operations.ts (avoids a second copy of the
-// "merge fields -> applyDiff update -> finalize" plumbing).
-export { finalizeSceneMutation };