@origintrail-official/dkg-agent 10.0.21 → 10.0.23

package/dist/dkg-agent.js

@@ -8,7 +8,7 @@ import { DKGNode, TypedEventBus, PROTOCOL_STORAGE_ACK, isStorageACKProtocol, PRO
 import { GraphManager, createTripleStore } from '@origintrail-official/dkg-storage';
 import { canonicalRootlessLifecycleGraph } from './rootless-lifecycle-graph.js';
 import { normalizeContextGraphDiscoveryScan, legacyChainListScanOptions, } from './context-graph-discovery-options.js';
-import { prepareRfc64LateLegacySwmBoundaryV1 } from './rfc64/legacy-swm-boundary-v1.js';
+import { awaitRfc64LateLegacySwmBoundaryAdmissionV1, prepareRfc64LateLegacySwmBoundaryV1 } from './rfc64/legacy-swm-boundary-v1.js';
 import { EVMChainAdapter, NoChainAdapter, isContextGraphChainScanPartialError, withRpcRequestContext } from '@origintrail-official/dkg-chain';
 import { DKGPublisher, ACKCollector, TripleStoreAsyncPromoteQueue, wrapAsRpcPreconditionIfApplicable, resolveStorageAckTiming, 
 // OT-RFC-43 A2/B3 — per-layer pointers + derived status helper.
@@ -23,7 +23,7 @@ import { deleteSyncPageCheckpoint, } from './sync/requester/page-fetch.js';
 import { createContextGraphSyncDeadline } from './sync/requester/durable-sync-budget.js';
 import { createSwmRecoveryMutationRuntimeV1 } from './sync/requester/swm-recovery-apply.js';
 import { resolveSyncContextGraphPriorities, validateSyncResponderSnapshotLimitsConfig, } from './sync/policy.js';
-import { resolveDiscoveredContextGraphBinding } from './context-graph-chain-discovery-binding.js';
+import { conflictsWithOwnedContextGraphBinding, resolveDiscoveredContextGraphBinding, } from './context-graph-chain-discovery-binding.js';
 import { relocatePrivateContextGraphMetadata, } from './context-graph-metadata-relocation.js';
 import { replaceContextGraphMetadataFact } from './context-graph-metadata-fact.js';
 import { stripLiteral, jsonLdToQuads, } from './dkg-agent-utils.js';
@@ -32,6 +32,7 @@ import { ContextGraphNotFoundError, InvalidContentError, } from './dkg-agent-typ
 import { normalizeAdapterPublisherAddress, adapterAdvertisesPublisherSigner, privateKeyAddress, inferAdapterPublisherAddress, defaultLargeLiteralStorage, createPublicSnapshotStore, applyDefaultLargeLiteralStorage, } from './dkg-agent-helpers.js';
 import { resolveSyncReconcilerTiming } from './sync/reconciler-timing.js';
 import { DKGAgentBase, createListContextGraphsCacheInvalidatingStore } from './dkg-agent-base.js';
+import { createProjectionMutationObserver } from './internal/projection-mutation-observer.js';
 import { mapWithConcurrency } from './map-with-concurrency.js';
 import { VmReconcileShutdownTimeoutError } from './vm-reconcile-service.js';
 import { ContextGraphMembershipPersistShutdownTimeoutError } from './context-graph-membership-persist-scheduler.js';
@@ -268,14 +269,10 @@ export class DKGAgent extends DKGAgentBase {
             },
             recordDrops: (drops, seam) => this.oversizeTombstoneLog.record(drops, seam),
             invalidateListContextGraphsCache: () => this.invalidateListContextGraphsCache(),
-            markMetaProjectionDirty: (quads) => this.contextGraphMetaProjection
-                .markDirtyFromQuads(quads),
             recoveryMutation: createSwmRecoveryMutationRuntimeV1({
                 store: this.store,
                 recordDrops: (drops, seam) => this.oversizeTombstoneLog.record(drops, seam),
                 invalidateListContextGraphsCache: () => this.invalidateListContextGraphsCache(),
-                markMetaProjectionDirty: (quads) => this.contextGraphMetaProjection
-                    .markDirtyFromQuads(quads),
             }),
             setCheckpoint: (key, offset) => this.syncCheckpoints.set(key, offset),
             deleteCheckpoint: (key) => this.syncCheckpoints.delete(key),
@@ -390,7 +387,10 @@ export class DKGAgent extends DKGAgentBase {
                 });
                 const headDigest = this.rfc64PersistenceV1?.swmAuthorInventory
                     .readSwmAuthorInventoryHeadDigestV1(scopeDigest, authorAddress) ?? null;
-                return JSON.stringify([lane.kind, lane.projectionTargetPolicy, scopeDigest, headDigest]);
+                return {
+                    scopeIdentity: JSON.stringify([lane.kind, lane.projectionTargetPolicy, scopeDigest]),
+                    headRevision: headDigest,
+                };
             },
             listFinalizedPrivateRepairs: () => (this.rfc64PersistenceV1?.finalizedPrivatePlacementRepairs.list() ?? []),
             repairFinalizedPrivatePlacement: async (repair) => {
@@ -761,23 +761,7 @@ export class DKGAgent extends DKGAgentBase {
             (!configuredPublisherAddress || publisherAddressMatchesLegacyKey));
         const agentStore = createListContextGraphsCacheInvalidatingStore(store, () => {
             agentRef?.invalidateListContextGraphsCache();
-        }, (quads, targetGraph) => {
-            if (!agentRef)
-                return;
-            // #1863 — a single-graph destructive mutation (replaceSubject) passes its
-            // TARGET GRAPH so deleted facts are fenced, while replacement quads
-            // cover inserted authority facts.
-            if (targetGraph !== undefined) {
-                agentRef.contextGraphMetaProjection.markDirtyForGraph(targetGraph);
-                if (quads)
-                    agentRef.contextGraphMetaProjection.markDirtyFromQuads(quads);
-                return;
-            }
-            if (quads)
-                agentRef.contextGraphMetaProjection.markDirtyFromQuads(quads);
-            else
-                agentRef.contextGraphMetaProjection.markAllDirty();
-        });
+        }, createProjectionMutationObserver(() => agentRef?.contextGraphMetaProjection));
         const publicSnapshotStore = config.publicSnapshotStore ?? (config.publicSnapshotStoreFactory
             ? config.publicSnapshotStoreFactory(agentStore)
             : createPublicSnapshotStore(config.dataDir, config.sharedMemoryPublicSnapshotStorage, agentStore));
