@gate-forge/core 0.1.0

package/dist/schemas/coverage-policy.js

@@ -0,0 +1,81 @@
+/**
+ * Coverage-policy schemas (plan 2026-09-13 §3.6, Phase 0 item 7, ADR
+ * 0005 D5): a tracked, OWNER-OWNED configuration section enumerating
+ * user-facing tables, their required real-UI CRUD operations, and any
+ * owner disposition excusing a table from that coverage. Recording or
+ * approving a disposition is a trusted-policy act — an agent edit never
+ * self-approves, because the section participates in the trusted policy
+ * revision identity.
+ */
+import { z } from 'zod';
+/** The four real-UI operations a table may require coverage for. */
+export const COVERAGE_OPERATIONS = ['create', 'read', 'update', 'delete'];
+/** The operation union a coverage policy may require. */
+export const CoverageOperationSchema = z.enum(COVERAGE_OPERATIONS);
+/**
+ * An OWNER disposition (plan §3.6): the recorded reason a table owes no
+ * real-UI coverage for its required operations. Kinds are closed-world;
+ * `other` requires the note to stay auditable. Approving one is a
+ * trusted-policy act, never an agent self-approval.
+ */
+export const CoverageDispositionSchema = z
+    .object({
+    kind: z.enum(['read-only-surface', 'admin-plane-unreachable', 'not-user-facing', 'other']),
+    /** Why the disposition applies; REQUIRED for `other` (auditability). */
+    note: z.string().min(1).optional(),
+})
+    .strict()
+    .superRefine((disposition, ctx) => {
+    if (disposition.kind === 'other' && (disposition.note === undefined || disposition.note.length === 0)) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['note'],
+            message: "disposition kind 'other' requires 'note' (the owner's reason must be recorded)",
+        });
+    }
+});
+/** One policy-enumerated user-facing table. */
+export const CoverageTableSchema = z
+    .object({
+    /** The resource inventory's bare table name (exact match). */
+    name: z.string().min(1),
+    /**
+     * Operations requiring mapped browser-e2e coverage unless a
+     * disposition excuses the table. A subset of the four real-UI
+     * operations; empty would enforce nothing and is rejected.
+     */
+    requiredOperations: z.array(CoverageOperationSchema).min(1),
+    /** Owner disposition recorded in trusted config (when coverage is excused). */
+    disposition: CoverageDispositionSchema.optional(),
+})
+    .strict();
+/**
+ * The `coveragePolicy` config section (plan §3.6). Absent or empty
+ * (`tables: []`) means the feature is OFF — enabling it is an explicit,
+ * tracked owner decision. Table names must be unique (a duplicate would
+ * make the enforcement scope ambiguous); each name is validated against
+ * the current run's resource inventory on every run.
+ */
+export const CoveragePolicySchema = z
+    .object({
+    /** User-facing tables the policy governs. */
+    tables: z.array(CoverageTableSchema),
+})
+    .strict()
+    .superRefine((policy, ctx) => {
+    const seen = new Set();
+    for (let index = 0; index < policy.tables.length; index += 1) {
+        const name = policy.tables[index]?.name;
+        if (name === undefined)
+            continue;
+        if (seen.has(name)) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['tables', index, 'name'],
+                message: `duplicate coverage-policy table '${name}': the enforcement scope must be unambiguous`,
+            });
+        }
+        seen.add(name);
+    }
+});
+//# sourceMappingURL=coverage-policy.js.map

