test: cover v18 hologram release gates

Author: flyingrobots

docs/design/0273-v18-continuum-evidence-posture-lattice/v18-continuum-evidence-posture-lattice.md

@@ -60,10 +60,10 @@ By the end of this design cycle, the `ContinuumEvidencePosture` class will be re
 ## Current Truth
 
 At the start of this cycle, `ContinuumEvidencePosture.ts` defined the posture as a flat string enum:
-[src/domain/continuum/ContinuumEvidencePosture.ts#8](file:///Users/james/git/git-stunts/git-warp/src/domain/continuum/ContinuumEvidencePosture.ts#L8).
+[src/domain/continuum/ContinuumEvidencePosture.ts#L8](../../../src/domain/continuum/ContinuumEvidencePosture.ts#L8).
 This collapses the dimensions, meaning we cannot distinguish between "translated but witnessed" and "native but redacted" history.
 This flat posture is used inside `ContinuumEvidenceClaim` to validate UCAN-style proof presence:
-[src/domain/continuum/ContinuumEvidenceClaim.ts#50](file:///Users/james/git/git-stunts/git-warp/src/domain/continuum/ContinuumEvidenceClaim.ts#L50).
+[src/domain/continuum/ContinuumEvidenceClaim.ts#L50](../../../src/domain/continuum/ContinuumEvidenceClaim.ts#L50).
 
 Paper VIII also defines `Scratch`, `AuthorOnly`, and `Shared` as revelation postures on observer coordinates and holograms. Those are not evidence-posture values and must not be folded into `ContinuumEvidencePosture`.
 

docs/design/0274-v18-zk-verkle-wormholes/v18-zk-verkle-wormholes.md

@@ -57,7 +57,7 @@ By the end of this design cycle, the domain will define replay-bearing hologram
 ## Current Truth
 
 Currently, `WormholeService.ts` only supports sequential replay of `ProvenancePayload`:
-[src/domain/services/WormholeService.ts#48](file:///Users/james/git/git-stunts/git-warp/src/domain/services/WormholeService.ts#L48).
+[src/domain/services/WormholeService.ts#L48](../../../src/domain/services/WormholeService.ts#L48).
 There is no representation of Verkle roots, space-time bivariate polynomials, or SNARK proofs in the codebase.
 
 The current Continuum witness ladder already separates replay core, witness core, and receipt shell for tick receipts. It does not yet generalize that replay/materialization contract to braid holograms or suffix-transform holograms.

test/unit/domain/continuum/ContinuumEvidencePosture.test.ts

@@ -93,9 +93,35 @@ describe('ContinuumEvidencePosture', () => {
 
     expect(claim.isNativeContinuumEvidence()).toBe(true);
     expect(claim.nativeWitnessProof).toBeUndefined();
+    expect(claim.posture.access.equals(ContinuumEvidenceAccess.redacted())).toBe(true);
     expect(claim.posture.canAuthorizeReplayShortcut()).toBe(false);
   });
 
+  it('accepts string coordinates and exposes all lattice coordinate helpers', () => {
+    const posture = new ContinuumEvidencePosture({
+      origin: 'fixture',
+      proofStrength: 'digest-only',
+      access: 'credential-required',
+      completeness: 'residual',
+    });
+    const syntheticOrigin = ContinuumEvidenceOrigin.synthetic();
+    const claimedProof = ContinuumEvidenceProofStrength.claimed();
+    const deniedAccess = ContinuumEvidenceAccess.denied();
+    const partialCompleteness = ContinuumEvidenceCompleteness.partial();
+    const obstructedCompleteness = ContinuumEvidenceCompleteness.obstructed();
+
+    expect(posture.toString()).toBe('fixture:digest-only:credential-required:residual');
+    expect(posture.origin.equals(ContinuumEvidenceOrigin.fixture())).toBe(true);
+    expect(posture.proofStrength.equals(ContinuumEvidenceProofStrength.digestOnly())).toBe(true);
+    expect(posture.access.requiresCredential()).toBe(true);
+    expect(posture.completeness.equals(ContinuumEvidenceCompleteness.residual())).toBe(true);
+    expect(syntheticOrigin.toString()).toBe('synthetic');
+    expect(claimedProof.toString()).toBe('claimed');
+    expect(deniedAccess.toString()).toBe('denied');
+    expect(partialCompleteness.toString()).toBe('partial');
+    expect(obstructedCompleteness.toString()).toBe('obstructed');
+  });
+
   it('rejects native witness proof when posture is not native evidence', () => {
     const descriptor = makeGeneratedReceiptDescriptor();
 
@@ -130,13 +156,39 @@ describe('ContinuumEvidencePosture', () => {
   it('rejects missing or invalid posture coordinates', () => {
     const descriptor = makeGeneratedReceiptDescriptor();
 
+    expect(() => new ContinuumEvidencePosture(
+      // @ts-expect-error runtime guard for JavaScript callers
+      undefined,
+    )).toThrow(WarpError);
+
     expect(() => new ContinuumEvidencePosture({
       origin: 'invalid',
       proofStrength: 'witnessed',
       access: 'available',
       completeness: 'complete',
     })).toThrow(WarpError);
 
+    expect(() => new ContinuumEvidencePosture({
+      origin: 'translated',
+      proofStrength: 'invalid',
+      access: 'available',
+      completeness: 'complete',
+    })).toThrow(WarpError);
+
+    expect(() => new ContinuumEvidencePosture({
+      origin: 'translated',
+      proofStrength: 'witnessed',
+      access: 'invalid',
+      completeness: 'complete',
+    })).toThrow(WarpError);
+
+    expect(() => new ContinuumEvidencePosture({
+      origin: 'translated',
+      proofStrength: 'witnessed',
+      access: 'available',
+      completeness: 'invalid',
+    })).toThrow(WarpError);
+
     expect(() => new ContinuumEvidenceClaim({
       descriptor,
       // @ts-expect-error runtime guard for JavaScript callers

test/unit/domain/continuum/GitWarpHologramReplay.test.ts

@@ -146,4 +146,97 @@ describe('git-warp hologram replay semantics', () => {
       payload: ProvenancePayload.identity(),
     })).toThrow(WarpError);
   });
+
+  it('rejects invalid braid hologram structure at runtime boundaries', () => {
+    const patch = makePatch({ writer: 'writer-a', lamport: 1, nodeId: 'node:a' });
+    const alphaMember = new GitWarpBraidHologramMember({
+      strandId: 'strand:a',
+      payload: makePayload(patch, 'f'.repeat(40)),
+    });
+    const duplicateAlphaMember = new GitWarpBraidHologramMember({
+      strandId: 'strand:a',
+      payload: makePayload(patch, '1'.repeat(40)),
+    });
+
+    expect(() => new GitWarpBraidHologram(
+      // @ts-expect-error runtime guard for JavaScript callers
+      undefined,
+    )).toThrow(WarpError);
+
+    expect(() => new GitWarpBraidHologram({
+      settlementId: '',
+      lawId: 'braid-law:non-empty',
+      projectionDigest: 'sha256:non-empty',
+      proofRef: 'proof:non-empty',
+      members: [alphaMember, new GitWarpBraidHologramMember({
+        strandId: 'strand:b',
+        payload: makePayload(patch, '2'.repeat(40)),
+      })],
+    })).toThrow(WarpError);
+
+    expect(() => new GitWarpBraidHologram({
+      settlementId: 'settlement:duplicate',
+      lawId: 'braid-law:duplicate',
+      projectionDigest: 'sha256:duplicate',
+      proofRef: 'proof:duplicate',
+      members: [alphaMember, duplicateAlphaMember],
+    })).toThrow(WarpError);
+
+    expect(() => new GitWarpBraidHologram({
+      settlementId: 'settlement:invalid-member',
+      lawId: 'braid-law:invalid-member',
+      projectionDigest: 'sha256:invalid-member',
+      proofRef: 'proof:invalid-member',
+      members: [alphaMember, { strandId: 'strand:b', payload: makePayload(patch, '3'.repeat(40)) }],
+    })).toThrow(WarpError);
+  });
+
+  it('rejects invalid braid members and suffix-transform fields', () => {
+    const patch = makePatch({ writer: 'writer-a', lamport: 1, nodeId: 'node:a' });
+
+    expect(() => new GitWarpBraidHologramMember(
+      // @ts-expect-error runtime guard for JavaScript callers
+      undefined,
+    )).toThrow(WarpError);
+
+    expect(() => new GitWarpBraidHologramMember({
+      strandId: '',
+      payload: makePayload(patch, '4'.repeat(40)),
+    })).toThrow(WarpError);
+
+    expect(() => new GitWarpBraidHologramMember({
+      strandId: 'strand:empty-payload',
+      payload: ProvenancePayload.identity(),
+    })).toThrow(WarpError);
+
+    expect(() => new GitWarpBraidHologramMember({
+      strandId: 'strand:invalid-payload',
+      // @ts-expect-error runtime guard for JavaScript callers
+      payload: patch,
+    })).toThrow(WarpError);
+
+    expect(() => new GitWarpSuffixTransformHologram(
+      // @ts-expect-error runtime guard for JavaScript callers
+      undefined,
+    )).toThrow(WarpError);
+
+    expect(() => new GitWarpSuffixTransformHologram({
+      sourceFrontierRef: '',
+      basisFrontierRef: 'frontier:local',
+      targetFrontierRef: 'frontier:merged',
+      transportLawId: 'transport-law:non-empty',
+      proofRef: 'proof:non-empty',
+      payload: makePayload(patch, '5'.repeat(40)),
+    })).toThrow(WarpError);
+
+    expect(() => new GitWarpSuffixTransformHologram({
+      sourceFrontierRef: 'frontier:remote',
+      basisFrontierRef: 'frontier:local',
+      targetFrontierRef: 'frontier:merged',
+      transportLawId: 'transport-law:invalid-payload',
+      proofRef: 'proof:invalid-payload',
+      // @ts-expect-error runtime guard for JavaScript callers
+      payload: patch,
+    })).toThrow(WarpError);
+  });
 });