amalgm 0.1.260 → 0.1.261

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.260",
+  "version": "0.1.261",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/registration/entity-cloud.js

@@ -124,7 +124,15 @@ function parseSnapshot(bytes) {
  * no watcher imports: a cloud record may be known on this machine long before
  * `amalgm add <uuid>` chooses and validates local ground for it.
  */
-function createEntityCloud({ db, userId, deviceId, content = null, repoStates = null, repoTransportFor = null }) {
+function createEntityCloud({
+  db,
+  userId,
+  deviceId,
+  content = null,
+  repoStates = null,
+  repoTransportFor = null,
+  recordAt = null,
+}) {
   if (!db) throw new Error('createEntityCloud requires an identity database');
   const ownerUserId = typeof userId === 'string' && userId ? userId : null;
   const localDeviceId = typeof deviceId === 'string' && deviceId ? deviceId : null;
@@ -155,17 +163,62 @@ function createEntityCloud({ db, userId, deviceId, content = null, repoStates =
     return snapshotFromRecords(records.map(cloudRecord));
   }
 
-  function queueContent(input, resourceId, { queue = false } = {}) {
-    const record = cloudRecord(input);
-    const head = contentHead(record);
-    if (!head) return;
-    if (!content || typeof content.has !== 'function') {
-      throw new Error('file entity content is unavailable: registration must capture bytes before it records their cloud head');
+  /**
+   * Select bytes by the root representation that reconstructs them. A
+   * repository's Repocard transport contains its worktree, so child file rows
+   * retain their UUID/version facts but never create duplicate cloud cargo.
+   * Ordinary workspace files still carry their own content, and a nested
+   * repository carries its own transport.
+   */
+  function contentHeads(records, { fallbackRecordAt = recordAt } = {}) {
+    const normalized = (records || []).map(cloudRecord);
+    const supplied = new Map(normalized.map((record) => [record.uuid, record]));
+    const lookup = (uuid) => {
+      const known = supplied.get(uuid);
+      if (known) return known;
+      const fallback = typeof fallbackRecordAt === 'function' ? fallbackRecordAt(uuid) : null;
+      return fallback ? cloudRecord(fallback) : null;
+    };
+
+    function enclosedByRepository(record) {
+      const seen = new Set([record.uuid]);
+      let parentUUID = record.parentUUID;
+      while (parentUUID !== null) {
+        if (seen.has(parentUUID)) throw new Error(`cloud entity ${record.uuid} has a cyclic parent chain`);
+        seen.add(parentUUID);
+        const parent = lookup(parentUUID);
+        // Missing ancestry retains content rather than risking an ordinary
+        // file whose only bytes were silently skipped.
+        if (!parent) return false;
+        if (parent.type === 'repo.git') return true;
+        parentUUID = parent.parentUUID;
+      }
+      return false;
+    }
+
+    const heads = [];
+    const seen = new Set();
+    for (const record of normalized) {
+      const contentHash = contentHead(record);
+      if (!contentHash) continue;
+      if (['file.text', 'file.binary'].includes(record.type) && enclosedByRepository(record)) continue;
+      if (seen.has(contentHash)) continue;
+      seen.add(contentHash);
+      heads.push({ record, contentHash });
     }
-    if (!content.has({ contentHash: head })) {
-      throw new Error('file entity bytes were not captured before its cloud head committed');
+    return heads;
+  }
+
+  function queueContentHeads(records, resourceId, { queue = false, fallbackRecordAt = recordAt } = {}) {
+    for (const { contentHash } of contentHeads(records, { fallbackRecordAt })) {
+      if (!content || typeof content.has !== 'function') {
+        throw new Error('file entity content is unavailable: registration must capture bytes before it records their cloud head');
+      }
+      if (!content.has({ contentHash })) {
+        throw new Error('file entity bytes were not captured before its cloud head committed');
+      }
+      if (queue) content.ensureUpload({ resourceId, contentHash });
     }
-    if (queue) content.ensureUpload({ resourceId, contentHash: head });
   }
 
   function replica() {
@@ -383,7 +436,7 @@ function createEntityCloud({ db, userId, deviceId, content = null, repoStates =
     // content drain creates the filesystem upload cursor; doing that here
     // would let a rolled-back identity write upload unreachable bytes.
     const cloud = cloudRecord(record);
-    queueContent(cloud, current.resourceId);
+    queueContentHeads([cloud], current.resourceId);
     upsertCatalogRecord({
       resourceId: current.resourceId,
       authorityEpoch: current.authorityEpoch,
@@ -423,7 +476,7 @@ function createEntityCloud({ db, userId, deviceId, content = null, repoStates =
     if (bytes > SNAPSHOT_REPLACE_MAX_BYTES) {
       throw new Error(`registered entity graph is ${bytes} bytes; the atomic cloud registration limit is ${SNAPSHOT_REPLACE_MAX_BYTES} bytes`);
     }
-    for (const record of snapshot.records) queueContent(record, current.resourceId, { queue: true });
+    queueContentHeads(snapshot.records, current.resourceId, { queue: true });
     const createdAt = now();
     db.prepare(`
       INSERT INTO entity_cloud_mutations (
@@ -448,8 +501,9 @@ function createEntityCloud({ db, userId, deviceId, content = null, repoStates =
     }
     const insert = db.prepare('INSERT INTO entity_cloud_mutations (resource_id, mutation_id, operation_json, mutation_state, created_at, updated_at) VALUES (?, ?, ?, \'pending\', ?, ?)');
     const createdAt = now();
-    for (const record of cloudSnapshot(records).records) {
-      queueContent(record, current.resourceId, { queue: true });
+    const snapshot = cloudSnapshot(records);
+    queueContentHeads(snapshot.records, current.resourceId, { queue: true });
+    for (const record of snapshot.records) {
       insert.run(
         current.resourceId,
         'ent_' + crypto.randomBytes(18).toString('base64url'),
@@ -632,7 +686,7 @@ function createEntityCloud({ db, userId, deviceId, content = null, repoStates =
     // upload. A joining device must NOT queue remote bytes as uploads; it
     // downloads them later through a materialization job instead.
     if (bootstrapping) {
-      for (const record of snapshot.records) queueContent(record, resourceId, { queue: true });
+      queueContentHeads(snapshot.records, resourceId, { queue: true });
     }
     replaceCatalog({
       resourceId,
@@ -706,15 +760,13 @@ function createEntityCloud({ db, userId, deviceId, content = null, repoStates =
     for (const job of pendingMaterializations().filter((entry) => entry.state === 'waiting_for_content')) {
       if (job.resourceId !== current.resourceId) continue;
       const tree = catalogTree({ resourceId: job.resourceId, uuid: job.entityUuid });
-      for (const record of tree) {
-        if (record.status !== 'active') continue;
-        const head = contentHead(record);
-        if (!head) continue;
-        const part = content.missingPart({ contentHash: head });
+      const active = tree.filter((record) => record.status === 'active');
+      for (const { contentHash } of contentHeads(active)) {
+        const part = content.missingPart({ contentHash });
         if (!part) continue;
         return {
           resourceId: job.resourceId,
-          contentHash: head,
+          contentHash,
           kind: part.kind,
           partIndex: part.partIndex,
           sha256: part.sha256,
@@ -882,10 +934,9 @@ function createEntityCloud({ db, userId, deviceId, content = null, repoStates =
         const records = operation?.kind === SNAPSHOT_REPLACE_OPERATION
           ? operation?.snapshot?.records
           : [operation?.record];
-        if ((records || []).some((record) => {
-          const head = contentHead(record);
-          return head && (!content || !content.uploaded({ resourceId: current.resourceId, contentHash: head }));
-        })) {
+        if (contentHeads(records).some(({ contentHash }) => (
+          !content || !content.uploaded({ resourceId: current.resourceId, contentHash })
+        ))) {
           return [];
         }
         claimRow.run(current.headVersion, leaseUntil, started, row.sequence);
@@ -923,7 +974,7 @@ function createEntityCloud({ db, userId, deviceId, content = null, repoStates =
       const records = operation?.kind === SNAPSHOT_REPLACE_OPERATION
         ? operation?.snapshot?.records
         : [operation?.record];
-      for (const record of records || []) queueContent(record, current.resourceId, { queue: true });
+      queueContentHeads(records || [], current.resourceId, { queue: true });
       contentQueuedSequences.add(row.sequence);
     }
     return content.claim({ resourceId: current.resourceId, leaseMs });
@@ -1136,6 +1187,7 @@ function createEntityCloud({ db, userId, deviceId, content = null, repoStates =
     status,
     hasUnsettledLocalMutation,
     catalogTree,
+    contentHeads,
     replica,
   };
 }

package/runtime/scripts/amalgm-mcp/registration/service.js

@@ -106,6 +106,10 @@ function createRegistrationService({
     return localState(captured, artifact.contentHash);
   }
 
+  // Entity-cloud needs only logical ancestry to choose a content plan. It
+  // never owns a watcher or address; this facade is available after the
+  // registration boundary is constructed below.
+  const boundary = { current: null };
   const entityCloud = createEntityCloud({
     db: identityDb,
     userId: cloudUserId,
@@ -113,11 +117,13 @@ function createRegistrationService({
     content: entityContent,
     repoStates: repoStateLookup,
     repoTransportFor: (record) => repoTransportHeads.get(record.payloadVersion) || null,
+    recordAt: (uuid) => {
+      try { return boundary.current?.registry.syncRecord(uuid) || null; } catch { return null; }
+    },
   });
 
   // The observer emits before the boundary exists (its constructor
   // scans), so the wire reads through a box that the boundary fills.
-  const boundary = { current: null };
   const observer = createObserver({
     db: evidenceDb,
     emit: (event) => boundary.current?.onEvent(event),
@@ -474,15 +480,8 @@ function createRegistrationService({
       return state;
     }
 
-    for (const record of active) {
-      if (['file.text', 'file.binary'].includes(record.type)
-        && !entityContent.complete({ contentHash: record.payloadVersion })) {
-        return false;
-      }
-      if (record.type === 'repo.git'
-        && (!record.transportVersion || !entityContent.complete({ contentHash: record.transportVersion }))) {
-        return false;
-      }
+    for (const { contentHash } of entityCloud.contentHeads(active)) {
+      if (!entityContent.complete({ contentHash })) return false;
     }
     if (!['workspace', 'repo.git', 'file.text', 'file.binary', 'link'].includes(root.type)) {
       throw new Error(`cloud root ${root.uuid} is ${root.type}; this materializer supports workspace, repository, file, and link trees only`);
@@ -579,11 +578,8 @@ function createRegistrationService({
     if (!['workspace', 'repo.git', 'file.text', 'file.binary', 'link'].includes(root.type)) {
       throw new Error(`cloud root ${root.uuid} is ${root.type}; this live materializer supports workspace, repository, file, and link trees only`);
     }
-    for (const record of active) {
-      if (['file.text', 'file.binary'].includes(record.type)
-        && !entityContent.complete({ contentHash: record.payloadVersion })) return false;
-      if (record.type === 'repo.git'
-        && (!record.transportVersion || !entityContent.complete({ contentHash: record.transportVersion }))) return false;
+    for (const { contentHash } of entityCloud.contentHeads(active)) {
+      if (!entityContent.complete({ contentHash })) return false;
     }
 
     const parent = fs.realpathSync(job.targetPath);

package/runtime/scripts/amalgm-mcp/tests/entity-materialization.test.js

@@ -369,20 +369,35 @@ test('add recreates an actual Git repository from verified Repocard cargo, then
       snapshotChecksum: sha256(snapshotBytes),
     });
 
-    const heads = new Set(records.flatMap((record) => {
-      if (['file.text', 'file.binary'].includes(record.type) && record.payloadVersion) return [record.payloadVersion];
-      if (record.type === 'repo.git' && record.transportVersion) return [record.transportVersion];
-      return [];
-    }));
-    for (const head of heads) {
-      const parts = uploadedParts(source.entityContent, bootstrap.resourceId, head);
-      for (const part of [...parts.filter((entry) => entry.kind === 'manifest'), ...parts.filter((entry) => entry.kind === 'chunk')]) {
-        target.receiveCloudContent({
-          resourceId: bootstrap.resourceId, contentHash: head, kind: part.kind,
-          partIndex: part.kind === 'manifest' ? 0 : part.partIndex,
-          sha256: part.sha256, dataBase64: part.dataBase64,
-        });
-      }
+    const planned = source.entityCloud.contentHeads(records);
+    assert.deepEqual(
+      planned.map(({ contentHash }) => contentHash),
+      [repoCloudRecord.transportVersion],
+      'a repository register uploads its one Repocard transport, never duplicate child file bytes',
+    );
+    const uploaded = [];
+    while (true) {
+      const part = source.entityCloud.claimContent();
+      if (!part) break;
+      uploaded.push(part);
+      source.entityCloud.acknowledgeContent({
+        resourceId: bootstrap.resourceId,
+        contentHash: part.contentHash,
+        kind: part.kind,
+        partIndex: part.partIndex,
+      });
+    }
+    assert.deepEqual(
+      [...new Set(uploaded.map((part) => part.contentHash))],
+      [repoCloudRecord.transportVersion],
+      'the source content pump sends only the repository transport',
+    );
+    for (const part of [...uploaded.filter((entry) => entry.kind === 'manifest'), ...uploaded.filter((entry) => entry.kind === 'chunk')]) {
+      target.receiveCloudContent({
+        resourceId: bootstrap.resourceId, contentHash: part.contentHash, kind: part.kind,
+        partIndex: part.kind === 'manifest' ? 0 : part.partIndex,
+        sha256: part.sha256, dataBase64: part.dataBase64,
+      });
     }
 
     const job = await target.add({ uuid: registered.record.uuid, targetPath: targetParent });