package/dist/schemas/coverage-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage-policy.js","sourceRoot":"","sources":["../../src/schemas/coverage-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,oEAAoE;AACpE,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAU,CAAC;AAEnF,yDAAyD;AACzD,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;AAKnE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC;KACvC,MAAM,CAAC;IACN,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,mBAAmB,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,OAAO,CAAC,CAAC;IAC1F,wEAAwE;IACxE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;CACnC,CAAC;KACD,MAAM,EAAE;KACR,WAAW,CAAC,CAAC,WAAW,EAAE,GAAG,EAAE,EAAE;IAChC,IAAI,WAAW,CAAC,IAAI,KAAK,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,KAAK,SAAS,IAAI,WAAW,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC;QACtG,GAAG,CAAC,QAAQ,CAAC;YACX,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,CAAC,MAAM,CAAC;YACd,OAAO,EAAE,gFAAgF;SAC1F,CAAC,CAAC;IACL,CAAC;AACH,CAAC,CAAC,CAAC;AAKL,+CAA+C;AAC/C,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC;KACjC,MAAM,CAAC;IACN,8DAA8D;IAC9D,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB;;;;OAIG;IACH,kBAAkB,EAAE,CAAC,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3D,+EAA+E;IAC/E,WAAW,EAAE,yBAAyB,CAAC,QAAQ,EAAE;CAClD,CAAC;KACD,MAAM,EAAE,CAAC;AAKZ;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC;KAClC,MAAM,CAAC;IACN,6CAA6C;IAC7C,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,mBAAmB,CAAC;CACrC,CAAC;KACD,MAAM,EAAE;KACR,WAAW,CAAC,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE;IAC3B,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QAC7D,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC;QACxC,IAAI,IAAI,KAAK,SAAS;YAAE,SAAS;QACjC,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACnB,GAAG,CAAC,QAAQ,CAAC;gBACX,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,CAAC;gBAC/B,OAAO,EAAE,oCAAoC,IAAI,8CAA8C;aAChG,CAAC,CAAC;QACL,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACjB,CAAC;AACH,CAAC,CAAC,CAAC"}

package/dist/schemas/evidence.d.ts

@@ -0,0 +1,65 @@
+/**
+ * EvidenceRecord schema (plan §4.7, pins #7/#11): typed records issued
+ * by the witness service. This is the only evidence shape the verifier
+ * trusts; test-side assertions never appear here.
+ *
+ * ADR 0001 / GF-23 encoded here: every record carries a service-issued
+ * `recordId` and the `runId` of its run manifest. Records whose trust
+ * tier is `claimed` (no service-issued provenance) can never produce a
+ * `satisfied` verdict — the verdict engine enforces that.
+ */
+import { z } from 'zod';
+/**
+ * Optional bulk scope (pin #11): a single record may stand for `count`
+ * homogeneous items. Obligations themselves stay per-resource; bulk
+ * scope only widens what one record attests.
+ */
+export declare const BulkScopeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"bulk">;
+    count: z.ZodNumber;
+}, z.core.$strict>;
+/** Inferred bulk-scope shape. */
+export type BulkScope = z.infer<typeof BulkScopeSchema>;
+/**
+ * Where a record's contents came from (part of the hashed identity,
+ * pin #7). `suite-submitted` records carry the TESTED SUITE's own
+ * assertion — the witness received it but cannot verify it happened —
+ * and are stamped `trust: 'claimed'` at issuance. `engine-observed`
+ * records carry contents the witness itself produced from an
+ * engine-side observation (the adapter read behind
+ * `persistence.entity`) and are stamped `trust: 'witnessed'`.
+ */
+export declare const RecordOriginSchema: z.ZodEnum<{
+    "suite-submitted": "suite-submitted";
+    "engine-observed": "engine-observed";
+}>;
+/** Inferred record-origin shape. */
+export type RecordOrigin = z.infer<typeof RecordOriginSchema>;
+/**
+ * A trusted evidence record issued by the witness service.
+ */
+export declare const EvidenceRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    recordId: z.ZodString;
+    runId: z.ZodUUID;
+    trust: z.ZodEnum<{
+        claimed: "claimed";
+        witnessed: "witnessed";
+    }>;
+    obligationId: z.ZodString;
+    kind: z.ZodString;
+    testId: z.ZodOptional<z.ZodString>;
+    payload: z.ZodOptional<z.ZodUnknown>;
+    origin: z.ZodOptional<z.ZodEnum<{
+        "suite-submitted": "suite-submitted";
+        "engine-observed": "engine-observed";
+    }>>;
+    scope: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"bulk">;
+        count: z.ZodNumber;
+    }, z.core.$strict>>;
+    issuedAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>;
+/** Inferred evidence-record shape. */
+export type EvidenceRecord = z.infer<typeof EvidenceRecordSchema>;
+//# sourceMappingURL=evidence.d.ts.map

