@ibgib/core-gib 0.1.58 → 0.1.60

package/src/sync/docs/security.md

@@ -285,29 +285,29 @@ We still call `senderCoordinator.sync(...)` — the phase focus is on what `peer
 
 **Goal**: With identity fully established and transport connected, sync a single ibgib `X` from source to dest. Verify S evolves correctly per turn (`sync` pool), and X's full dependency graph arrives on dest. After commit, both sender and receiver durable spaces must contain: the same evolved I, the full S dependency graph, and the full X dependency graph.
 
-#### Phase 3A — Innerspace unit test (`sync-withid.fullsync.respec.mts`)
-
-- [ ] Create `sync-withid.fullsync.respec.mts`
-  - [ ] Create `r1_alpha_v0_source` via `TestTransformer`
-  - [ ] Call `senderCoordinator.sync({ domainIbGibs: [alpha], senderIdentity, senderSecret, ... })`
-  - [ ] `ifWeMight` — `"alpha dep graph matches on source and dest"`: use `getDependencyGraph` + `graphsAreEquivalent`
-  - [ ] `ifWeMight` — `"sessionIdentity evolved the expected number of times"`: assert `S.data.n` equals the known deterministic turn count
-    - [ ] 🔲 **TODO**: Manually inspect the full session keystone graph after a first run and count the exact number of outgoing turns (Init + Delta(s) + Commit), then hard-code that number into this assertion
-  - [ ] `ifWeMight` — `"sender durable space has I (evolved frame)"`: assert I1 addr is in `sourceSpace`
-  - [ ] `ifWeMight` — `"receiver durable space has I (evolved frame)"`: assert I1 addr is in `destSpace`
-  - [ ] `ifWeMight` — `"sender durable space has full S dep graph"`: use `getDependencyGraph` on S in `sourceSpace`
-  - [ ] `ifWeMight` — `"receiver durable space has full S dep graph"`: use `getDependencyGraph` on S in `destSpace`
+#### Phase 3A — Innerspace unit test (`sync-withid.pingpong.respec.mts`)
+
+- [x] Create `sync-withid.pingpong.respec.mts`
+  - [x] Create `r1_alpha_v0_source` (represented by `xStone` test domain ibgib)
+  - [x] Call `senderCoordinator.sync({ domainIbGibs: [alpha], senderIdentity, senderSecret, ... })`
+  - [x] `ifWeMight` — `"alpha dep graph matches on source and dest"`: use `getDependencyGraph` + `graphsAreEquivalent`
+  - [x] `ifWeMight` — `"sessionIdentity evolved the expected number of times"`: assert `S.data.n` equals the known deterministic turn count
+    - [x] ☑ **TODO**: Manually inspect the full session keystone graph after a first run and count the exact number of outgoing turns (Init + Delta(s) + Commit), then hard-code that number into this assertion
+  - [x] `ifWeMight` — `"sender durable space has I (evolved frame)"`: assert I1 addr is in `sourceSpace`
+  - [x] `ifWeMight` — `"receiver durable space has I (evolved frame)"`: assert I1 addr is in `destSpace`
+  - [x] `ifWeMight` — `"sender durable space has full S dep graph"`: use `getDependencyGraph` on S in `sourceSpace`
+  - [x] `ifWeMight` — `"receiver durable space has full S dep graph"`: use `getDependencyGraph` on S in `destSpace`
 
 #### Phase 3B — Space-Gib integrated (manual)
 
-- [ ] Trigger a sync of a known test ibgib via `dev-tools.mts` (add "sync - fullsync" button to a new row)
-- [ ] Confirm S evolves on each outgoing turn (inspect frame `data.n` in debugger)
-- [ ] Confirm X's full dependency graph is present on the client after commit
-- [ ] Confirm X's full dependency graph is present on the server after commit
-- [ ] Confirm S's full dependency graph is present on the client after commit
-- [ ] Confirm S's full dependency graph is present on the server after commit
-- [ ] Confirm I's evolved frame (I1) is present on the client after commit
-- [ ] Confirm I's evolved frame (I1) is present on the server after commit
+- [x] Trigger a sync of a known test ibgib via `dev-tools.mts` (add "sync - fullsync" button to a new row)
+- [x] Confirm S evolves on each outgoing turn (inspect frame `data.n` in debugger)
+- [x] Confirm X's full dependency graph is present on the client after commit
+- [x] Confirm X's full dependency graph is present on the server after commit
+- [x] Confirm S's full dependency graph is present on the client after commit
+- [x] Confirm S's full dependency graph is present on the server after commit
+- [x] Confirm I's evolved frame (I1) is present on the client after commit
+- [x] Confirm I's evolved frame (I1) is present on the server after commit
 
 
 ---
@@ -320,14 +320,14 @@ The sync proper will not be called. The test only cares that the pre-connect ide
 
 #### Phase 1A — Innerspace unit test
 
-- [ ] Create `sync-with-identity-basic.respec.mts` with scaffold:
+- [x] Create `sync-withid.establish.respec.mts` with scaffold:
   - `Metaspace_Innerspace` + two `InnerSpace_V1` (source/dest) + `SyncSagaCoordinator` pair + `newTestPeer()` factory
   - A `senderSecret` constant (test-only plaintext)
   - A `KeystoneService_V1` instance (new'd inline)
-- [ ] Add `respecfully` block: `"Phase 1: establishSessionIdentity"`
-  - [ ] `ifWeMight` — `"creates sessionIdentity genesis (S) locally"`: assert `S^Stjp` was generated and exists in `sourceSpace`
-  - [ ] `ifWeMight` — `"evolves senderIdentity (I → I1) with sync claim"`: assert `I1` frame has a proof whose `claim.verb === 'sync'` and `claim.target === S^Stjp`
-  - [ ] `ifWeMight` — `"posts I1 and S to destSpace (receiver)"`: assert both addrs are retrievable from `destSpace`
+- [x] Add `respecfully` block: `"Phase 1: establishSessionIdentity"`
+  - [x] `ifWeMight` — `"creates sessionIdentity genesis (S) locally"`: assert `S^Stjp` was generated and exists in `sourceSpace`
+  - [x] `ifWeMight` — `"evolves senderIdentity (I → I1) with sync claim"`: assert `I1` frame has a proof whose `claim.verb === 'sync'` and `claim.target === S^Stjp`
+  - [x] `ifWeMight` — `"posts I1 and S to destSpace (receiver)"`: assert both addrs are retrievable from `destSpace`
 
 #### Phase 1B — Space-Gib integrated (manual)
 
@@ -344,7 +344,7 @@ The sync proper will not be called. The test only cares that the pre-connect ide
 
 #### Phase 2A — Innerspace unit test
 
-- [x] Extend `sync-with-identity-basic.respec.mts` with a `respecfully` block: `"Phase 2: connect"` (Note: implemented in separate file `sync-withid.connect.respec.mts`)
+- [x] Create `sync-withid.connect.respec.mts` with a `respecfully` block: `"Phase 2: connect"`
   - [x] `ifWeMight` — `"connect completes without error"`: call `peer.connect()` and assert no exception
   - [x] `ifWeMight` — `"connect pool is depleted by exactly one challenge"`: assert `S.data.pools['connect'].used` increased by the expected count
 
@@ -362,19 +362,87 @@ The sync proper will not be called. The test only cares that the pre-connect ide
 
 #### Phase 3A — Innerspace unit test
 
-- [ ] Extend `sync-with-identity-basic.respec.mts` or create `sync-with-identity-singletimeline.respec.mts`
-  - [ ] Create `r1_alpha_v0_source` via `TestTransformer`
-  - [ ] Call `senderCoordinator.sync({ domainIbGibs: [alpha], senderIdentity, senderSecret, ... })`
-  - [ ] `ifWeMight` — `"alpha dep graph matches on source and dest"`: use `getDependencyGraph` + `graphsAreEquivalent`
-  - [ ] `ifWeMight` — `"sessionIdentity evolved once per sync turn"`: assert `S.data.n` equals number of outgoing turns
+- [x] Create `sync-withid.pingpong.respec.mts`
+  - [x] Create `r1_alpha_v0_source` via `TestTransformer` (represented by `xStone` test domain ibgib)
+  - [x] Call `senderCoordinator.sync({ domainIbGibs: [alpha], senderIdentity, senderSecret, ... })`
+  - [x] `ifWeMight` — `"alpha dep graph matches on source and dest"`: use `getDependencyGraph` + `graphsAreEquivalent`
+  - [x] `ifWeMight` — `"sessionIdentity evolved once per sync turn"`: assert `S.data.n` equals number of outgoing turns
 
 #### Phase 3B — Space-Gib integrated (manual)
 
-- [ ] Trigger a sync of a known test ibgib via `dev-tools.mts` or equivalent UI
-- [ ] Confirm S evolves on each outgoing turn (inspect frame `data.n` in debugger)
-- [ ] Confirm X's full dependency graph is present on the client after commit
-- [ ] Confirm X's full dependency graph is present on the server after commit
-- [ ] Confirm S's full dependency graph is present on the client after commit
-- [ ] Confirm S's full dependency graph is present on the server after commit
-- [ ] Confirm I's full dependency graph is present on the client after commit
-- [ ] Confirm I's full dependency graph is present on the server after commit
+- [x] Trigger a sync of a known test ibgib via `dev-tools.mts` or equivalent UI
+- [x] Confirm S evolves on each outgoing turn (inspect frame `data.n` in debugger)
+- [x] Confirm X's full dependency graph is present on the client after commit
+- [x] Confirm X's full dependency graph is present on the server after commit
+- [x] Confirm S's full dependency graph is present on the client after commit
+- [x] Confirm S's full dependency graph is present on the server after commit
+- [x] Confirm I's full dependency graph is present on the client after commit
+- [x] Confirm I's full dependency graph is present on the server after commit
+
+---
+
+### Phase 4 — Advanced Data and Conflict Scenarios
+
+**Goal**: Extend the WebSocket peer and Space-Gib interface to manually execute and verify all advanced data and conflict scenarios currently covered by the InnerSpace unit tests.
+
+For each scenario, verify automated innerspace tests (A) are fully functional, and create manual websocket peer tests (B) with corresponding buttons/UI elements.
+
+#### 1. Sync InnerSpace (Basic Push Sync)
+- [ ] Phase 4.1A — Automated InnerSpace Verification (`sync-innerspace.respec.mts`)
+- [ ] Phase 4.1B — WebSocket Peer Manual Verification (integrated via Dev Tools)
+  * Tests basic push sync of a single timeline and its mutations from Source to Destination.
+  * Verifies that the target timeline tip and its dependency graph successfully arrive at the destination.
+
+#### 2. Sync Constants (No TJP)
+- [ ] Phase 4.2A — Automated InnerSpace Verification (`sync-innerspace-constants.respec.mts`)
+- [ ] Phase 4.2B — WebSocket Peer Manual Verification (integrated via Dev Tools)
+  * Tests syncing "constants" (ibGibs without timelines/TJPs) and verifies that dependencies (linked constants) are resolved.
+  * Ensures idempotency/smart diffing (payloads are not re-sent if they already exist in the destination space).
+
+#### 3. Sync Destination with Partial History
+- [ ] Phase 4.3A — Automated InnerSpace Verification (`sync-innerspace-partial-update.respec.mts`)
+- [ ] Phase 4.3B — WebSocket Peer Manual Verification (integrated via Dev Tools)
+  * Tests push synchronization when the destination already contains a partial timeline history (e.g., up to V1), but the sender has newer frames (V2).
+  * Verifies that only the delta is transmitted and correctly linked to the existing history at the destination.
+
+#### 4. Sync Deep History Updates
+- [ ] Phase 4.4A — Automated InnerSpace Verification (`sync-innerspace-deep-updates.respec.mts`)
+- [ ] Phase 4.4B — WebSocket Peer Manual Verification (integrated via Dev Tools)
+  * Tests push synchronization of a timeline tip with a deep mutation history (multiple updates).
+  * Verifies that the destination receives all intermediate frames, preserving the full timeline history and graph integrity.
+
+#### 5. Sync Destination Ahead (Remote Newer)
+- [ ] Phase 4.5A — Automated InnerSpace Verification (`sync-innerspace-dest-ahead.respec.mts`)
+- [ ] Phase 4.5B — WebSocket Peer Manual Verification (integrated via Dev Tools)
+  * Tests synchronization when the destination (remote) actually has a newer frame (V2) than the sender's local tip (V1).
+  * Verifies that the sender learns of the remote tip and pulls it down so both client and server converge to the dest-ahead tip.
+
+#### 6. Sync Multiple Independent Timelines
+- [ ] Phase 4.6A — Automated InnerSpace Verification (`sync-innerspace-multiple-timelines.respec.mts`)
+- [ ] Phase 4.6B — WebSocket Peer Manual Verification (integrated via Dev Tools)
+  * Tests synchronization of multiple independent timelines (e.g., Timeline A and Timeline B) in a single sync coordinator call.
+  * Verifies that both timeline tips and their respective dependency graphs are transferred and updated correctly.
+
+#### 7. Basic Divergence Conflict Resolution
+- [ ] Phase 4.7A — Automated InnerSpace Verification (`sync-conflict-basic-divergence.respec.mts`)
+- [ ] Phase 4.7B — WebSocket Peer Manual Verification (integrated via Dev Tools)
+  * Tests divergence when source and destination edit different fields on a shared base timeline simultaneously.
+  * Verifies that optimistic merge automatically produces a merged tip (V3) containing both edits and records the graft metadata (`graftbase`, `graftorphan`).
+
+#### 8. Divergence with Related Timelines
+- [ ] Phase 4.8A — Automated InnerSpace Verification (`sync-conflict-basic-multitimelines.respec.mts`)
+- [ ] Phase 4.8B — WebSocket Peer Manual Verification (integrated via Dev Tools)
+  * Tests advanced divergence where one of the divergent updates also references/relates a new independent timeline (Beta).
+  * Verifies that during optimistic merge, the dependent timeline is synced automatically alongside the merged tip.
+
+#### 9. Text Field Merge (LCS) Conflict Resolution
+- [ ] Phase 4.9A — Automated InnerSpace Verification (`sync-conflict-text-merge.respec.mts`)
+- [ ] Phase 4.9B — WebSocket Peer Manual Verification (integrated via Dev Tools)
+  * Tests automatic merging of conflicting string edits within the `ibgib.data.text` field using the LCS (Longest Common Subsequence) merge algorithm.
+  * Verifies merging of simple appends (beginning vs. end) and interleaved edits in different paragraphs.
+
+#### 10. Advanced Multi-Round/Timeline Permutations
+- [ ] Phase 4.10A — Automated InnerSpace Verification (`sync-conflict-adv-multitimelines.respec.mts`)
+- [ ] Phase 4.10B — WebSocket Peer Manual Verification (integrated via Dev Tools)
+  * Tests complex multi-round/timeline permutations with parallel divergent edits across multiple rounds.
+  * Verifies that nested or sequential merges resolve correctly using the optimistic graft strategy.

package/src/sync/sync-peer/sync-peer-http-receiver/sync-peer-http-receiver-v1.mts

@@ -8,7 +8,7 @@ import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
 import { GLOBAL_LOG_A_LOT } from '../../../core-constants.mjs';
 import { SyncPeer_V1 } from '../sync-peer-v1.mjs';
 import { SyncSagaContextIbGib_V1 } from '../../sync-saga-context/sync-saga-context-types.mjs';
-import { authenticateContext } from '../../sync-saga-context/sync-saga-context-helpers.mjs';
+import { authenticateContextIntrinsically } from '../../sync-saga-context/sync-saga-context-helpers.mjs';
 import { IbGibSpaceAny } from '../../../witness/space/space-base-v1.mjs';
 import {
     InitializeSyncPeerHttpReceiverOpts,
@@ -160,13 +160,16 @@ export class SyncPeerHttpReceiver_V1
 
             // Put control ibgibs into durable space
             const allControlIbGibs = [context, ...payloadIbGibsControl];
+            if (context.signedSessionIdentity) {
+                allControlIbGibs.push(context.signedSessionIdentity);
+            }
             for (const ibGib of allControlIbGibs) {
                 await putInSpace({ space: localSpace, ibGibs: [ibGib] });
                 await registerNewIbGib({ space: localSpace, ibGib });
             }
 
             // Auth verification (Bill architecture: turn-based context signing)
-            const authErrors = await authenticateContext({
+            const authErrors = await authenticateContextIntrinsically({
                 context,
                 space: localSpace,
             });
@@ -186,6 +189,7 @@ export class SyncPeerHttpReceiver_V1
                 metaspace: localMetaspace,
                 mySpace: localSpace,
                 myTempSpace: localTempSpace,
+                peer: this,
             });
 
             return responseCtx || undefined;

package/src/sync/sync-peer/sync-peer-innerspace/sync-peer-innerspace-types.mts

@@ -45,7 +45,7 @@ export interface SyncPeerInnerspaceOptions {
      */
     receiverTempSpace?: IbGibSpaceAny;
     /**
-     * The sender coordinator, used for authentication-related (k eystones).
+     * The sender coordinator, used for authentication-related (keystones).
      */
     senderCoordinator?: SyncSagaCoordinator;
 }

package/src/sync/sync-peer/sync-peer-innerspace/sync-peer-innerspace-v1.mts

@@ -12,14 +12,14 @@ import { SyncPeer_V1 } from '../sync-peer-v1.mjs';
 import { putInSpace, registerNewIbGib } from '../../../witness/space/space-helper.mjs';
 import { SyncSagaContextIbGib_V1, } from '../../sync-saga-context/sync-saga-context-types.mjs';
 import { SyncPeerInnerspaceData_V1, SyncPeerInnerspaceIbGib_V1, SyncPeerInnerspaceOptions, SyncPeerInnerspaceRel8ns_V1 } from './sync-peer-innerspace-types.mjs';
-import { authenticateContext } from '../../sync-saga-context/sync-saga-context-helpers.mjs';
+import { authenticateContextIntrinsically } from '../../sync-saga-context/sync-saga-context-helpers.mjs';
 import { MetaspaceService } from '../../../witness/space/metaspace/metaspace-types.mjs';
 import { SyncSagaCoordinator } from '../../sync-saga-coordinator.mjs';
 import { ConnectSyncPeerOpts, InitializeSyncPeerOpts } from '../sync-peer-types.mjs';
 import { getSyncSagaFrameDependencyGraph, putInSpace_dnasThenNonDnas } from '../../sync-helpers.mjs';
 import { getDependencyGraph } from '../../../common/other/graph-helper.mjs';
 import { SyncStage } from '../../sync-constants.mjs';
-import { toDto } from '../../../common/other/ibgib-helper.mjs';import { KeystoneIbGib_V1 } from '../../../keystone/keystone-types.mjs';
+import { toDto } from '../../../common/other/ibgib-helper.mjs'; import { KeystoneIbGib_V1 } from '../../../keystone/keystone-types.mjs';
 
 
 const logalot = GLOBAL_LOG_A_LOT;
@@ -52,7 +52,7 @@ export interface InitializeSyncPeerInnerspaceOpts extends InitializeSyncPeerOpts
      */
     receiverTempSpace?: IbGibSpaceAny;
     /**
-     * The sender coordinator, used for authentication-related (k eystones).
+     * The sender coordinator, used for authentication-related (keystones).
      */
     senderCoordinator?: SyncSagaCoordinator;
 }
@@ -205,6 +205,7 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1<ConnectSyncPeerInnerspace
 
             const { sagaFrame } = context;
 
+
             // The context has already been validated, authenticated and authorized at this point.
 
             // #region sanity validation assertions
@@ -242,8 +243,7 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1<ConnectSyncPeerInnerspace
             const msg = msgStones[0];
             if (!msg.data) { throw new Error(`(UNEXPECTED) sync saga message ibgib.data falsy? (E: 61ec18743988ad3cbab2072d1dd69826)`); }
 
-
-            // this is where we did the i dentityIbGibs
+            // this is where we did the identityIbGibs
 
             // send the context itself, then send the payload ibgibs separately.
             // in this innerspace, this just means putting the control ibgibs
@@ -257,6 +257,9 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1<ConnectSyncPeerInnerspace
             const payloadIbGibsControl = [
                 msg, sagaFrame, context
             ].map(x => toDto({ ibGib: x }));
+            if (context.signedSessionIdentity) {
+                payloadIbGibsControl.push(toDto({ ibGib: context.signedSessionIdentity }));
+            }
             if (logalot) { console.log(`${lc} putting into receiverSpace: ${receiverSpace.ib} (I: 1ba18b14a26bdd0e7800da4812898826)`); }
             await putInSpace({
                 ibGibs: payloadIbGibsControl,
@@ -288,20 +291,14 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1<ConnectSyncPeerInnerspace
             // the payload ibgibs. so the receiver coordinator should be ready
             // to do its thing.
 
-            // Auth verification (Bill architecture: turn-based context signing)
-            const authErrors = await authenticateContext({
-                context,
-                space: receiverSpace,
-            });
-            if (authErrors.length > 0) {
-                throw new Error(`Context authentication failed: ${authErrors.join(', ')} (E: d34b8ad98d84e1ba8d8f7facd288826)`);
-            }
+            // NOTE: We have already validated/authenticated/authorized context at this point, as we called it before invoking this method (sendContextRequest)
 
             const responseCtx = await receiverCoordinator.continueSync({
                 sagaContext: context,
                 metaspace: receiverMetaspace,
                 mySpace: receiverSpace,
                 myTempSpace: receiverTempSpace,
+                peer: this,
             });
 
             if (logalot) { console.log(`${lc} receiverCoordinator.continueSync responseCtx: ${responseCtx ? pretty(responseCtx) : 'undefined'} (I: fb2831decde1f2b3589021f85ab19126)`); }
@@ -328,7 +325,7 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1<ConnectSyncPeerInnerspace
             if (!msgResponse.data) { throw new Error(`(UNEXPECTED) sync saga message ibgib.data falsy? (E: 61ec18743988ad3cbab2072d1dd69826)`); }
 
             const responsePayloadIbGibsControl = [
-                msgResponse, responseCtx.sagaFrame, context
+                msgResponse, responseCtx.sagaFrame, responseCtx
             ].map(x => toDto({ ibGib: x }));
             // ...put into sender's durable space
             await putInSpace({

package/src/sync/sync-peer/sync-peer-types.mts

@@ -3,6 +3,7 @@
  */
 
 import { IbGibData_V1, IbGibRel8ns_V1, IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { IbGibAddr } from '@ibgib/ts-gib/dist/types.mjs';
 
 import { SubjectWitness } from '../../common/pubsub/subject/subject-types.mjs';
 import { SyncSagaContextData_V1, SyncSagaContextIbGib_V1, SyncSagaContextRel8ns_V1 } from '../sync-saga-context/sync-saga-context-types.mjs';
@@ -162,6 +163,12 @@ export interface SyncPeerWitness<TInitializeOpts extends InitializeSyncPeerOpts
      */
     payloadIbGibsDomainReceived$: SubjectWitness<IbGib_V1>;
 
+    currentSessionIdentity: KeystoneIbGib_V1 | undefined;
+    /**
+     * convenience getter for {@link currentSessionIdentity}
+     */
+    get currentSessionIdentityAddr(): IbGibAddr | undefined;
+
     /**
      * Pre-connect phase: creates the session keystone (S) locally, evolves
      * `senderIdentity` (I → I1) with a `sync` claim targeting S, and posts
@@ -174,7 +181,7 @@ export interface SyncPeerWitness<TInitializeOpts extends InitializeSyncPeerOpts
      * this reference for the remainder of the saga. The name `newSenderIdentity`
      * (I1) is intentionally scoped only within this method to avoid confusion.
      */
-    establishSessionIdentity(): Promise<KeystoneIbGib_V1 | undefined>;
+    establishSessionIdentity(): Promise<void>;
 
     /**
      * Establishes the connection context.
@@ -184,4 +191,24 @@ export interface SyncPeerWitness<TInitializeOpts extends InitializeSyncPeerOpts
      * @param opts Connection options, including the sagaId for the upcoming sync saga.
      */
     connect(opts?: { sagaId?: string }): Promise<void>;
+
+    // /**
+    //  * Returns the sender's long-lived primary/domain identity.
+    //  */
+    // getSenderIdentity(): KeystoneIbGib_V1 | undefined;
+
+    /**
+     * Evolves the session identity (S_n -> S_n+1) and signs targeting
+     * contextAddr for the **sync** verb. This is in contrast to signing for
+     * the "connect" verb, for which you use {@link signContextConnect}
+     */
+    signContext(opts: { contextAddr: IbGibAddr }): Promise<KeystoneIbGib_V1 | undefined>;
+
+    /**
+     * Evolves the session identity (S_n -> S_n+1) solving the demanded connect
+     * challenges.  This is NOT for signing session when doing the ping pong of
+     * sync protocol. For that, you use {@link signContext}
+     */
+    signContextConnect(opts: { challengeUuid: string, demandedIds: string[] }): Promise<KeystoneIbGib_V1 | undefined>;
+
 }

package/src/sync/sync-peer/sync-peer-v1.mts

@@ -7,11 +7,8 @@
 import { extractErrorMsg } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
 import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
 import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
-import { IbGibAddr } from '@ibgib/ts-gib/dist/types.mjs';
-import { validateIbGibIntrinsically } from '@ibgib/ts-gib/dist/V1/validate-helper.mjs';
 
 import { GLOBAL_LOG_A_LOT } from '../../core-constants.mjs';
-import { SYNC_MSG_REL8N_NAME, SYNC_SAGA_PAYLOAD_ADDRS_DOMAIN } from '../sync-constants.mjs';
 import { SubjectWitness } from '../../common/pubsub/subject/subject-types.mjs';
 import { SyncSagaContextIbGib_V1 } from '../sync-saga-context/sync-saga-context-types.mjs';
 import {
@@ -19,19 +16,18 @@ import {
     SyncPeerRel8ns_V1, SyncPeerWitness
 } from './sync-peer-types.mjs';
 import { LightWitnessBase_V1 } from '../../witness/light-witness-base-v1.mjs';
-import { IbGibSpaceAny } from '../../witness/space/space-base-v1.mjs';
 import { newupSubject } from '../../common/pubsub/subject/subject-helper.mjs';
-import { authenticateContext, authorizeContext, validateContextAndSagaFrame } from '../sync-saga-context/sync-saga-context-helpers.mjs';
+import { authenticateContextIntrinsically, validateContextAndSagaFrame } from '../sync-saga-context/sync-saga-context-helpers.mjs';
 import { getFromSpace } from '../../witness/space/space-helper.mjs';
 import { getFullSyncSagaHistory, deriveSessionSecret } from '../sync-helpers.mjs';
-import { SyncSagaFrameDependencyGraph } from '../sync-types.mjs';
+import { SessionGenesisFrameDetails, SyncSagaFrameDependencyGraph } from '../sync-types.mjs';
 import { KeystoneService_V1 } from '../../keystone/keystone-service-v1.mjs';
 import { KeystoneIbGib_V1 } from '../../keystone/keystone-types.mjs';
-import { KEYSTONE_VERB_SYNC } from '../../keystone/keystone-constants.mjs';
+import { KEYSTONE_VERB_CONNECT, KEYSTONE_VERB_SYNC, POOL_ID_CONNECT, } from '../../keystone/keystone-constants.mjs';
+import { getTjpAddr } from '../../common/other/ibgib-helper.mjs';
+import { IbGibAddr } from '@ibgib/ts-gib/dist/types.mjs';
 
 const logalot = GLOBAL_LOG_A_LOT;
-const logalotControlDomain = false;
-const lcControlDomain = '[ControlDomain]';
 
 
 /**
@@ -54,6 +50,100 @@ export abstract class SyncPeer_V1<
 
     public opts: TInitializeOpts | undefined;
     public payloadIbGibsDomainReceived$!: SubjectWitness<IbGib_V1>;
+    public currentSessionIdentity: KeystoneIbGib_V1 | undefined;
+    public get currentSessionIdentityAddr(): IbGibAddr | undefined {
+        return this.currentSessionIdentity ?
+            getIbGibAddr({ ibGib: this.currentSessionIdentity }) :
+            undefined;
+    }
+
+    // public getSenderIdentity(): KeystoneIbGib_V1 | undefined {
+    //     return this.opts?.senderIdentity;
+    // }
+
+    public async signContext({
+        contextAddr,
+    }: {
+        contextAddr: IbGibAddr;
+    }): Promise<KeystoneIbGib_V1 | undefined> {
+        const lc = `${this.lc}[${this.signContext.name}]`;
+        try {
+            if (!this.currentSessionIdentity) {
+                return undefined;
+            }
+            if (!this.opts) { throw new Error(`opts not initialized. (E: bcf5978aed789b0ebcbdc51971ebe826)`); }
+            const { fnSenderSecret, sagaId, localMetaspace, localSpace } = this.opts;
+            if (!fnSenderSecret) { throw new Error(`fnSenderSecret not initialized. (E: 207fd292a2e8c53c05fd0a74a4ae6d26)`); }
+            if (!sagaId) { throw new Error(`sagaId not initialized. (E: f2e35cc13ed873b638116188119d1826)`); }
+
+            const senderSecret = await fnSenderSecret();
+            const sessionSecret = await deriveSessionSecret({ senderSecret, sagaId });
+
+            const keystoneSvc = new KeystoneService_V1();
+            const evolved = await keystoneSvc.sign({
+                latestKeystone: this.currentSessionIdentity,
+                masterSecret: sessionSecret,
+                claim: {
+                    verb: KEYSTONE_VERB_SYNC,
+                    target: contextAddr,
+                },
+                metaspace: localMetaspace,
+                space: localSpace,
+            });
+
+            this.currentSessionIdentity = evolved;
+            return evolved;
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        }
+    }
+
+    /**
+ * Evolves the session identity (S_n -> S_n+1) solving the demanded connect challenges.
+ */
+    public async signContextConnect({
+        challengeUuid,
+        demandedIds,
+    }: {
+        challengeUuid: string;
+        demandedIds: string[];
+    }): Promise<KeystoneIbGib_V1 | undefined> {
+        const lc = `${this.lc}[${this.signContextConnect.name}]`;
+        try {
+            if (!this.currentSessionIdentity) {
+                return undefined;
+            }
+            if (!this.opts) { throw new Error(`opts not initialized. (E: bcf5978aed789b0ebcbdc51971ebe826)`); }
+            const { fnSenderSecret, sagaId, localMetaspace, localSpace } = this.opts;
+            if (!fnSenderSecret) { throw new Error(`fnSenderSecret not initialized. (E: 207fd292a2e8c53c05fd0a74a4ae6d26)`); }
+            if (!sagaId) { throw new Error(`sagaId not initialized. (E: f2e35cc13ed873b638116188119d1826)`); }
+
+            const senderSecret = await fnSenderSecret();
+            const sessionSecret = await deriveSessionSecret({ senderSecret, sagaId });
+
+            const keystoneSvc = new KeystoneService_V1();
+            const evolved = await keystoneSvc.sign({
+                latestKeystone: this.currentSessionIdentity,
+                masterSecret: sessionSecret,
+                poolId: POOL_ID_CONNECT,
+                requiredChallengeIds: demandedIds,
+                claim: {
+                    verb: KEYSTONE_VERB_CONNECT,
+                    target: challengeUuid,
+                },
+                metaspace: localMetaspace,
+                space: localSpace,
+            });
+
+            this.currentSessionIdentity = evolved;
+            return evolved;
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        }
+    }
+
 
     get classname(): string {
         if (!this.data) { throw new Error(`(UNEXPECTED) this.data falsy? (E: 1ab1841e9338b54f3aa615fa37024826)`); }
@@ -127,7 +217,7 @@ export abstract class SyncPeer_V1<
      * hold a reference for subsequent per-turn signing. The name
      * `newSenderIdentity` (I1) is scoped only within this method.
      */
-    public async establishSessionIdentity(): Promise<KeystoneIbGib_V1 | undefined> {
+    public async establishSessionIdentity(): Promise<void> {
         const lc = `${this.lc}[${this.establishSessionIdentity.name}]`;
         try {
             if (logalot) { console.log(`${lc} starting... (I: f2a1b3c4d5e6f7a8b9c0d1e2f3a4b526)`); }
@@ -141,6 +231,9 @@ export abstract class SyncPeer_V1<
                 if (logalot) { console.log(`${lc} no senderIdentity/fnSenderSecret — skipping establish (I: f29348a77d1542326d14043ea4b69126)`); }
                 return undefined;
             }
+            const senderIdentityAddr = getIbGibAddr({ ibGib: senderIdentity });
+            const senderIdentityTjpAddr = getTjpAddr({ ibGib: senderIdentity });
+            if (!senderIdentityTjpAddr) { throw new Error(`(UNEXPECTED) senderIdentityTjpAddr falsy? (E: d5d8c3ab25a83a2c127904fe96de1526)`); }
 
             if (!sagaId) { throw new Error(`(UNEXPECTED) sagaId falsy? Must be set in initializeOpts before calling establishSessionIdentity. (E: c6ba389d51b8af07d82458f875cf9826)`); }
 
@@ -155,10 +248,19 @@ export abstract class SyncPeer_V1<
             if (!this.opts.sessionConnectPoolConfig) { throw new Error(`(UNEXPECTED) opts.sessionConnectPoolConfig falsy? (E: 3351fd566eb8bbd2f821bb08c4419826)`); }
             if (!this.opts.sessionSyncPoolConfig) { throw new Error(`(UNEXPECTED) opts.sessionSyncPoolConfig falsy? (E: dbffa810d9e7ff6079088deb5b8e7826)`); }
 
+            // session genesis keystone should have soft links to both
+            // targetAddrs and the sender identity that spawned it.
+            const frameDetails: SessionGenesisFrameDetails = {
+                senderIdentityAddr,
+                senderIdentityTjpAddr,
+            }
+            if (this.opts.targetAddrs) {
+                frameDetails.targetAddrs = this.opts.targetAddrs
+            }
             const sessionIdentity = await keystoneSvc.genesis({
                 masterSecret: sessionSecret,
                 configs: [this.opts.sessionConnectPoolConfig, this.opts.sessionSyncPoolConfig],
-                frameDetails: this.opts.targetAddrs ? { targetAddrs: this.opts.targetAddrs } : undefined,
+                frameDetails,
                 metaspace: localMetaspace,
                 space: localSpace,
             });
@@ -179,7 +281,7 @@ export abstract class SyncPeer_V1<
             // Step 3: Post both to the receiver (peer-specific).
             await this.postEstablishToReceiver({ newSenderIdentity, sessionIdentity });
 
-            return sessionIdentity;
+            this.currentSessionIdentity = sessionIdentity;
         } catch (error) {
             console.error(`${lc} ${extractErrorMsg(error)}`);
             throw error;
@@ -257,16 +359,12 @@ export abstract class SyncPeer_V1<
     //     }
     // }
 
-
-
-    protected async authenticateValidateAuthorize({
+    protected async authenticateAndValidate({
         context,
-        fullSagaHistory,
     }: {
         context: SyncSagaContextIbGib_V1,
-        fullSagaHistory: SyncSagaFrameDependencyGraph[],
     }): Promise<void> {
-        const lc = `${this.lc}[${this.authenticateValidateAuthorize.name}]`;
+        const lc = `${this.lc}[${this.authenticateAndValidate.name}]`;
         try {
             if (logalot) { console.log(`${lc} starting... (I: add238055cd84a222c5b8c89913af526)`); }
 
@@ -274,7 +372,8 @@ export abstract class SyncPeer_V1<
             const { localSpace } = this.opts;
 
             // first authenticate, because invalid authn is a non-starter
-            const authenticationErrors = await authenticateContext({
+            // (already validated intrinsically)
+            const authenticationErrors = await authenticateContextIntrinsically({
                 context,
                 space: localSpace,
             });
@@ -288,12 +387,6 @@ export abstract class SyncPeer_V1<
             if (validationErrors.length > 0) {
                 throw new Error(`invalid context received. validationErrors: ${validationErrors} (E: 8b34c875c968af29bc433138e57a7826)`);
             }
-            // we have a valid authentication that points to a valid context,
-            // but what exactly is authorized ?
-            const authorizationErrors = await authorizeContext({ context, fullSagaHistory });
-            if (authorizationErrors.length > 0) {
-                throw new Error(`invalid context authorization. authorizationErrors: ${authorizationErrors} (E: 8ddc284a758cf10ba829334c1babb826)`);
-            }
         } catch (error) {
             console.error(`${lc} ${extractErrorMsg(error)}`);
             throw error;
@@ -361,14 +454,12 @@ export abstract class SyncPeer_V1<
             // this is not just happening on the client, but this peer may be
             // the one receiving the context as well.
 
-            const sagaHistory_beforeSend = await getFullSyncSagaHistory({
-                sagaIbGib: context.sagaFrame,
-                space: this.opts.localSpace
-            });
+            // const sagaHistory_beforeSend = await getFullSyncSagaHistory({
+            //     sagaIbGib: context.sagaFrame,
+            //     space: this.opts.localSpace
+            // });
 
-            await this.authenticateValidateAuthorize({
-                context, fullSagaHistory: sagaHistory_beforeSend,
-            });
+            await this.authenticateAndValidate({ context });
 
             // at this point, we have a valid, authenticated, authorized context
 
@@ -389,9 +480,10 @@ export abstract class SyncPeer_V1<
                     space: this.opts.localSpace
                 });
 
-                await this.authenticateValidateAuthorize({
-                    context, fullSagaHistory: sagaHistory_afterSend,
-                });
+                // NOTE: I think this is the wrong place for this, as we must do this in the peer **before** storing any control ibgibs. This needs to be done in the continueSync I _think_ (not sure yet)
+                // await this.authenticateValidateAuthorize({
+                //     context, fullSagaHistory: sagaHistory_afterSend,
+                // });
 
                 return response;
             } else {