@ibgib/core-gib 0.1.12 → 0.1.14

package/dist/witness/space/space-types.mjs

@@ -125,5 +125,9 @@ export const IbGibSpaceOptionsCmdModifier = {
      * Get the tjp ibgibs/addrs for given ibgib(s)
      */
     tjps: 'tjps',
+    /**
+     * Modifies the get command to retrieve a dependency graph.
+     */
+    dependencyGraph: 'dependency-graph',
 };
 //# sourceMappingURL=space-types.mjs.map

package/dist/witness/space/space-types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"space-types.mjs","sourceRoot":"","sources":["../../../src/witness/space/space-types.mts"],"names":[],"mappings":"AAQA,OAAO,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAC;AAUnF,MAAM,CAAC,MAAM,aAAa,GAAG;IACzB;;;;;;OAMG;IACH,KAAK,EAAE,OAAwB;IAC/B;;;OAGG;IACH,UAAU,EAAE,YAA6B;IACzC;;;;;;OAMG;IACH,UAAU,EAAE,YAA6B;CAC5C,CAAA;AACD,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,MAAM,EAAE,CAAC;AAG3E,MAAM,CAAC,MAAM,SAAS,GAAG;IACrB;;;;;;OAMG;IACH,IAAI,EAAE,MAAmB;IACzB;;;OAGG;IACH,IAAI,EAAE,MAAmB;CAC5B,CAAA;AACD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,CAAC;AAGnE;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B;;;;;;;;OAQG;IACH,eAAe,EAAE,iBAAqC;CACzD,CAAA;AAED,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B,YAAY,EAAE,cAAkC;CACnD,CAAA;AAGD;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IACxB,GAAG,gBAAgB;IACnB,GAAG,gBAAgB;CACtB,CAAA;AACD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,MAAM,EAAE,CAAC;AAgHzE,+CAA+C;AAC/C,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAChC,iEAAiE;IACjE,GAAG,EAAE,KAA6B;IAClC,iDAAiD;IACjD,GAAG,EAAE,KAA6B;IAClC,mCAAmC;IACnC,MAAM,EAAE,QAAgC;CAC3C,CAAA;AAOD;;GAEG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG;IACxC;;;;OAIG;IACH,GAAG,EAAE,KAAqC;IAC1C;;OAEG;IACH,KAAK,EAAE,OAAuC;IAC9C;;;;;;;;;;;OAWG;IACH,MAAM,EAAE,QAAwC;IAChD;;OAEG;IACH,KAAK,EAAE,OAAuC;IAC9C;;OAEG;IACH,OAAO,EAAE,SAAyC;IAClD;;OAEG;IACH,IAAI,EAAE,MAAsC;CAC/C,CAAA"}
+{"version":3,"file":"space-types.mjs","sourceRoot":"","sources":["../../../src/witness/space/space-types.mts"],"names":[],"mappings":"AAQA,OAAO,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAC;AAUnF,MAAM,CAAC,MAAM,aAAa,GAAG;IACzB;;;;;;OAMG;IACH,KAAK,EAAE,OAAwB;IAC/B;;;OAGG;IACH,UAAU,EAAE,YAA6B;IACzC;;;;;;OAMG;IACH,UAAU,EAAE,YAA6B;CAC5C,CAAA;AACD,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,MAAM,EAAE,CAAC;AAG3E,MAAM,CAAC,MAAM,SAAS,GAAG;IACrB;;;;;;OAMG;IACH,IAAI,EAAE,MAAmB;IACzB;;;OAGG;IACH,IAAI,EAAE,MAAmB;CAC5B,CAAA;AACD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,CAAC;AAGnE;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B;;;;;;;;OAQG;IACH,eAAe,EAAE,iBAAqC;CACzD,CAAA;AAED,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC5B,YAAY,EAAE,cAAkC;CACnD,CAAA;AAGD;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IACxB,GAAG,gBAAgB;IACnB,GAAG,gBAAgB;CACtB,CAAA;AACD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,MAAM,EAAE,CAAC;AAgHzE,+CAA+C;AAC/C,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAChC,iEAAiE;IACjE,GAAG,EAAE,KAA6B;IAClC,iDAAiD;IACjD,GAAG,EAAE,KAA6B;IAClC,mCAAmC;IACnC,MAAM,EAAE,QAAgC;CAC3C,CAAA;AAOD;;GAEG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG;IACxC;;;;OAIG;IACH,GAAG,EAAE,KAAqC;IAC1C;;OAEG;IACH,KAAK,EAAE,OAAuC;IAC9C;;;;;;;;;;;OAWG;IACH,MAAM,EAAE,QAAwC;IAChD;;OAEG;IACH,KAAK,EAAE,OAAuC;IAC9C;;OAEG;IACH,OAAO,EAAE,SAAyC;IAClD;;OAEG;IACH,IAAI,EAAE,MAAsC;IAC5C;;OAEG;IACH,eAAe,EAAE,kBAAkD;CACtE,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ibgib/core-gib",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "ibgib core functionality, including base architecture for witnesses, spaces, apps, robbots, etc., as well as shared utility functions. Node v19+ needed for heavily-used isomorphic webcrypto hashing consumed in both node and browsers.",
   "funding": {
     "type": "individual",
@@ -50,7 +50,7 @@
   "dependencies": {
     "@ibgib/encrypt-gib": "^0.2.34",
     "@ibgib/helper-gib": "^0.0.33",
-    "@ibgib/ts-gib": "^0.5.27"
+    "@ibgib/ts-gib": "^0.5.28"
   },
   "devDependencies": {
     "@types/node": "^20.2.1"

package/src/keystone/keystone-helpers.mts

@@ -103,7 +103,7 @@ export function getDeterministicRequirements({
     if (requiredChallengeIds && requiredChallengeIds.length > 0) {
         for (const id of requiredChallengeIds) {
             if (!pool.challenges[id]) {
-                throw new Error(`(UNEXPECTED) Required challenge ID not found in pool: ${id} (E: 2c9f8...)`);
+                throw new Error(`(UNEXPECTED) Required challenge ID not found in pool: ${id} (E: 10c5619d80d8cf6cc84ffbf8be0dbc25)`);
             }
             // Strict: Consume it.
             if (!available.includes(id)) {
@@ -133,7 +133,7 @@ export function getDeterministicRequirements({
                 const match = bucket.find(id => available.includes(id));
 
                 if (!match) {
-                    throw new Error(`Entropy Exhaustion. Cannot satisfy binding for char '${char}'. (E: 8d3a1...)`);
+                    throw new Error(`Entropy Exhaustion. Cannot satisfy binding for char '${char}'. (E: 341b95dc3a58be3e083d1d9c4a0c4925)`);
                 }
 
                 // Strict: Consume it.
@@ -150,7 +150,7 @@ export function getDeterministicRequirements({
         // Take the first N from the remaining available list
         if (available.length < behavior.selectSequentially) {
             console.error(`[getDeterministicRequirements] Entropy Exhaustion! AvailableCount: ${available.length}, Required Seq: ${behavior.selectSequentially}. Available IDs: ${available.join(',')}`);
-            throw new Error(`Entropy Exhaustion. Insufficient challenges for FIFO requirement. (E: 9c2b4...)`);
+            throw new Error(`Entropy Exhaustion. Insufficient challenges for FIFO requirement. (E: 9efa88003e1d5eccb837c85154ee5625)`);
         }
 
         const fifoIds = available.slice(0, behavior.selectSequentially);

package/src/sync/README.md

@@ -0,0 +1,275 @@
+# Symmetric Sync Protocol Architecture
+
+This document outlines the architecture for the symmetric synchronization protocol between two "Sync Nodes" (e.g., Alice/Client and Bob/Server).
+
+## Concepts
+
+*   **Saga**: A linear conversation of ibGibs (`Init` -> `Ack` -> `Delta` -> `Commit`).
+*   **SyncSagaCoordinator**: The "Driver" that manages the saga state machine. It is symmetric: both Alice and Bob use the same coordinator logic.
+*   **SyncWitness**: An abstraction for the "Other Side". It implements the `Witness` interface (IbGib pattern) to transport messages.
+    *   `LocalSyncWitness`: Direct in-memory call (for testing/local sync).
+    *   `RemoteSyncWitness`: HTTP/WebSocket transport (for client-server).
+*   **SyncSagaContext**: The payload exchanged between witnesses. It is a full-fledged ibGib containing the saga frame and all necessary proof/data stones.
+
+## Data Structures
+
+### SyncSagaContext (The Payload)
+
+We treat the context itself as an ibGib.
+
+```typescript
+import { IbGib_V1, IbGibData_V1, IbGibRel8ns_V1 } from '@ibgib/ts-gib/dist/V1';
+
+export const SYNC_SAGA_CONTEXT_ATOM = 'sync_sagacontext';
+
+export interface SyncSagaContextData_V1 extends IbGibData_V1 {
+    /**
+     * Contextual metadata, if any.
+     */
+    cmd?: string;
+}
+
+export interface SyncSagaContextRel8ns_V1 extends IbGibRel8ns_V1 {
+    /**
+     * The primary Saga Frame being transported (Init, Ack, Delta, etc.).
+     * 0..1 (Optional only if trivial ping)
+     */
+    sagaFrame?: string[]; // [addr]
+
+    /**
+     * Message stones associated with this context (e.g. Init payload stone).
+     */
+    msgs?: string[];
+
+    /**
+     * The Ephemeral Session Keystone Identity used for this saga.
+     */
+    sessionKeystone?: string[];
+
+    /**
+     * Authorization claims linking Session Key to Primary Identity.
+     */
+    claims?: string[];
+    
+    /**
+     * Any other dependency stones/ibgibs required for validation.
+     */
+    other?: string[];
+}
+
+export interface SyncSagaContextIbGib_V1 extends IbGib_V1<SyncSagaContextData_V1, SyncSagaContextRel8ns_V1> {}
+```
+
+## Abstract Transport (`SyncPeer`)
+
+The transport layer is just another Witness.
+
+```typescript
+import { LightWitnessBase_V1 } from '../../witness/light-witness-base-v1';
+
+/**
+ * Witness for talking to a Sync Peer.
+ * Input: SyncSagaContextIbGib_V1 (The Request)
+ * Output: SyncSagaContextIbGib_V1 (The Response)
+ */
+export abstract class SyncPeer_V1 extends LightWitnessBase_V1 {
+    // The 'witness' method is the transport mechanism.
+    abstract witness(arg: SyncSagaContextIbGib_V1): Promise<SyncSagaContextIbGib_V1 | undefined>;
+}
+```
+
+## Workflow Execution (Alice -> Bob)
+
+### 1. Startup: Alice Initiates (Client Side)
+
+Create the `SessionKeystone`, authorize it with `PrimaryIdentity`, and start the Saga.
+
+```typescript
+// IN: SyncSagaCoordinator (Alice)
+async function sync({
+    peer,           // The SyncPeer_V1 (connected to Bob)
+    localSpace,     // Alice's main space
+    metaspace,
+    primaryIdentity // Alice's Master Keystone
+}: SyncOptions) {
+    
+    // 0. WORKING CONTEXT (Transactional)
+    // Create a temp space to squash "in-flight" saga metadata
+    // so we don't pollute localSpace until commit.
+    const tempSpace = await metaspace.createLocalSpace({ inMemory: true });
+    
+    try {
+        // 1. BOOTSTRAP IDENTITY
+        const sagaId = await getUUID();
+        
+        // A. Create Fresh Session Keystone (TJP)
+        // Derived deterministically from Master Secret + SagaId
+        const sessionIdentity = await createSessionKeystone({ 
+            seed: sagaId, 
+            masterSecret: primaryIdentity.secret 
+        });
+        
+        // B. Authorize Session Key (Primary signs Session TJP)
+        // Primary creates a "Claim" saying "I authorize this Session Key"
+        // Target: SessionIdentity TJPAddr
+        // Context: SagaId
+        const authClaim = await createKeystoneClaim({
+            issuer: primaryIdentity,
+            subject: sessionIdentity.tjp, 
+            context: sagaId,
+        });
+        // (Sign the claim with Primary)
+        
+        // 2. CREATE SAGA INIT (in Temp Space)
+        // A. Create Init Msg Stone
+        const initStone = await this.createSyncMsgStone({
+            data: { 
+                sagaId,
+                stage: 'init', 
+                identity: sessionIdentity.toPublic(), 
+                authorization: authClaim,
+            },
+            space: tempSpace,
+            metaspace
+        });
+
+        // B. Evolve Saga Frame (Root)
+        // Rel8s to Session Identity TJP (Soft Link via signing)
+        const sagaFrame = await this.evolveSyncSagaIbGib({
+            msgStones: [initStone],
+            identity: sessionIdentity, // Signed by Session Key
+            space: tempSpace,
+            metaspace
+        });
+
+        // 3. TRANSPORT (Alice -> Bob)
+        // Construct Context IbGib via Helper
+        const requestCtx = await createSyncSagaContext({
+            data: { cmd: 'process' },
+            rel8ns: {
+                sagaFrame: [getIbGibAddr(sagaFrame)],
+                msgs: [getIbGibAddr(initStone)],
+                sessionKeystone: [getIbGibAddr(sessionIdentity)],
+                claims: [getIbGibAddr(authClaim)],
+            }
+        });
+        // (We would physically put these artifacts into a transmit buffer/space here)
+
+        // "Witness" the request (Put to Bob)
+        const responseCtx = await peer.witness(requestCtx);
+        
+        // 4. HANDLE RESPONSE (Bob -> Alice)
+        if (responseCtx) {
+             // Bob replied with Ack/Counter
+            await this.handleSagaFrame({
+                incomingCtx: responseCtx,
+                localSpace, 
+                tempSpace,
+                identity: sessionIdentity
+            });
+        }
+        
+        // 5. COMMIT (If success)
+        // Merge relevant artifacts from tempSpace to localSpace
+        
+    } finally {
+        // CLEANUP
+        // Destroy tempSpace
+    }
+}
+```
+
+### 2. Receiver: Bob Reacts (Server Side)
+
+Bob receives the context, validates the `SessionKey` -> `PrimaryIdentity` chain, and negotiates.
+
+```typescript
+// IN: SyncSagaCoordinator (Bob)
+// Called via Internal Plumbing when SyncPeer receives 'witness()' call
+async function handleRequest(ctx: SyncSagaContextIbGib_V1): Promise<SyncSagaContextIbGib_V1> {
+
+    // 1. VALIDATION (The Guard Rails)
+    // A. Validate Structure (Stones exist, hashes match)
+    // B. Validate Identity Chain:
+    //    - Verify `ctx.sagaFrame` signed by `SessionKey` (in `ctx.sessionKeystone`)
+    //    - Verify `SessionKey` authorized by `AuthClaim` (in `ctx.claims`)
+    //    - Verify `AuthClaim` signed by `PrimaryIdentity` (Known/Trusted?)
+    
+    // 2. WORKING CONTEXT
+    const tempSpace = ...; // Bob's temp space management
+    
+    // 3. LOGIC DISPATCH
+    const incomingFrameAddr = ctx.rel8ns.sagaFrame[0];
+    const incomingFrame = await getFromSpace(incomingFrameAddr); // (From ctx payload)
+    
+    const stage = incomingFrame.data.stage; // 'init'
+    
+    let responseFrame;
+    if (stage === 'init') {
+        responseFrame = await this.handleInitFrame(incomingFrame, tempSpace);
+    } else if (stage === 'delta') {
+        // ...
+    }
+    
+    // 4. RESPONSE
+    // Construct Response Context with new frame + stones
+    return responseCtx;
+}
+```
+
+## Calling Code Example
+
+The `sync` method returns a `SyncSagaInfo` object, which behaves like a mini-pubsub communicator. This allows the caller to subscribe to progress updates or await completion.
+
+### Types
+
+```typescript
+import { SubjectWitness } from '../../common/pubsub/subject/subject-types';
+
+export interface SyncSagaInfo {
+    sagaId: string;
+    /**
+     * Stream of context updates happening during the saga.
+     * Subscribe to this to receive real-time progress.
+     */
+    updates$: SubjectWitness<SyncSagaContextIbGib_V1>;
+    
+    /**
+     * Promise that resolves when the saga completes successfully.
+     */
+    done: Promise<void>;
+}
+```
+
+### Usage
+
+```typescript
+import { SyncSagaCoordinator } from './sync-saga-coordinator';
+
+// 1. Initialize Coordinator
+const coordinator = new SyncSagaCoordinator( ... );
+
+// 2. Start Sync
+const sagaInfo = await coordinator.sync({
+    peer: remoteWitness,
+    localSpace: myLocalSpace,
+    metaspace: myServices,
+    primaryIdentity: myIdentity
+});
+
+// 3. Subscribe to Updates
+await sagaInfo.updates$.subscribe(async (context) => {
+    // context is SyncSagaContextIbGib_V1
+    // You can inspect the frame stage, look for errors, etc.
+    const frameAddr = context.rel8ns.sagaFrame?.[0];
+    console.log(`Saga Update: ${frameAddr}`);
+});
+
+// 4. Await Completion
+try {
+    await sagaInfo.done;
+    console.log("Sync Complete!");
+} catch (error) {
+    console.error("Sync Failed:", error);
+}
+```

package/src/sync/sync-constants.mts

@@ -1,23 +1,28 @@
 export const SYNC_ATOM = "sync";
 
+export const SYNC_MSG_REL8N_NAME = "sync-msg";
+
 /**
  * Protocol version string for V1.
  */
 export const SYNC_PROTOCOL_V1 = "sync 1.0.0";
 
 export const SYNC_STAGE_INIT = "init";
+export const SYNC_STAGE_ACK = "ack";
 export const SYNC_STAGE_REQUEST = "request";
 export const SYNC_STAGE_DELTA = "delta";
 export const SYNC_STAGE_COMMIT = "commit";
 
 export type SyncStage =
     | typeof SYNC_STAGE_INIT
+    | typeof SYNC_STAGE_ACK
     | typeof SYNC_STAGE_REQUEST
     | typeof SYNC_STAGE_DELTA
     | typeof SYNC_STAGE_COMMIT;
 
 export const SyncStage = {
     init: SYNC_STAGE_INIT,
+    ack: SYNC_STAGE_ACK,
     request: SYNC_STAGE_REQUEST,
     delta: SYNC_STAGE_DELTA,
     commit: SYNC_STAGE_COMMIT,

package/src/sync/sync-helpers.mts

@@ -1,9 +1,13 @@
 import { extractErrorMsg } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";
+import { IbGib_V1 } from "@ibgib/ts-gib/dist/V1/types.mjs";
 import { Ib } from "@ibgib/ts-gib/dist/types.mjs";
+
+import { GLOBAL_LOG_A_LOT } from "../core-constants.mjs";
 import { SYNC_ATOM } from "./sync-constants.mjs";
-import { SyncData_V1, SyncIbInfo_V1 } from "./sync-types.mjs";
+import { SyncData_V1, SyncIb_V1 } from "./sync-types.mjs";
+import { IbGibSpaceAny } from "../witness/space/space-base-v1.mjs";
+import { getFromSpace } from "../witness/space/space-helper.mjs";
 
-const GLOBAL_LOG_A_LOT = false; // Todo: import from core constants if needed
 const logalot = GLOBAL_LOG_A_LOT;
 
 /**
@@ -38,17 +42,21 @@ export async function parseSyncIb({
     ib,
 }: {
     ib: Ib,
-}): Promise<SyncIbInfo_V1> {
+}): Promise<SyncIb_V1> {
     const lc = `[${parseSyncIb.name}]`;
     try {
         const parts = ib.split(' ');
         if (parts.length !== 3) {
-            throw new Error(`Invalid sync ib. Expected 3 parts [atom uuid stage]. Got ${parts.length}. (E: 7c8d9...)`);
+            throw new Error(`Invalid sync ib. Expected 3 parts [atom uuid stage]. Got ${parts.length}. (E: 7db603e0dcf8c35af826cce89a125825)`);
         }
-        const [atom, uuid, stage] = parts;
+        const [
+            atom,
+            uuid,
+            stage
+        ] = parts;
 
         if (atom !== SYNC_ATOM) {
-            throw new Error(`Invalid sync ib. Expected atom '${SYNC_ATOM}', got '${atom}'. (E: 8f9e1...)`);
+            throw new Error(`Atom mismatch. Expected ${SYNC_ATOM}. Got ${atom}.`);
         }
 
         return { atom, uuid, stage: stage as any };
@@ -57,3 +65,94 @@ export async function parseSyncIb({
         throw error;
     }
 }
+
+/**
+ * Checks if an address (`olderAddr`) is in the past frames of another (`newerAddr`).
+ * 
+ * Efficiently uses `inMemoryGraph` if provided to avoid Space I/O.
+ * Otherwise falls back to traversing using `space`.
+ */
+export async function isPastFrame({
+    olderAddr,
+    newerAddr,
+    space,
+    inMemoryGraph,
+}: {
+    olderAddr: string, // Was ancestorAddr
+    newerAddr: string, // Was descendantAddr
+    space?: IbGibSpaceAny,
+    inMemoryGraph?: { [addr: string]: IbGib_V1 },
+}): Promise<boolean> {
+    if (olderAddr === newerAddr) return true;
+
+    // Quick check if optimization allowed
+    if (inMemoryGraph) {
+        // Optimization: Iterate the graph values (or keys) and see if olderAddr is in any 'past'
+        // Actually we need to traverse from newerAddr back to olderAddr using the graph.
+
+        const queue = [newerAddr];
+        const visited = new Set<string>();
+
+        while (queue.length > 0) {
+            const currentAddr = queue.shift()!;
+            if (visited.has(currentAddr)) continue;
+            visited.add(currentAddr);
+
+            if (currentAddr === olderAddr) return true;
+
+            const node = inMemoryGraph[currentAddr];
+            // If node not in memory graph, we can't traverse further in memory.
+            // If we have space, we could fallback, but usually mixed mode is tricky.
+            // For now, if provided inMemoryGraph, assume it contains the relevant segment.
+            if (!node && space) {
+                // optional fallback to space if allowed?
+                // User requirement: "at most we are looking... in dependency graph". 
+                // So let's fallback if space provided.
+                const res = await getFromSpace({ space, addr: currentAddr });
+                if (res.success && res.ibGibs?.length) {
+                    const spaceNode = res.ibGibs[0];
+                    if (spaceNode.rel8ns && spaceNode.rel8ns.past) {
+                        for (const pastAddr of spaceNode.rel8ns.past) {
+                            if (!visited.has(pastAddr)) queue.push(pastAddr);
+                        }
+                    }
+                }
+                continue;
+            } else if (!node) {
+                continue; // Dead end in memory
+            }
+
+            if (node.rel8ns && node.rel8ns.past) {
+                for (const pastAddr of node.rel8ns.past) {
+                    if (!visited.has(pastAddr)) queue.push(pastAddr);
+                }
+            }
+        }
+        return false;
+    }
+
+    // Fallback to purely space-based traversal if no memory graph
+    if (!space) { throw new Error(`Must provide either space or inMemoryGraph for ancestry check.`); }
+
+    const queue = [newerAddr];
+    const visited = new Set<string>();
+
+    while (queue.length > 0) {
+        const currentAddr = queue.shift()!;
+        if (visited.has(currentAddr)) continue;
+        visited.add(currentAddr);
+
+        if (currentAddr === olderAddr) return true;
+
+        const res = await getFromSpace({ space, addr: currentAddr });
+        if (!res.success || !res.ibGibs || res.ibGibs.length === 0) continue;
+        const node = res.ibGibs[0];
+        if (node.rel8ns && node.rel8ns.past) {
+            for (const pastAddr of node.rel8ns.past) {
+                if (!visited.has(pastAddr)) queue.push(pastAddr);
+            }
+        }
+    }
+
+    return false;
+}