package/dist/schemas/evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence.d.ts","sourceRoot":"","sources":["../../src/schemas/evidence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;kBAMjB,CAAC;AAEZ,iCAAiC;AACjC,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB;;;EAAiD,CAAC;AAEjF,oCAAoC;AACpC,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;kBAwBtB,CAAC;AAEZ,sCAAsC;AACtC,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/schemas/evidence.js

@@ -0,0 +1,64 @@
+/**
+ * EvidenceRecord schema (plan §4.7, pins #7/#11): typed records issued
+ * by the witness service. This is the only evidence shape the verifier
+ * trusts; test-side assertions never appear here.
+ *
+ * ADR 0001 / GF-23 encoded here: every record carries a service-issued
+ * `recordId` and the `runId` of its run manifest. Records whose trust
+ * tier is `claimed` (no service-issued provenance) can never produce a
+ * `satisfied` verdict — the verdict engine enforces that.
+ */
+import { z } from 'zod';
+import { SchemaVersionField, TrustTierSchema } from './common.js';
+import { ObligationIdSchema } from './claim.js';
+/**
+ * Optional bulk scope (pin #11): a single record may stand for `count`
+ * homogeneous items. Obligations themselves stay per-resource; bulk
+ * scope only widens what one record attests.
+ */
+export const BulkScopeSchema = z
+    .object({
+    kind: z.literal('bulk'),
+    /** Number of items this record attests to (positive). */
+    count: z.number().int().min(1),
+})
+    .strict();
+/**
+ * Where a record's contents came from (part of the hashed identity,
+ * pin #7). `suite-submitted` records carry the TESTED SUITE's own
+ * assertion — the witness received it but cannot verify it happened —
+ * and are stamped `trust: 'claimed'` at issuance. `engine-observed`
+ * records carry contents the witness itself produced from an
+ * engine-side observation (the adapter read behind
+ * `persistence.entity`) and are stamped `trust: 'witnessed'`.
+ */
+export const RecordOriginSchema = z.enum(['suite-submitted', 'engine-observed']);
+/**
+ * A trusted evidence record issued by the witness service.
+ */
+export const EvidenceRecordSchema = z
+    .object({
+    schemaVersion: SchemaVersionField,
+    /** Service-issued record id (sha256 hex of its canonical identity). */
+    recordId: z.string().regex(/^[0-9a-f]{64}$/, 'recordId must be a 64-char lowercase sha256 hex'),
+    /** Run manifest this record belongs to. */
+    runId: z.uuid(),
+    /** Trust tier: `witnessed` records were collected engine-side. */
+    trust: TrustTierSchema,
+    /** Obligation the evidence relates to. */
+    obligationId: ObligationIdSchema,
+    /** Evidence primitive kind, e.g. `ui.action`, `persistence.entity`. */
+    kind: z.string().min(1),
+    /** Test that produced the claim this evidence supports, when known. */
+    testId: z.string().min(1).optional(),
+    /** Evidence payload (primitive-defined, open JSON). */
+    payload: z.unknown().optional(),
+    /** Where the contents came from (drives the trust stamp at issuance). */
+    origin: RecordOriginSchema.optional(),
+    /** Bulk attestation scope, when this record covers multiple items. */
+    scope: BulkScopeSchema.optional(),
+    /** Issue timestamp from the engine-injected clock (ISO-8601). */
+    issuedAt: z.iso.datetime().optional(),
+})
+    .strict();
+//# sourceMappingURL=evidence.js.map

