@jinn-network/task-execution-protocol 0.0.0 → 0.1.0-canary.sha.05ab5a98a8b30392ca448de12748b19b0c947684

package/README.md

@@ -1 +1,36 @@
-Placeholder. Real versions come from stack-npm-publish.yml.
+# @jinn-network/task-execution-protocol
+
+Pure, I/O-free reference implementation of the Jinn Task Execution Protocol (TEP) v1: types,
+JSON Schemas, sealing + digest functions, the observation fold, family validators, and
+deterministic Attempt-URI derivation. No I/O, no Jinn dependencies — Evidence Protocol
+references are structural `{ family, digest }` fields, not a package dependency.
+
+See the design: `docs/superpowers/specs/2026-07-27-task-execution-protocol-and-stack-design.md`.
+Carried-amendment implementation notes: `docs/superpowers/specs/2026-07-28-tep-v1-implementation-addendum.md`.
+
+## The frozen public surface
+
+Records: `TaskSpecification`, `SubmissionRecord`, `DeliveryRecord`, `DispatchContext`,
+`ProtocolObservation`, `ResourceDescriptor`, `EvidenceRecordReference`, `AttemptDescriptor`
+(a projection materialized by a backend's `observe()`, §9/§22).
+
+Pure functions: `sealTask` / `sealSubmission` / `sealDelivery` (JCS + I-JSON enforcement),
+`documentDigest`, `validateTask` / `validateSubmission` / `validateDelivery` /
+`validateDispatchContext` / `validateObservation`, `foldObservations` (§10.4),
+`deriveAttemptUri` (§9.2 UUIDv5, exports the frozen `TEP_ATTEMPT_NAMESPACE`), and
+`mergeRequirements` (the profiles §5.1 tighten-only run-pinning merge, carried amendment 1).
+
+## The seal-once rule (§6.1)
+
+Every sealed document family (Task, Submission, Delivery) canonicalizes exactly once with
+RFC 8785 JCS under I-JSON at sealing. Those bytes are the document forever — no consumer ever
+re-canonicalizes to check a digest. `documentDigest(bytes)` always hashes the exact bytes
+received, never a re-derived form.
+
+## Fixtures
+
+`fixtures/golden-task-execution-v1/` — a complete local-and-marketplace scenario pair over one
+Task digest, plus a key-order-sensitive equivalence record (`equivalence/`). `fixtures/adversarial-v1/`
+— the §24 adversarial minimum set; this package ships the fixture bytes plus a `manifest.json`
+describing each case's expected disposition. `@jinn-network/task-execution-testing` (a sibling
+package, not built by this milestone) drives the conformance assertions against them.

package/dist/canonical.d.ts

@@ -0,0 +1,3 @@
+import { type JsonValue } from "./json.js";
+/** RFC 8785 JCS over the I-JSON-integer subset; those bytes are the document forever (§6.1). */
+export declare function serializeCanonicalJson(value: JsonValue): Uint8Array;

package/dist/canonical.js

@@ -0,0 +1,24 @@
+import { compareCodeUnitStrings } from "./order.js";
+import { cloneIJsonValue } from "./json.js";
+const encoder = new TextEncoder();
+/** Emit RFC 8785 JCS by explicit sorted-key iteration — insertion order is never trusted (§7.14). */
+function serialize(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "number")
+        return String(value);
+    if (typeof value === "string")
+        return JSON.stringify(value); // JCS string escaping (I-JSON subset)
+    if (Array.isArray(value)) {
+        return `[${value.map((element) => serialize(element)).join(",")}]`;
+    }
+    const keys = Object.keys(value)
+        .sort(compareCodeUnitStrings); // sorted array drives emission
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${serialize(value[k])}`).join(",")}}`;
+}
+/** RFC 8785 JCS over the I-JSON-integer subset; those bytes are the document forever (§6.1). */
+export function serializeCanonicalJson(value) {
+    return encoder.encode(serialize(cloneIJsonValue(value)));
+}

package/dist/descriptors.d.ts

