amalgm 0.1.245 → 0.1.246

package/runtime/scripts/amalgm-mcp/tests/workspace-tree-core.test.js

@@ -6,7 +6,6 @@ const assert = require('node:assert/strict');
 const { can, resolveEffectiveRole } = require('../workspace/tree/access');
 const { isUuidV7, uuidV7, uuidV7Timestamp } = require('../workspace/tree/identity');
 const { applyTreeOperation } = require('../workspace/tree/reducer');
-const { normalizeTreeSnapshot } = require('../workspace/tree/snapshot');
 
 test('UUIDv7 identity is standard, timestamped, and independent of path', () => {
   const now = 1_782_000_123_456;
@@ -71,82 +70,6 @@ test('tree operations preserve identity across rename and reject cycles', () =>
   }), /destination folder does not exist|inside itself/);
 });
 
-test('symlink legality is a portable invariant of the complete live tree', () => {
-  const workspaceId = uuidV7();
-  const folderId = uuidV7();
-  const nestedId = uuidV7();
-  const linkId = uuidV7();
-  const root = {
-    id: workspaceId,
-    workspaceId,
-    parentId: null,
-    kind: 'folder',
-    name: 'Workspace',
-  };
-  let nodes = new Map([[workspaceId, root]]);
-  nodes = applyTreeOperation(nodes, {
-    kind: 'tree.create',
-    workspaceId,
-    nodeId: folderId,
-    parentId: workspaceId,
-    nodeKind: 'folder',
-    name: 'folder',
-  });
-  nodes = applyTreeOperation(nodes, {
-    kind: 'tree.create',
-    workspaceId,
-    nodeId: nestedId,
-    parentId: folderId,
-    nodeKind: 'folder',
-    name: 'nested',
-  });
-  nodes = applyTreeOperation(nodes, {
-    kind: 'tree.create',
-    workspaceId,
-    nodeId: linkId,
-    parentId: nestedId,
-    nodeKind: 'symlink',
-    name: 'entry',
-    symlinkTarget: '../../folder/file.txt',
-  });
-
-  assert.throws(() => applyTreeOperation(nodes, {
-    kind: 'tree.move',
-    workspaceId,
-    nodeId: nestedId,
-    parentId: workspaceId,
-  }), /escapes its workspace/);
-  for (const [index, target] of [
-    '../../../outside',
-    '/tmp/outside',
-    '\\\\server\\share',
-    'C:\\outside',
-    'C:outside',
-  ].entries()) {
-    assert.throws(() => applyTreeOperation(nodes, {
-      kind: 'tree.create',
-      workspaceId,
-      nodeId: uuidV7(Date.now() + index),
-      parentId: workspaceId,
-      nodeKind: 'symlink',
-      name: `unsafe-${index}`,
-      symlinkTarget: target,
-    }), /relative|escapes its workspace/);
-  }
-
-  const snapshot = {
-    schemaVersion: 1,
-    workspaceId,
-    version: 0,
-    nodes: Array.from(nodes.values()).map((node) => ({ ...node })),
-  };
-  snapshot.nodes.find((node) => node.id === linkId).symlinkTarget = '../../../outside';
-  assert.throws(
-    () => normalizeTreeSnapshot(snapshot),
-    /escapes its workspace/,
-  );
-});
-
 test('trash cascades preserve independently trashed children', () => {
   const workspaceId = uuidV7();
   const folderId = uuidV7();
@@ -176,11 +99,9 @@ test('trash cascades preserve independently trashed children', () => {
     kind: 'tree.trash', workspaceId, nodeId: fileId, trashedAt: '2026-07-21T00:01:00.000Z',
   });
   nodes = applyTreeOperation(nodes, {
-    kind: 'tree.trash', workspaceId, nodeId: folderId, trashedAt: '2026-07-21T00:01:00.000Z',
+    kind: 'tree.trash', workspaceId, nodeId: folderId, trashedAt: '2026-07-21T00:02:00.000Z',
   });
   assert.equal(nodes.get(fileId).trashedAt, '2026-07-21T00:01:00.000Z');
-  assert.equal(nodes.get(fileId).trashComponentId, fileId);
-  assert.equal(nodes.get(folderId).trashComponentId, folderId);
 
   nodes = applyTreeOperation(nodes, {
     kind: 'tree.restore', workspaceId, nodeId: folderId,
@@ -190,115 +111,4 @@ test('trash cascades preserve independently trashed children', () => {
   assert.throws(() => applyTreeOperation(nodes, {
     kind: 'tree.restore', workspaceId, nodeId: folderId,
   }), /must be trashed/);
-
-  nodes = applyTreeOperation(nodes, {
-    kind: 'tree.purge', workspaceId, nodeId: fileId,
-  });
-  assert.ok(nodes.get(fileId).purgedAt);
-  assert.equal(nodes.get(fileId).trashComponentId, null);
-});
-
-test('snapshots require active trash provenance and retire it on purge', () => {
-  const workspaceId = uuidV7();
-  const fileId = uuidV7();
-  const base = {
-    schemaVersion: 1,
-    workspaceId,
-    version: 1,
-    nodes: [
-      {
-        id: workspaceId,
-        workspaceId,
-        parentId: null,
-        kind: 'folder',
-        name: 'Workspace',
-      },
-      {
-        id: fileId,
-        workspaceId,
-        parentId: workspaceId,
-        kind: 'file',
-        name: 'note.txt',
-        trashedAt: '2026-07-21T00:01:00.000Z',
-      },
-    ],
-  };
-  assert.throws(
-    () => normalizeTreeSnapshot(base),
-    /requires explicit trash provenance/,
-  );
-  const cyclic = structuredClone(base);
-  cyclic.nodes[1].trashedAt = null;
-  cyclic.nodes[1].parentId = fileId;
-  assert.throws(() => normalizeTreeSnapshot(cyclic), /contains a cycle/);
-
-  const siblingId = uuidV7();
-  const nonAncestor = structuredClone(base);
-  nonAncestor.nodes.push({
-    id: siblingId,
-    workspaceId,
-    parentId: workspaceId,
-    kind: 'folder',
-    name: 'other-trash',
-    trashedAt: '2026-07-21T00:01:00.000Z',
-    trashComponentId: siblingId,
-  });
-  nonAncestor.nodes[1].trashComponentId = siblingId;
-  assert.throws(() => normalizeTreeSnapshot(nonAncestor), /is not an ancestor/);
-
-  const purged = structuredClone(base);
-  purged.nodes[1].purgedAt = '2026-07-21T00:02:00.000Z';
-  const normalized = normalizeTreeSnapshot(purged);
-  assert.equal(normalized.nodes.get(fileId).trashComponentId, null);
-});
-
-test('snapshot ancestry validation stays bounded on a deep tree', { timeout: 10_000 }, () => {
-  const workspaceId = uuidV7();
-  const componentId = uuidV7();
-  const changedAt = '2026-07-21T00:01:00.000Z';
-  const nodes = [{
-    id: workspaceId,
-    workspaceId,
-    parentId: null,
-    kind: 'folder',
-    name: 'Workspace',
-  }, {
-    id: componentId,
-    workspaceId,
-    parentId: workspaceId,
-    kind: 'folder',
-    name: 'trash-root',
-  }];
-  let parentId = componentId;
-  for (let index = 0; index < 20_000; index += 1) {
-    const id = uuidV7();
-    nodes.push({
-      id,
-      workspaceId,
-      parentId,
-      kind: 'folder',
-      name: `level-${index}`,
-    });
-    parentId = id;
-  }
-  const live = normalizeTreeSnapshot({
-    schemaVersion: 1,
-    workspaceId,
-    version: 1,
-    nodes,
-  });
-  const trashed = applyTreeOperation(live.nodes, {
-    kind: 'tree.trash',
-    workspaceId,
-    nodeId: componentId,
-    trashedAt: changedAt,
-  });
-  const normalized = normalizeTreeSnapshot({
-    schemaVersion: 1,
-    workspaceId,
-    version: 2,
-    nodes: Array.from(trashed.values()),
-  });
-  assert.equal(normalized.nodes.size, nodes.length);
-  assert.equal(normalized.nodes.get(parentId).trashComponentId, componentId);
 });