package/dist/schemas/evidence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence.js","sourceRoot":"","sources":["../../src/schemas/evidence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC;KAC7B,MAAM,CAAC;IACN,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IACvB,yDAAyD;IACzD,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAC/B,CAAC;KACD,MAAM,EAAE,CAAC;AAKZ;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,CAAC,CAAC;AAKjF;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC;KAClC,MAAM,CAAC;IACN,aAAa,EAAE,kBAAkB;IACjC,uEAAuE;IACvE,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,gBAAgB,EAAE,iDAAiD,CAAC;IAC/F,2CAA2C;IAC3C,KAAK,EAAE,CAAC,CAAC,IAAI,EAAE;IACf,kEAAkE;IAClE,KAAK,EAAE,eAAe;IACtB,0CAA0C;IAC1C,YAAY,EAAE,kBAAkB;IAChC,uEAAuE;IACvE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,uEAAuE;IACvE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACpC,uDAAuD;IACvD,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAC/B,yEAAyE;IACzE,MAAM,EAAE,kBAAkB,CAAC,QAAQ,EAAE;IACrC,sEAAsE;IACtE,KAAK,EAAE,eAAe,CAAC,QAAQ,EAAE;IACjC,iEAAiE;IACjE,QAAQ,EAAE,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;CACtC,CAAC;KACD,MAAM,EAAE,CAAC"}