@@ -0,0 +1,26 @@
+/**
+ * in-toto v1 ResourceDescriptor (§6.4). Digest is identity; IPFS CIDs, gateway URLs, and git
+ * object identifiers are locator hints riding in uri/downloadLocation/annotations — never
+ * identity. Bounded inline `content` is permitted for small values and always accompanied by
+ * its digest.
+ */
+export interface ResourceDescriptor {
+    name?: string;
+    uri?: string;
+    digest?: Record<string, string>;
+    mediaType?: string;
+    downloadLocation?: string;
+    annotations?: Record<string, unknown>;
+    content?: string;
+}
+/** Structural check: a ResourceDescriptor must carry at least one of uri/digest/content (§6.4). */
+export declare function resourceDescriptorHasLocator(descriptor: ResourceDescriptor): boolean;
+/**
+ * The structural Evidence Protocol seam (§6.4): a reference by family + digest only. This is a
+ * structural convention, not a package dependency — no import of any evidence package.
+ */
+export type EvidenceRecordFamily = "execution-evidence" | "result-evaluation" | "execution-verification";
+export interface EvidenceRecordReference {
+    family: EvidenceRecordFamily;
+    digest: `sha256:${string}`;
+}

package/dist/descriptors.js

@@ -0,0 +1,6 @@
+/** Structural check: a ResourceDescriptor must carry at least one of uri/digest/content (§6.4). */
+export function resourceDescriptorHasLocator(descriptor) {
+    return descriptor.uri !== undefined
+        || (descriptor.digest !== undefined && Object.keys(descriptor.digest).length > 0)
+        || descriptor.content !== undefined;
+}

package/dist/errors.d.ts

@@ -0,0 +1,4 @@
+export declare const TASK_EXECUTION_ERROR_CATEGORIES: readonly ["invalid-document", "unsupported-profile", "unsupported-requirement", "unsupported-capability", "invalid-reference", "content-corruption", "access-denied", "submission-conflict", "attempt-not-found", "dependency-unavailable", "backend-unavailable", "operation-aborted", "deadline-exceeded", "transport-failure", "result-unavailable", "protocol-violation"];
+export type TaskExecutionErrorCategory = (typeof TASK_EXECUTION_ERROR_CATEGORIES)[number];
+export declare const ERROR_RETRYABLE: Record<TaskExecutionErrorCategory, boolean>;
+export declare function isRetryable(category: TaskExecutionErrorCategory): boolean;

package/dist/errors.js

@@ -0,0 +1,23 @@
+export const TASK_EXECUTION_ERROR_CATEGORIES = [
+    "invalid-document", "unsupported-profile", "unsupported-requirement",
+    "unsupported-capability", "invalid-reference", "content-corruption",
+    "access-denied", "submission-conflict", "attempt-not-found",
+    "dependency-unavailable", "backend-unavailable", "operation-aborted",
+    "deadline-exceeded", "transport-failure", "result-unavailable",
+    "protocol-violation",
+];
+// retryable defaults (§13 says each category carries a machine-readable flag;
+// the flags themselves are a field-level refinement — pinned by errors.test.ts).
+export const ERROR_RETRYABLE = {
+    "invalid-document": false, "unsupported-profile": false,
+    "unsupported-requirement": false, "unsupported-capability": false,
+    "invalid-reference": false, "content-corruption": false,
+    "access-denied": false, "submission-conflict": false,
+    "attempt-not-found": false, "dependency-unavailable": true,
+    "backend-unavailable": true, "operation-aborted": true,
+    "deadline-exceeded": true, "transport-failure": true,
+    "result-unavailable": false, "protocol-violation": false,
+};
+export function isRetryable(category) {
+    return ERROR_RETRYABLE[category];
+}

package/dist/events.d.ts

@@ -0,0 +1,10 @@
+export declare const SUBMISSION_EVENT_TYPES: readonly ["network.jinn.task-execution.submission-accepted.v1", "network.jinn.task-execution.submission-rejected.v1", "network.jinn.task-execution.submission-closed.v1"];
+export declare const ATTEMPT_EVENT_TYPES: readonly ["network.jinn.task-execution.attempt-engaged.v1", "network.jinn.task-execution.attempt-started.v1", "network.jinn.task-execution.progress.v1", "network.jinn.task-execution.cancel-requested.v1", "network.jinn.task-execution.cancel-acknowledged.v1", "network.jinn.task-execution.execution-observed.v1", "network.jinn.task-execution.delivery-recorded.v1", "network.jinn.task-execution.attempt-terminal.v1"];
+export declare const TASK_EXECUTION_EVENT_TYPES: readonly ["network.jinn.task-execution.submission-accepted.v1", "network.jinn.task-execution.submission-rejected.v1", "network.jinn.task-execution.submission-closed.v1", "network.jinn.task-execution.attempt-engaged.v1", "network.jinn.task-execution.attempt-started.v1", "network.jinn.task-execution.progress.v1", "network.jinn.task-execution.cancel-requested.v1", "network.jinn.task-execution.cancel-acknowledged.v1", "network.jinn.task-execution.execution-observed.v1", "network.jinn.task-execution.delivery-recorded.v1", "network.jinn.task-execution.attempt-terminal.v1"];
+/** Highest representable value under the fixed-width 16-digit `sequence` encoding (§10.1). */
+export declare const MAX_SEQUENCE = 9999999999999999n;
+/**
+ * Fixed-width, zero-padded 16-digit decimal encoding of the CloudEvents `sequence` extension
+ * (§10.1) — orders lexicographically, which is what CloudEvents' `sequence` mandates.
+ */
+export declare function formatSequence(n: bigint): string;