@@ -798,7 +782,7 @@ export class DKGAgent extends DKGAgentBase {
             kaAllocator: config.kaNumberAllocator,
             // RFC ka-metadata-trim P3.3 — `metadata.provenanceEvents` (default true).
             provenanceEvents: config.metadataProvenanceEvents,
-            resolveDurableRootPromotionAtomicCompanion: (input) => {
+            resolveDurableRootPromotionAtomicCompanion: Object.assign((input) => {
                 // Every root graph may exist before its exact catalog head is durable,
                 // including the normal catalog lane. Persist its negative-completeness
                 // witness in the same transaction; exact catalog reconciliation alone
@@ -812,7 +796,14 @@ export class DKGAgent extends DKGAgentBase {
                 // A promote that meets a retirement's fence (its asset's, or the graph's) is
                 // retried by the queue; every other refusal here stays a hard failure.
                 return translateLegacySwmRetirementFence(() => prepareRfc64LateLegacySwmBoundaryV1(owner, input.contextGraphId, input.kaUal, input.shareOperationId, input.assertionVersion));
-            },
+            }, {
+                // The promote gives a fence a short time to drop before it prepares.
+                awaitAdmission: async (input) => {
+                    if (resolvedConfig.dataDir === undefined || agentRef === undefined)
+                        return;
+                    await awaitRfc64LateLegacySwmBoundaryAdmissionV1(agentRef, input.contextGraphId, input.kaUal);
+                },
+            }),
             resolveDurableRootMaterializationAtomicCompanion: (input) => {
                 if (resolvedConfig.dataDir === undefined)
                     return;
@@ -1050,20 +1041,25 @@ export class DKGAgent extends DKGAgentBase {
         return diagnostics.pingPeers({ node: this.node, peerHealth: this.peerHealth, log: this.log });
     }
     /**
-     * Record metadata learned through a discovery channel, then apply the
-     * temporary role policy required until core host-mode custody is independent
-     * from member subscriptions (#1611):
-     *
-     * - edge: catalogue only; explicit subscribe/create/join owns activation
-     * - core: newly discovered graphs auto-subscribe so ACK-capable nodes keep
-     *   the publish/finalization handlers needed to host network data
+     * Enrich catalogue metadata while preserving an owned numeric slot.
+     * Until core custody is independent (#1611), new core discoveries activate
+     * ACK/finalization hosting; edge discoveries stay passive.
      *
-     * Existing unsubscribed rows are never reactivated here. That preserves an
-     * operator's explicit unsubscribe while still allowing authoritative
-     * metadata (including an on-chain binding) to enrich the catalogue.
+     * Existing unsubscribed rows retain their explicit inactive intent.
      */
     recordDiscoveredContextGraph(contextGraphId, metadata, options = {}) {
         const existing = this.subscribedContextGraphs.get(contextGraphId);
+        const authoritativeOnChainId = isCanonicalAuthoritativeContextGraphId(metadata.onChainId)
+            ? metadata.onChainId
+            : undefined;
+        if (existing
+            && conflictsWithOwnedContextGraphBinding(existing.onChainId, authoritativeOnChainId)) {
+            // Discovery enriches an identity; it cannot replace an owned slot.
+            // Explicit verified rebinds use their own authority boundary.
+            this.log.warn(createOperationContext('system'), `Ignoring discovered Context Graph "${contextGraphId}" slot ${authoritativeOnChainId}: `
+                + `the local identity already owns slot ${existing.onChainId}`);
+            return existing;
+        }
         const next = {
             ...existing,
             syncMode: existing?.syncMode ?? 'always-on',
@@ -1074,9 +1070,6 @@ export class DKGAgent extends DKGAgentBase {
             metaSynced: existing?.metaSynced === true,
             participantAgents: metadata.participantAgents ?? existing?.participantAgents,
         };
-        const authoritativeOnChainId = isCanonicalAuthoritativeContextGraphId(metadata.onChainId)
-            ? metadata.onChainId
-            : undefined;
         const invalidExplicitOnChainId = metadata.onChainId !== undefined
             && authoritativeOnChainId === undefined;
         if (authoritativeOnChainId !== undefined) {
@@ -1090,9 +1083,7 @@ export class DKGAgent extends DKGAgentBase {
         if (!invalidExplicitOnChainId && metadata.onChainHash !== undefined) {
             next.onChainHash = metadata.onChainHash;
         }
-        // Discovery-only rows stay in-memory. Metadata learned for an already
-        // active member/host row is part of that durable state and must survive a
-        // restart (notably a later-discovered onChainId).
+        // Only an admitted member/host's enrichment belongs in durable state.
         const persistEnrichment = options.persist !== false
             && (existing?.subscribed === true || existing?.coreHosted === true);
         this.setContextGraphSubscription(contextGraphId, next, { persist: persistEnrichment });
@@ -1551,10 +1542,7 @@ export class DKGAgent extends DKGAgentBase {
             partialChainScanError = err;
             return err.partialResults;
         };
-        // NameRegistry enumeration is keyed by bytes32 name hashes, while all
-        // authoritative agent bindings are positive decimal ContextGraphStorage
-        // ids. Keep those namespaces separate: the legacy
-        // ContextGraphOnChain.contextGraphId field is the former, not the latter.
+        // Enumeration name hashes and authoritative numeric slots are distinct.
         const knownNameHashes = new Set();
         for (const [localId, sub] of this.subscribedContextGraphs) {
             if (sub.onChainHash && ethers.isHexString(sub.onChainHash, 32)) {
@@ -1607,6 +1595,12 @@ export class DKGAgent extends DKGAgentBase {
                     }
                 }
                 const durableOnChainId = await readDurableContextGraphOnChainId(binding.name);
+                const currentOnChainId = this.subscribedContextGraphs.get(binding.name)?.onChainId;
+                if (conflictsWithOwnedContextGraphBinding(currentOnChainId, binding.onChainId)) {
+                    this.log.warn(ctx, `Ignoring chain discovery for "${binding.name}" slot ${binding.onChainId}: `
+                        + `the local identity already owns slot ${currentOnChainId}`);
+                    continue;
+                }
                 if (durableOnChainId === binding.onChainId) {
                     // A previous attempt may have committed the reconstructible RDF
                     // binding but failed the active/core subscription write before page
@@ -1621,18 +1615,9 @@ export class DKGAgent extends DKGAgentBase {
                         knownNameHashes.add(registryNameHash);
                     continue;
                 }
-                // Persist the on-chain ID durably so the publisher's VM registration
-                // guard can find it via RDF (it has no access to the in-memory
-                // subscribedContextGraphs map). Only the metadata home gets it:
-                // ontology for a public graph, its own `_meta` for a curated one (only
-                // its curator gets here). A graph found on chain isn't held here, and
-                // any `_meta` row would make the relocation treat it as held.
-                // Single-valued binding guard (RS heal): on-chain id is immutable; clear
-                // any prior value so the cgId resolver / heal never read a multi-valued
-                // (LIMIT-1-nondeterministic) binding.
-                // Keep this durable write before in-memory catalogue mutation: cursor
-                // pages are acked after this function returns, and an in-memory onChainId
-                // alone must not make a retry skip the RDF binding.
+                // The publisher resolves this reconstructible binding from RDF.
+                // Write its public/private metadata home before catalogue persistence
+                // and page acknowledgement, so a failed durable row can be replayed.
                 await replaceContextGraphMetadataFact(this.store, binding.name, {
                     predicate: CONTEXT_GRAPH_ON_CHAIN_ID_PREDICATE,
                     object: `"${binding.onChainId}"`,