package/dist/schemas/execution-result.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Execution-result record (plan 2026-09-13 §5.1 row "Execution result",
+ * Phase 4 work item 3, ADR 0005 D2): the trusted supervisor's OWN account
+ * of a run — planned versus executed instances, per-instance outcomes and
+ * attempts, runner exit, fixture/teardown outcome, shard completeness,
+ * selection + catalog digests, trusted policy digest, engine versions,
+ * and environment identity.
+ *
+ * Trust boundary (ADR 0005 D2): the suite reporter is INPUT, never
+ * signature authority. This record is written by trusted supervision
+ * under the excluded run-state directory; its digest (see
+ * {@link executionResultDigestOf}) is what the gate receipt binds —
+ * never a reporter aggregate. `outcomes` rows are supervision-normalized
+ * data, not the reporter's own summary.
+ */
+import { z } from 'zod';
+/** Domain tag separating execution-result digests from every other hash. */
+export declare const EXECUTION_RESULT_DOMAIN = "gateforge.execution-result.v1";
+/** Domain tag separating selection digests from every other hash. */
+export declare const SELECTION_DOMAIN = "gateforge.selection.v1";
+/** One planned instance (fixed BEFORE the run; ADR 0005 D2). */
+export declare const PlannedInstanceSchema: z.ZodObject<{
+    logicalKey: z.ZodString;
+    project: z.ZodNullable<z.ZodString>;
+    file: z.ZodString;
+    titlePath: z.ZodArray<z.ZodString>;
+    frameworkId: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+/** Inferred planned-instance shape. */
+export type PlannedInstance = z.infer<typeof PlannedInstanceSchema>;
+/** Per-instance execution status the supervisor accepts from the runner. */
+export declare const InstanceStatusSchema: z.ZodEnum<{
+    fixme: "fixme";
+    passed: "passed";
+    failed: "failed";
+    skipped: "skipped";
+    "not-run": "not-run";
+}>;
+/** Inferred instance-status shape. */
+export type InstanceStatus = z.infer<typeof InstanceStatusSchema>;
+/** One executed instance outcome (supervision-normalized; input only). */
+export declare const ExecutedOutcomeSchema: z.ZodObject<{
+    logicalKey: z.ZodString;
+    project: z.ZodNullable<z.ZodString>;
+    file: z.ZodString;
+    titlePath: z.ZodArray<z.ZodString>;
+    status: z.ZodEnum<{
+        fixme: "fixme";
+        passed: "passed";
+        failed: "failed";
+        skipped: "skipped";
+        "not-run": "not-run";
+    }>;
+    attempt: z.ZodNumber;
+    expectedFailure: z.ZodBoolean;
+}, z.core.$strict>;
+/** Inferred executed-outcome shape. */
+export type ExecutedOutcome = z.infer<typeof ExecutedOutcomeSchema>;
+/** One typed supervision finding (plan §5.4 run rows). */
+export declare const SupervisionFindingSchema: z.ZodObject<{
+    cause: z.ZodEnum<{
+        TEST_NOT_EXECUTED: "TEST_NOT_EXECUTED";
+        TEST_FAILED: "TEST_FAILED";
+        RUN_INCOMPLETE: "RUN_INCOMPLETE";
+    }>;
+    detail: z.ZodString;
+    logicalKey: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+/** Inferred supervision-finding shape. */
+export type SupervisionFinding = z.infer<typeof SupervisionFindingSchema>;
+/** One witness-recorded session of an expected test (execution authority). */
+export declare const TracedSessionSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    openedTick: z.ZodNumber;
+    sealedTick: z.ZodNullable<z.ZodNumber>;
+    outcome: z.ZodNullable<z.ZodString>;
+    activity: z.ZodNumber;
+}, z.core.$strict>;
+/** Inferred traced-session shape. */
+export type TracedSession = z.infer<typeof TracedSessionSchema>;
+/** The witness-side session trace for ONE expected test. */
+export declare const TracedTestSchema: z.ZodObject<{
+    testId: z.ZodNullable<z.ZodString>;
+    project: z.ZodNullable<z.ZodString>;
+    file: z.ZodString;
+    titlePath: z.ZodArray<z.ZodString>;
+    sessions: z.ZodArray<z.ZodObject<{
+        sessionId: z.ZodString;
+        openedTick: z.ZodNumber;
+        sealedTick: z.ZodNullable<z.ZodNumber>;
+        outcome: z.ZodNullable<z.ZodString>;
+        activity: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Inferred traced-test shape. */
+export type TracedTest = z.infer<typeof TracedTestSchema>;
+/**
+ * The sealed execution result. Strict: unknown keys are rejected so a
+ * hostile run-state edit cannot smuggle extra authority in.
+ */
+export declare const ExecutionResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    runId: z.ZodString;
+    invocationId: z.ZodString;
+    inputDigest: z.ZodString;
+    trustedPolicyDigest: z.ZodString;
+    selection: z.ZodObject<{
+        runner: z.ZodString;
+        mode: z.ZodEnum<{
+            "full-relevant-suite": "full-relevant-suite";
+            "mapped-selection": "mapped-selection";
+        }>;
+        logicalKeys: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    selectionDigest: z.ZodString;
+    catalogDigest: z.ZodString;
+    planned: z.ZodArray<z.ZodObject<{
+        logicalKey: z.ZodString;
+        project: z.ZodNullable<z.ZodString>;
+        file: z.ZodString;
+        titlePath: z.ZodArray<z.ZodString>;
+        frameworkId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    outcomes: z.ZodArray<z.ZodObject<{
+        logicalKey: z.ZodString;
+        project: z.ZodNullable<z.ZodString>;
+        file: z.ZodString;
+        titlePath: z.ZodArray<z.ZodString>;
+        status: z.ZodEnum<{
+            fixme: "fixme";
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+            "not-run": "not-run";
+        }>;
+        attempt: z.ZodNumber;
+        expectedFailure: z.ZodBoolean;
+    }, z.core.$strict>>;
+    enumerationDigest: z.ZodOptional<z.ZodString>;
+    sessionTrace: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        testId: z.ZodNullable<z.ZodString>;
+        project: z.ZodNullable<z.ZodString>;
+        file: z.ZodString;
+        titlePath: z.ZodArray<z.ZodString>;
+        sessions: z.ZodArray<z.ZodObject<{
+            sessionId: z.ZodString;
+            openedTick: z.ZodNumber;
+            sealedTick: z.ZodNullable<z.ZodNumber>;
+            outcome: z.ZodNullable<z.ZodString>;
+            activity: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    runnerExit: z.ZodNullable<z.ZodNumber>;
+    complete: z.ZodBoolean;
+    causes: z.ZodArray<z.ZodObject<{
+        cause: z.ZodEnum<{
+            TEST_NOT_EXECUTED: "TEST_NOT_EXECUTED";
+            TEST_FAILED: "TEST_FAILED";
+            RUN_INCOMPLETE: "RUN_INCOMPLETE";
+        }>;
+        detail: z.ZodString;
+        logicalKey: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    fixtureOutcome: z.ZodEnum<{
+        unknown: "unknown";
+        passed: "passed";
+        failed: "failed";
+    }>;
+    shardCompleteness: z.ZodObject<{
+        complete: z.ZodBoolean;
+        detail: z.ZodString;
+    }, z.core.$strict>;
+    maxAttemptObserved: z.ZodNumber;
+    engines: z.ZodRecord<z.ZodString, z.ZodString>;
+    browsers: z.ZodRecord<z.ZodString, z.ZodString>;
+    environmentIdentity: z.ZodString;
+    startedAt: z.ZodString;
+    finishedAt: z.ZodString;
+}, z.core.$strict>;
+/** Inferred execution-result shape. */
+export type ExecutionResult = z.infer<typeof ExecutionResultSchema>;
+/**
+ * Computes the domain-separated digest of an execution result (plan §5.1:
+ * the receipt binds THIS digest, never a reporter aggregate). The digest
+ * covers every field except the `causes`-vs-`complete` consistency check
+ * (which is structural, not content).
+ *
+ * Args:
+ *   result: a validated execution result.
+ *
+ * Returns:
+ *   string: 64-char lowercase hex digest.
+ *
+ * Throws:
+ *   TypeError: when the result contains non-JSON-representable values.
+ */
+export declare function executionResultDigestOf(result: ExecutionResult): string;
+/**
+ * Computes the domain-separated selection digest (plan Phase 4 item 3:
+ * the expected test set is hashed BEFORE the run so a receipt binds the
+ * exact selection, and any selection change forces a fresh run).
+ *
+ * Args:
+ *   selection: the runner, mode, and logical keys selected.
+ *
+ * Returns:
+ *   string: 64-char lowercase hex digest.
+ */
+export declare function selectionDigestOf(selection: {
+    runner: string;
+    mode: 'full-relevant-suite' | 'mapped-selection';
+    logicalKeys: readonly string[];
+}): string;
+//# sourceMappingURL=execution-result.d.ts.map

package/dist/schemas/execution-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-result.d.ts","sourceRoot":"","sources":["../../src/schemas/execution-result.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,4EAA4E;AAC5E,eAAO,MAAM,uBAAuB,kCAAkC,CAAC;AAEvE,qEAAqE;AACrE,eAAO,MAAM,gBAAgB,2BAA2B,CAAC;AAKzD,gEAAgE;AAChE,eAAO,MAAM,qBAAqB;;;;;;kBAavB,CAAC;AAEZ,uCAAuC;AACvC,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,4EAA4E;AAC5E,eAAO,MAAM,oBAAoB;;;;;;EAA8D,CAAC;AAEhG,sCAAsC;AACtC,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,0EAA0E;AAC1E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;kBAiBvB,CAAC;AAEZ,uCAAuC;AACvC,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,0DAA0D;AAC1D,eAAO,MAAM,wBAAwB;;;;;;;;kBAS1B,CAAC;AAEZ,0CAA0C;AAC1C,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,8EAA8E;AAC9E,eAAO,MAAM,mBAAmB;;;;;;kBAkBrB,CAAC;AAEZ,qCAAqC;AACrC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,4DAA4D;AAC5D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;kBAalB,CAAC;AAEZ,kCAAkC;AAClC,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2F9B,CAAC;AAEL,uCAAuC;AACvC,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAEvE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,qBAAqB,GAAG,kBAAkB,CAAC;IACjD,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC,GAAG,MAAM,CAOT"}