package/dist/events.js

@@ -0,0 +1,18 @@
+// The reverse-DNS type strings are the single source of truth for the discriminated observation
+// payload schema (schemas/observation.ts) and are re-exported here under the frozen §22 names.
+import { ATTEMPT_OBSERVATION_TYPES, OBSERVATION_TYPES, SUBMISSION_OBSERVATION_TYPES, } from "./schemas/observation.js";
+export const SUBMISSION_EVENT_TYPES = SUBMISSION_OBSERVATION_TYPES;
+export const ATTEMPT_EVENT_TYPES = ATTEMPT_OBSERVATION_TYPES;
+export const TASK_EXECUTION_EVENT_TYPES = OBSERVATION_TYPES;
+/** Highest representable value under the fixed-width 16-digit `sequence` encoding (§10.1). */
+export const MAX_SEQUENCE = 9999999999999999n;
+/**
+ * Fixed-width, zero-padded 16-digit decimal encoding of the CloudEvents `sequence` extension
+ * (§10.1) — orders lexicographically, which is what CloudEvents' `sequence` mandates.
+ */
+export function formatSequence(n) {
+    if (n < 0n || n > MAX_SEQUENCE) {
+        throw new RangeError(`sequence out of the 16-digit range: ${n}`);
+    }
+    return n.toString().padStart(16, "0");
+}

package/dist/fixtures.d.ts

@@ -0,0 +1,31 @@
+/** The golden scenario pair's shared Task, sealed bytes (§24). */
+export declare function loadGoldenTaskBytes(): Promise<Uint8Array>;
+export type GoldenScenario = "local" | "marketplace";
+export declare function loadGoldenSubmissionBytes(scenario: GoldenScenario): Promise<Uint8Array>;
+export declare function loadGoldenDeliveryBytes(scenario: GoldenScenario): Promise<Uint8Array>;
+export declare function loadGoldenObservations(scenario: GoldenScenario): Promise<unknown[]>;
+export interface GoldenConformanceReport {
+    taskDigest: `sha256:${string}`;
+    scenarios: Record<GoldenScenario, {
+        submission: string;
+        submissionDigest: `sha256:${string}`;
+        attempt: string;
+        deliveryDigest: `sha256:${string}`;
+    }>;
+}
+export declare function loadGoldenConformanceReport(): Promise<GoldenConformanceReport>;
+export declare function loadEquivalenceTaskBytes(variant: "a" | "b"): Promise<Uint8Array>;
+export declare function loadEquivalenceExpectedDigest(): Promise<`sha256:${string}`>;
+export interface AdversarialManifestEntry {
+    id: string;
+    description: string;
+    expectedDisposition: string;
+}
+export interface AdversarialManifest {
+    taskDigest: `sha256:${string}`;
+    fixtures: readonly AdversarialManifestEntry[];
+}
+export declare function loadAdversarialManifest(): Promise<AdversarialManifest>;
+/** Reads an arbitrary file inside a named adversarial fixture directory. */
+export declare function readAdversarialFile(id: string, filename: string): Promise<Uint8Array>;
+export declare function readAdversarialJson(id: string, filename: string): Promise<unknown>;

package/dist/fixtures.js

@@ -0,0 +1,45 @@
+import { readFile } from "node:fs/promises";
+function fixtureUrl(relativePath) {
+    return new URL(`../fixtures/${relativePath}`, import.meta.url);
+}
+async function readFixtureBytes(relativePath) {
+    return new Uint8Array(await readFile(fixtureUrl(relativePath)));
+}
+async function readFixtureJson(relativePath) {
+    return JSON.parse(await readFile(fixtureUrl(relativePath), "utf8"));
+}
+const GOLDEN_ROOT = "golden-task-execution-v1";
+/** The golden scenario pair's shared Task, sealed bytes (§24). */
+export async function loadGoldenTaskBytes() {
+    return readFixtureBytes(`${GOLDEN_ROOT}/task.json`);
+}
+export async function loadGoldenSubmissionBytes(scenario) {
+    return readFixtureBytes(`${GOLDEN_ROOT}/${scenario}/submission.json`);
+}
+export async function loadGoldenDeliveryBytes(scenario) {
+    return readFixtureBytes(`${GOLDEN_ROOT}/${scenario}/delivery.json`);
+}
+export async function loadGoldenObservations(scenario) {
+    return (await readFixtureJson(`${GOLDEN_ROOT}/${scenario}/observations.json`));
+}
+export async function loadGoldenConformanceReport() {
+    return (await readFixtureJson(`${GOLDEN_ROOT}/conformance-report.json`));
+}
+export async function loadEquivalenceTaskBytes(variant) {
+    return readFixtureBytes(`${GOLDEN_ROOT}/equivalence/task-${variant}.json`);
+}
+export async function loadEquivalenceExpectedDigest() {
+    const { digest } = (await readFixtureJson(`${GOLDEN_ROOT}/equivalence/expected-digest.json`));
+    return digest;
+}
+const ADVERSARIAL_ROOT = "adversarial-v1";
+export async function loadAdversarialManifest() {
+    return (await readFixtureJson(`${ADVERSARIAL_ROOT}/manifest.json`));
+}
+/** Reads an arbitrary file inside a named adversarial fixture directory. */
+export async function readAdversarialFile(id, filename) {
+    return readFixtureBytes(`${ADVERSARIAL_ROOT}/${id}/${filename}`);
+}
+export async function readAdversarialJson(id, filename) {
+    return readFixtureJson(`${ADVERSARIAL_ROOT}/${id}/${filename}`);
+}

package/dist/fold.d.ts

@@ -0,0 +1,46 @@
+import type { ProtocolObservation } from "./schemas/observation.js";
+import type { AttemptState, FailureBlame } from "./states.js";
+/** Pure projection over an Attempt's observation log (§9/§10.4/§22). */
+export interface DerivedAttemptState {
+    state: AttemptState;
+    terminal: boolean;
+    contradictory: boolean;
+    cancelRequested: boolean;
+    blame?: FailureBlame;
+    executor?: string;
+    effectiveDeadline?: string;
+    executionIds: readonly string[];
+    deliveries: readonly {
+        digest: `sha256:${string}`;
+    }[];
+}
+/**
+ * The §9/§22 Attempt projection, materialized at `observe()`'s surface (backend, Task 2.x;
+ * program §7.16). Defined here so the frozen §22 name is a real export; its reference fields
+ * (`task`/`submission`/`annotations`) are supplied at materialization time by the consumer that
+ * holds the Submission + dispatch context — the pure log fold below does not carry them.
+ */
+export interface AttemptDescriptor {
+    attempt: `urn:uuid:${string}`;
+    task: `sha256:${string}`;
+    submission: `urn:uuid:${string}`;
+    annotations?: Readonly<Record<string, unknown>>;
+    derived: DerivedAttemptState;
+}
+export interface FoldObservationsOptions {
+    /** The clock reading to derive provisional `expired` against (§10.4 rule 5). */
+    now?: string;
+    /** The Attempt's effective absolute deadline, from the engaging Submission. */
+    effectiveDeadline?: string;
+}
+/**
+ * Implements §10.4 exactly. Without `opts`, this is a pure log fold — no provisional `expired`.
+ *
+ * SELF-FILTER (§10.1/§10.4): the caller MAY hand this function a multi-source log (e.g. every
+ * observation recorded for an Attempt, not pre-filtered). Once the first `attempt-engaged` in
+ * sequence order pins the authoritative source, every observation whose envelope `source` does
+ * not match it — including a forged or merely corroborating observation from a different
+ * producer — is excluded from the fold entirely: it neither updates derived state nor
+ * participates in terminal resolution (so it can never raise a false `contradictory`).
+ */
+export declare function foldObservations(observations: readonly ProtocolObservation[], opts?: FoldObservationsOptions): DerivedAttemptState;

package/dist/fold.js

@@ -0,0 +1,160 @@
+function isTerminal(observation) {
+    return observation.type === "network.jinn.task-execution.attempt-terminal.v1";
+}
+function dedupe(observations) {
+    const seen = new Set();
+    const result = [];
+    for (const observation of observations) {
+        // A raw byte (not an escape) was used as the delimiter here pre-fix -- invisible in a
+        // normal read, and (like the fake backend's idempotency scope key, see
+        // testing/src/fake-backend.ts) it made this file register as binary to git, hiding this
+        // function's diffs from review. Named and escaped explicitly now; same delimiter role
+        // (source/id are unconstrained strings, so an undelimited or ambiguous join could
+        // collide two distinct pairs into one dedupe key), same U+001F convention this tree
+        // already uses in `deriveAttemptUri` and the fake backend's idempotency scope.
+        const key = `${observation.source}\u001f${observation.id}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(observation);
+    }
+    return result;
+}
+/**
+ * Resolves the authoritative terminal from the sequence-ordered list of `attempt-terminal`
+ * observations (§10.4 rules 4 and 6). A single terminal is authoritative outright. Multiple
+ * terminals resolve by walking in order: while the currently accepted terminal is the
+ * quasi-terminal `lost`, a later terminal supersedes it without contradiction (rule 6); any
+ * other terminal-to-terminal transition is contradictory, and the derived state is the first
+ * terminal in sequence order (rule 4).
+ */
+function resolveTerminal(terminals) {
+    if (terminals.length === 0)
+        return undefined;
+    let accepted = terminals[0];
+    let contradictory = false;
+    for (let i = 1; i < terminals.length; i++) {
+        if (!contradictory && accepted.data.state === "lost") {
+            accepted = terminals[i]; // rule 6: quasi-terminal supersession, no contradiction
+        }
+        else {
+            contradictory = true;
+            accepted = terminals[0]; // rule 4: contradictory falls back to the first-in-sequence terminal
+        }
+    }
+    return { accepted, contradictory };
+}
+/**
+ * §10.1/§10.4: `attempt-engaged` pins the authoritative observation-producer source (its
+ * `data.source` field) for the rest of the Attempt's log. If multiple `attempt-engaged`
+ * observations from different sources appear (a race, or a forgery), the first one in sequence
+ * order wins as the engagement — every other observation, including a later `attempt-engaged`
+ * from a different source, is non-authoritative.
+ */
+function findAuthoritativeSource(ordered) {
+    for (const observation of ordered) {
+        if (observation.type === "network.jinn.task-execution.attempt-engaged.v1") {
+            return observation.data.source;
+        }
+    }
+    return undefined;
+}
+/**
+ * Implements §10.4 exactly. Without `opts`, this is a pure log fold — no provisional `expired`.
+ *
+ * SELF-FILTER (§10.1/§10.4): the caller MAY hand this function a multi-source log (e.g. every
+ * observation recorded for an Attempt, not pre-filtered). Once the first `attempt-engaged` in
+ * sequence order pins the authoritative source, every observation whose envelope `source` does
+ * not match it — including a forged or merely corroborating observation from a different
+ * producer — is excluded from the fold entirely: it neither updates derived state nor
+ * participates in terminal resolution (so it can never raise a false `contradictory`).
+ */
+export function foldObservations(observations, opts) {
+    const ordered = dedupe(observations)
+        .slice()
+        .sort((a, b) => (a.sequence < b.sequence ? -1 : a.sequence > b.sequence ? 1 : 0));
+    const authoritativeSource = findAuthoritativeSource(ordered);
+    let running = false;
+    let cancelRequested = false;
+    let executor;
+    let effectiveDeadline;
+    const executionIds = [];
+    const deliveries = [];
+    const terminals = [];
+    for (const observation of ordered) {
+        if (authoritativeSource !== undefined && observation.source !== authoritativeSource)
+            continue;
+        switch (observation.type) {
+            case "network.jinn.task-execution.attempt-engaged.v1": {
+                if (observation.data.executor !== undefined)
+                    executor = observation.data.executor;
+                effectiveDeadline = observation.data.effectiveDeadline;
+                break;
+            }
+            case "network.jinn.task-execution.attempt-started.v1": {
+                running = true;
+                if (observation.data.executor !== undefined)
+                    executor = observation.data.executor;
+                break;
+            }
+            case "network.jinn.task-execution.cancel-requested.v1": {
+                cancelRequested = true;
+                break;
+            }
+            case "network.jinn.task-execution.execution-observed.v1": {
+                executionIds.push(observation.data.executionId);
+                break;
+            }
+            case "network.jinn.task-execution.delivery-recorded.v1": {
+                // The Sha256Digest zod schema enforces the `sha256:<hex>` shape at runtime; regex-based
+                // zod schemas infer as `string`, so the narrower template type is asserted here.
+                deliveries.push({ digest: observation.data.digest });
+                break;
+            }
+            default:
+                break;
+        }
+        if (isTerminal(observation))
+            terminals.push(observation);
+    }
+    const resolved = resolveTerminal(terminals);
+    if (resolved !== undefined) {
+        return {
+            state: resolved.accepted.data.state,
+            terminal: true,
+            contradictory: resolved.contradictory,
+            cancelRequested,
+            blame: resolved.accepted.data.blame,
+            executor,
+            effectiveDeadline,
+            executionIds,
+            deliveries,
+        };
+    }
+    // No authoritative terminal in the log. Provisional `expired` derives only when the caller
+    // supplies both a clock reading and the effective deadline (program §7.16 / §10.4 rule 5).
+    if (opts?.now !== undefined
+        && opts.effectiveDeadline !== undefined
+        && new Date(opts.now).getTime() > new Date(opts.effectiveDeadline).getTime()) {
+        return {
+            state: "expired",
+            terminal: true,
+            contradictory: false,
+            cancelRequested,
+            executor,
+            effectiveDeadline,
+            executionIds,
+            deliveries,
+        };
+    }
+    return {
+        state: running ? "running" : "pending",
+        terminal: false,
+        contradictory: false,
+        cancelRequested,
+        executor,
+        effectiveDeadline,
+        executionIds,
+        deliveries,
+    };
+}

package/dist/hashing.d.ts

@@ -0,0 +1,2 @@
+export declare function sha256Hex(bytes: Uint8Array): string;
+export declare function documentDigest(bytes: Uint8Array): `sha256:${string}`;

package/dist/hashing.js

@@ -0,0 +1,8 @@
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+export function sha256Hex(bytes) {
+    return bytesToHex(sha256(bytes));
+}
+export function documentDigest(bytes) {
+    return `sha256:${sha256Hex(bytes)}`;
+}

package/dist/identifiers.d.ts

@@ -0,0 +1,9 @@
+import { compareCodeUnitStrings } from "./order.js";
+/** Exact wire media types for the three sealed Task Execution Protocol records. */
+export declare const TASK_MEDIA_TYPE: "application/vnd.jinn.task-execution.task.v1+json";
+export declare const SUBMISSION_MEDIA_TYPE: "application/vnd.jinn.task-execution.submission.v1+json";
+export declare const DELIVERY_MEDIA_TYPE: "application/vnd.jinn.task-execution.delivery.v1+json";
+export declare const TEP_ATTEMPT_NAMESPACE = "158601b2-0cad-5f8b-89f2-c4a36f79fc78";
+export declare function isValidUrnUuid(uri: string): boolean;
+export declare function deriveAttemptUri(bindingName: string, correlationTuple: readonly (string | number)[]): `urn:uuid:${string}`;
+export { compareCodeUnitStrings };

package/dist/identifiers.js

@@ -0,0 +1,39 @@
+import { sha1 } from "@noble/hashes/legacy.js"; // @noble/hashes v2 exposes sha1 here; verified at install
+import { compareCodeUnitStrings } from "./order.js";
+/** Exact wire media types for the three sealed Task Execution Protocol records. */
+export const TASK_MEDIA_TYPE = "application/vnd.jinn.task-execution.task.v1+json";
+export const SUBMISSION_MEDIA_TYPE = "application/vnd.jinn.task-execution.submission.v1+json";
+export const DELIVERY_MEDIA_TYPE = "application/vnd.jinn.task-execution.delivery.v1+json";
+// Fixed TEP Attempt-URI namespace: a v5 UUID over the RFC 4122 "URL" namespace
+// (6ba7b811-9dad-11d1-80b4-00c04fd430c8) and the name "jinn.network/task-execution/attempt".
+// EXPORTED (program §7.2): the marketplace binding consumes this constant; it never re-derives
+// its own. Computed once and frozen; pinned by identifiers.test.ts.
+export const TEP_ATTEMPT_NAMESPACE = "158601b2-0cad-5f8b-89f2-c4a36f79fc78";
+// Frozen name-construction delimiter (program §7.2): the ASCII unit separator (U+001F), a
+// control char that cannot appear in the parts, so variable-length parts never concatenate
+// ambiguously.
+const NAME_UNIT_SEPARATOR = "\u001f";
+const UUID_RE = /^urn:uuid:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+export function isValidUrnUuid(uri) {
+    return UUID_RE.test(uri);
+}
+function uuidBytes(uuid) {
+    const hex = uuid.replaceAll("-", "");
+    return Uint8Array.from({ length: 16 }, (_, i) => parseInt(hex.slice(i * 2, i * 2 + 2), 16));
+}
+function formatUuid(b) {
+    const h = [...b].map((x) => x.toString(16).padStart(2, "0")).join("");
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+export function deriveAttemptUri(bindingName, correlationTuple) {
+    // Frozen deterministic name (§7.2): bindingName + tuple parts, unit-separator-delimited so
+    // variable-length parts never concatenate ambiguously.
+    const name = [bindingName, ...correlationTuple.map(String)].join(NAME_UNIT_SEPARATOR);
+    const input = new Uint8Array([...uuidBytes(TEP_ATTEMPT_NAMESPACE), ...new TextEncoder().encode(name)]);
+    const hash = sha1(input).slice(0, 16);
+    hash[6] = (hash[6] & 0x0f) | 0x50; // version 5
+    hash[8] = (hash[8] & 0x3f) | 0x80; // variant RFC 4122
+    return `urn:uuid:${formatUuid(hash)}`;
+}
+// compareCodeUnitStrings re-exported for callers assembling deterministic tuples.
+export { compareCodeUnitStrings };

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+export declare const TASK_EXECUTION_PROTOCOL_URI = "https://spec.jinn.network/profiles/task-execution/v1";
+export { compareCodeUnitStrings } from "./order.js";
+export { documentDigest, sha256Hex } from "./hashing.js";
+export { serializeCanonicalJson } from "./canonical.js";
+export { IJsonNumberError, UndefinedArrayElementError, assertIJsonInteger } from "./json.js";
+export type { JsonValue } from "./json.js";
+export { resourceDescriptorHasLocator } from "./descriptors.js";
+export type { EvidenceRecordFamily, EvidenceRecordReference, ResourceDescriptor } from "./descriptors.js";
+export { DELIVERY_MEDIA_TYPE, SUBMISSION_MEDIA_TYPE, TASK_MEDIA_TYPE, TEP_ATTEMPT_NAMESPACE, deriveAttemptUri, isValidUrnUuid, } from "./identifiers.js";
+export { DigestMapSchema, EFFORT_TIERS, EVIDENCE_RECORD_FAMILIES, EffortTierSchema, EvidenceRecordReferenceSchema, HarnessPinSchema, IsolationPolicySchema, LoadoutSchema, ModelPinSchema, PreferencesMap, RequirementsMap, ResourceDescriptorSchema, Rfc3339, Sha256Digest, UrnUuid, } from "./schemas/common.js";
+export type { EffortTier } from "./schemas/common.js";
+export { TaskOutputSlotSchema, TaskSpecificationSchema } from "./schemas/task.js";
+export type { TaskSpecification } from "./schemas/task.js";
+export { SubmissionRecordSchema } from "./schemas/submission.js";
+export type { SubmissionRecord } from "./schemas/submission.js";
+export { DeliveryRecordSchema } from "./schemas/delivery.js";
+export type { DeliveryRecord } from "./schemas/delivery.js";
+export { DispatchContextSchema } from "./schemas/dispatch-context.js";
+export type { DispatchContext } from "./schemas/dispatch-context.js";
+export { ATTEMPT_OBSERVATION_TYPES, OBSERVATION_TYPES, ProtocolObservationSchema, SUBMISSION_OBSERVATION_TYPES, } from "./schemas/observation.js";
+export type { ProtocolObservation } from "./schemas/observation.js";
+export { validateDelivery, validateDispatchContext, validateObservation, validateSubmission, validateTask, } from "./validators.js";
+export type { ValidationIssue, ValidationResult } from "./validators.js";
+export { ERROR_RETRYABLE, TASK_EXECUTION_ERROR_CATEGORIES, isRetryable } from "./errors.js";
+export type { TaskExecutionErrorCategory } from "./errors.js";
+export { ATTEMPT_EVENT_TYPES, MAX_SEQUENCE, SUBMISSION_EVENT_TYPES, TASK_EXECUTION_EVENT_TYPES, formatSequence, } from "./events.js";
+export { ATTEMPT_STATES, TERMINAL_STATES } from "./states.js";
+export type { AttemptState, FailureBlame } from "./states.js";
+export { foldObservations } from "./fold.js";
+export type { AttemptDescriptor, DerivedAttemptState, FoldObservationsOptions } from "./fold.js";
+export { InvalidDocumentError, sealDelivery, sealSubmission, sealTask } from "./sealing.js";
+export { mergeRequirements } from "./requirements.js";
+export type { ComparisonClass, EffectiveRequirements, MergeRequirementsResult } from "./requirements.js";
+export { loadAdversarialManifest, loadEquivalenceExpectedDigest, loadEquivalenceTaskBytes, loadGoldenConformanceReport, loadGoldenDeliveryBytes, loadGoldenObservations, loadGoldenSubmissionBytes, loadGoldenTaskBytes, readAdversarialFile, readAdversarialJson, } from "./fixtures.js";
+export type { AdversarialManifest, AdversarialManifestEntry, GoldenConformanceReport, GoldenScenario, } from "./fixtures.js";

package/dist/index.js

@@ -0,0 +1,33 @@
+// @jinn-network/task-execution-protocol — public surface (frozen at the §22 granularity).
+// Pure, I/O-free reference implementation of the Jinn Task Execution Protocol v1.
+export const TASK_EXECUTION_PROTOCOL_URI = "https://spec.jinn.network/profiles/task-execution/v1";
+// --- sealing primitives (order, hashing, canonicalization, I-JSON) ---
+export { compareCodeUnitStrings } from "./order.js";
+export { documentDigest, sha256Hex } from "./hashing.js";
+export { serializeCanonicalJson } from "./canonical.js";
+export { IJsonNumberError, UndefinedArrayElementError, assertIJsonInteger } from "./json.js";
+// --- descriptors + structural evidence seam ---
+export { resourceDescriptorHasLocator } from "./descriptors.js";
+// --- identity: deterministic Attempt-URI derivation (§9.2, program §7.2) ---
+export { DELIVERY_MEDIA_TYPE, SUBMISSION_MEDIA_TYPE, TASK_MEDIA_TYPE, TEP_ATTEMPT_NAMESPACE, deriveAttemptUri, isValidUrnUuid, } from "./identifiers.js";
+// --- family schemas (zod) ---
+export { DigestMapSchema, EFFORT_TIERS, EVIDENCE_RECORD_FAMILIES, EffortTierSchema, EvidenceRecordReferenceSchema, HarnessPinSchema, IsolationPolicySchema, LoadoutSchema, ModelPinSchema, PreferencesMap, RequirementsMap, ResourceDescriptorSchema, Rfc3339, Sha256Digest, UrnUuid, } from "./schemas/common.js";
+export { TaskOutputSlotSchema, TaskSpecificationSchema } from "./schemas/task.js";
+export { SubmissionRecordSchema } from "./schemas/submission.js";
+export { DeliveryRecordSchema } from "./schemas/delivery.js";
+export { DispatchContextSchema } from "./schemas/dispatch-context.js";
+export { ATTEMPT_OBSERVATION_TYPES, OBSERVATION_TYPES, ProtocolObservationSchema, SUBMISSION_OBSERVATION_TYPES, } from "./schemas/observation.js";
+// --- validators ---
+export { validateDelivery, validateDispatchContext, validateObservation, validateSubmission, validateTask, } from "./validators.js";
+// --- error, event, and Attempt-state vocabularies (§13/§10.2/§10.3) ---
+export { ERROR_RETRYABLE, TASK_EXECUTION_ERROR_CATEGORIES, isRetryable } from "./errors.js";
+export { ATTEMPT_EVENT_TYPES, MAX_SEQUENCE, SUBMISSION_EVENT_TYPES, TASK_EXECUTION_EVENT_TYPES, formatSequence, } from "./events.js";
+export { ATTEMPT_STATES, TERMINAL_STATES } from "./states.js";
+// --- the observation fold (§10.4) + the Attempt projection (§9/§22) ---
+export { foldObservations } from "./fold.js";
+// --- sealing entry points (§6.1) ---
+export { InvalidDocumentError, sealDelivery, sealSubmission, sealTask } from "./sealing.js";
+// --- requirements/run-pinning merge (carried amendment 1, program §7.3) ---
+export { mergeRequirements } from "./requirements.js";
+// --- fixture loaders (golden + adversarial, §24) ---
+export { loadAdversarialManifest, loadEquivalenceExpectedDigest, loadEquivalenceTaskBytes, loadGoldenConformanceReport, loadGoldenDeliveryBytes, loadGoldenObservations, loadGoldenSubmissionBytes, loadGoldenTaskBytes, readAdversarialFile, readAdversarialJson, } from "./fixtures.js";

package/dist/json.d.ts

@@ -0,0 +1,23 @@
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare class IJsonNumberError extends Error {
+    readonly value: number;
+    constructor(value: number);
+}
+declare class InvalidIJsonValueError extends Error {
+    readonly category: "invalid-document";
+    constructor(message: string);
+}
+/**
+ * Retained public error for callers that distinguish malformed arrays. Explicit `undefined`
+ * elements and holes both violate the stack-wide dense-array rule (§7.1/§7.24).
+ */
+export declare class UndefinedArrayElementError extends InvalidIJsonValueError {
+    constructor();
+}
+/** Sealed families admit only exact I-JSON integers; fractional quantities are strings (§6.1). */
+export declare function assertIJsonInteger(value: number): void;
+/** Validate and snapshot the fail-closed JSON value domain before canonical emission. */
+export declare function cloneIJsonValue(value: unknown): JsonValue;
+export {};