@sequenceholdings/managed-functions 0.4.0 → 0.4.2

package/dist/lattice-provenance-contract.d.ts

@@ -0,0 +1,519 @@
+import { z } from 'zod';
+export declare const FUNCTION_LATTICE_EXECUTION_TOKEN_HEADER = "x-sequence-lattice-execution-token";
+export declare const FUNCTION_LATTICE_CONTEXT_PATH = "/api/managed-functions/lattice/context";
+export declare const functionLatticeStartProvenanceSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    issuer: z.ZodString;
+    runId: z.ZodString;
+    processId: z.ZodString;
+    processVersion: z.ZodString;
+    bundleHash: z.ZodString;
+    actorSub: z.ZodString;
+    startedBy: z.ZodNullable<z.ZodString>;
+    mode: z.ZodEnum<{
+        system: "system";
+        manual: "manual";
+        trigger: "trigger";
+        schedule: "schedule";
+        subprocess: "subprocess";
+        intervention: "intervention";
+    }>;
+    basis: z.ZodEnum<{
+        fga_invoker: "fga_invoker";
+        trusted_trigger: "trusted_trigger";
+        schedule_author: "schedule_author";
+        schedule_no_author: "schedule_no_author";
+        trusted_service: "trusted_service";
+        subprocess_spawn_gate: "subprocess_spawn_gate";
+        subprocess_parent_starter: "subprocess_parent_starter";
+        subprocess_existing_child: "subprocess_existing_child";
+        intervention_actor: "intervention_actor";
+    }>;
+    authorizedAt: z.ZodISODateTime;
+    schedule: z.ZodNullable<z.ZodObject<{
+        scheduleId: z.ZodString;
+        scheduledAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type FunctionLatticeStartProvenance = z.infer<typeof functionLatticeStartProvenanceSchema>;
+export declare const functionLatticeHumanCompletionQuerySchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    stepId: z.ZodOptional<z.ZodString>;
+    ancestorNodeId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type FunctionLatticeHumanCompletionQuery = z.infer<typeof functionLatticeHumanCompletionQuerySchema>;
+export declare const functionLatticeHumanCompletionsQuerySchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    ancestorNodeId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type FunctionLatticeHumanCompletionsQuery = z.infer<typeof functionLatticeHumanCompletionsQuerySchema>;
+export declare const functionLatticeParallelSnapshotQuerySchema: z.ZodObject<{
+    nodeId: z.ZodString;
+    ancestorNodeId: z.ZodString;
+}, z.core.$strict>;
+export type FunctionLatticeParallelSnapshotQuery = z.infer<typeof functionLatticeParallelSnapshotQuerySchema>;
+export declare const functionLatticeContextRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operation: z.ZodLiteral<"getExecutionContext">;
+}, z.core.$strict>, z.ZodObject<{
+    nodeId: z.ZodString;
+    stepId: z.ZodOptional<z.ZodString>;
+    ancestorNodeId: z.ZodOptional<z.ZodString>;
+    operation: z.ZodLiteral<"getHumanCompletion">;
+}, z.core.$strict>, z.ZodObject<{
+    nodeId: z.ZodString;
+    ancestorNodeId: z.ZodOptional<z.ZodString>;
+    operation: z.ZodLiteral<"getHumanCompletions">;
+}, z.core.$strict>, z.ZodObject<{
+    nodeId: z.ZodString;
+    ancestorNodeId: z.ZodString;
+    operation: z.ZodLiteral<"getParallelSnapshot">;
+}, z.core.$strict>], "operation">;
+export type FunctionLatticeContextRequest = z.infer<typeof functionLatticeContextRequestSchema>;
+export declare const functionLatticeExecutionContextSchema: z.ZodObject<{
+    receiverFunctionOrgId: z.ZodString;
+    parent: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        runId: z.ZodString;
+        processId: z.ZodString;
+        processVersion: z.ZodString;
+        bundleHash: z.ZodString;
+        stepId: z.ZodString;
+        nodeId: z.ZodString;
+        attempt: z.ZodNumber;
+        input: z.ZodUnknown;
+        branch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            index: z.ZodNumber;
+            item: z.ZodUnknown;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    run: z.ZodObject<{
+        id: z.ZodString;
+        processId: z.ZodString;
+        processVersion: z.ZodString;
+        bundleHash: z.ZodString;
+        entity: z.ZodNullable<z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+        startProvenance: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            version: z.ZodLiteral<1>;
+            issuer: z.ZodString;
+            runId: z.ZodString;
+            processId: z.ZodString;
+            processVersion: z.ZodString;
+            bundleHash: z.ZodString;
+            actorSub: z.ZodString;
+            startedBy: z.ZodNullable<z.ZodString>;
+            mode: z.ZodEnum<{
+                system: "system";
+                manual: "manual";
+                trigger: "trigger";
+                schedule: "schedule";
+                subprocess: "subprocess";
+                intervention: "intervention";
+            }>;
+            basis: z.ZodEnum<{
+                fga_invoker: "fga_invoker";
+                trusted_trigger: "trusted_trigger";
+                schedule_author: "schedule_author";
+                schedule_no_author: "schedule_no_author";
+                trusted_service: "trusted_service";
+                subprocess_spawn_gate: "subprocess_spawn_gate";
+                subprocess_parent_starter: "subprocess_parent_starter";
+                subprocess_existing_child: "subprocess_existing_child";
+                intervention_actor: "intervention_actor";
+            }>;
+            authorizedAt: z.ZodISODateTime;
+            schedule: z.ZodNullable<z.ZodObject<{
+                scheduleId: z.ZodString;
+                scheduledAt: z.ZodISODateTime;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strip>;
+    step: z.ZodObject<{
+        id: z.ZodString;
+        nodeId: z.ZodString;
+        attempt: z.ZodNumber;
+        runAsServiceAccount: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    receiver: z.ZodObject<{
+        functionId: z.ZodString;
+        versionId: z.ZodString;
+        invocationId: z.ZodString;
+        invoker: z.ZodObject<{
+            sub: z.ZodString;
+            kind: z.ZodString;
+            authenticationMethod: z.ZodString;
+        }, z.core.$strip>;
+        attachedServiceAccountSub: z.ZodString;
+    }, z.core.$strip>;
+    input: z.ZodUnknown;
+    ctxSnapshot: z.ZodObject<{
+        entity: z.ZodUnknown;
+        upstream: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        run: z.ZodObject<{
+            id: z.ZodString;
+            process_id: z.ZodString;
+            version: z.ZodString;
+            started_at: z.ZodISODateTime;
+            started_by: z.ZodNullable<z.ZodString>;
+            metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            trigger_reason: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        }, z.core.$strip>;
+        branch: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            index: z.ZodNumber;
+            item: z.ZodUnknown;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type FunctionLatticeExecutionContext = z.infer<typeof functionLatticeExecutionContextSchema>;
+export declare const functionLatticeHumanCompletionSchema: z.ZodObject<{
+    receiverFunctionOrgId: z.ZodString;
+    parent: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        runId: z.ZodString;
+        processId: z.ZodString;
+        processVersion: z.ZodString;
+        bundleHash: z.ZodString;
+        stepId: z.ZodString;
+        nodeId: z.ZodString;
+        attempt: z.ZodNumber;
+        input: z.ZodUnknown;
+        branch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            index: z.ZodNumber;
+            item: z.ZodUnknown;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    run: z.ZodObject<{
+        id: z.ZodString;
+        processId: z.ZodString;
+        processVersion: z.ZodString;
+        bundleHash: z.ZodString;
+        entity: z.ZodNullable<z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+        startProvenance: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            version: z.ZodLiteral<1>;
+            issuer: z.ZodString;
+            runId: z.ZodString;
+            processId: z.ZodString;
+            processVersion: z.ZodString;
+            bundleHash: z.ZodString;
+            actorSub: z.ZodString;
+            startedBy: z.ZodNullable<z.ZodString>;
+            mode: z.ZodEnum<{
+                system: "system";
+                manual: "manual";
+                trigger: "trigger";
+                schedule: "schedule";
+                subprocess: "subprocess";
+                intervention: "intervention";
+            }>;
+            basis: z.ZodEnum<{
+                fga_invoker: "fga_invoker";
+                trusted_trigger: "trusted_trigger";
+                schedule_author: "schedule_author";
+                schedule_no_author: "schedule_no_author";
+                trusted_service: "trusted_service";
+                subprocess_spawn_gate: "subprocess_spawn_gate";
+                subprocess_parent_starter: "subprocess_parent_starter";
+                subprocess_existing_child: "subprocess_existing_child";
+                intervention_actor: "intervention_actor";
+            }>;
+            authorizedAt: z.ZodISODateTime;
+            schedule: z.ZodNullable<z.ZodObject<{
+                scheduleId: z.ZodString;
+                scheduledAt: z.ZodISODateTime;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strip>;
+    step: z.ZodObject<{
+        id: z.ZodString;
+        nodeId: z.ZodString;
+        attempt: z.ZodNumber;
+        runAsServiceAccount: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    receiver: z.ZodObject<{
+        functionId: z.ZodString;
+        versionId: z.ZodString;
+        invocationId: z.ZodString;
+        invoker: z.ZodObject<{
+            sub: z.ZodString;
+            kind: z.ZodString;
+            authenticationMethod: z.ZodString;
+        }, z.core.$strip>;
+        attachedServiceAccountSub: z.ZodString;
+    }, z.core.$strip>;
+    human: z.ZodObject<{
+        receipt: z.ZodString;
+        runId: z.ZodString;
+        processId: z.ZodString;
+        bundleHash: z.ZodString;
+        actorSub: z.ZodString;
+        receiptId: z.ZodString;
+        stepId: z.ZodString;
+        nodeId: z.ZodString;
+        attempt: z.ZodNumber;
+        edgeId: z.ZodNullable<z.ZodString>;
+        payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        completedAt: z.ZodISODateTime;
+        ancestor: z.ZodOptional<z.ZodObject<{
+            runId: z.ZodString;
+            processId: z.ZodString;
+            bundleHash: z.ZodString;
+            stepId: z.ZodString;
+            nodeId: z.ZodString;
+            attempt: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type FunctionLatticeHumanCompletion = z.infer<typeof functionLatticeHumanCompletionSchema>;
+export declare const functionLatticeHumanCompletionsPageSchema: z.ZodObject<{
+    completions: z.ZodArray<z.ZodObject<{
+        receiverFunctionOrgId: z.ZodString;
+        parent: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            runId: z.ZodString;
+            processId: z.ZodString;
+            processVersion: z.ZodString;
+            bundleHash: z.ZodString;
+            stepId: z.ZodString;
+            nodeId: z.ZodString;
+            attempt: z.ZodNumber;
+            input: z.ZodUnknown;
+            branch: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                index: z.ZodNumber;
+                item: z.ZodUnknown;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        run: z.ZodObject<{
+            id: z.ZodString;
+            processId: z.ZodString;
+            processVersion: z.ZodString;
+            bundleHash: z.ZodString;
+            entity: z.ZodNullable<z.ZodObject<{
+                type: z.ZodString;
+                id: z.ZodString;
+            }, z.core.$strip>>;
+            startProvenance: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                version: z.ZodLiteral<1>;
+                issuer: z.ZodString;
+                runId: z.ZodString;
+                processId: z.ZodString;
+                processVersion: z.ZodString;
+                bundleHash: z.ZodString;
+                actorSub: z.ZodString;
+                startedBy: z.ZodNullable<z.ZodString>;
+                mode: z.ZodEnum<{
+                    system: "system";
+                    manual: "manual";
+                    trigger: "trigger";
+                    schedule: "schedule";
+                    subprocess: "subprocess";
+                    intervention: "intervention";
+                }>;
+                basis: z.ZodEnum<{
+                    fga_invoker: "fga_invoker";
+                    trusted_trigger: "trusted_trigger";
+                    schedule_author: "schedule_author";
+                    schedule_no_author: "schedule_no_author";
+                    trusted_service: "trusted_service";
+                    subprocess_spawn_gate: "subprocess_spawn_gate";
+                    subprocess_parent_starter: "subprocess_parent_starter";
+                    subprocess_existing_child: "subprocess_existing_child";
+                    intervention_actor: "intervention_actor";
+                }>;
+                authorizedAt: z.ZodISODateTime;
+                schedule: z.ZodNullable<z.ZodObject<{
+                    scheduleId: z.ZodString;
+                    scheduledAt: z.ZodISODateTime;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strip>;
+        step: z.ZodObject<{
+            id: z.ZodString;
+            nodeId: z.ZodString;
+            attempt: z.ZodNumber;
+            runAsServiceAccount: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        receiver: z.ZodObject<{
+            functionId: z.ZodString;
+            versionId: z.ZodString;
+            invocationId: z.ZodString;
+            invoker: z.ZodObject<{
+                sub: z.ZodString;
+                kind: z.ZodString;
+                authenticationMethod: z.ZodString;
+            }, z.core.$strip>;
+            attachedServiceAccountSub: z.ZodString;
+        }, z.core.$strip>;
+        human: z.ZodObject<{
+            receipt: z.ZodString;
+            runId: z.ZodString;
+            processId: z.ZodString;
+            bundleHash: z.ZodString;
+            actorSub: z.ZodString;
+            receiptId: z.ZodString;
+            stepId: z.ZodString;
+            nodeId: z.ZodString;
+            attempt: z.ZodNumber;
+            edgeId: z.ZodNullable<z.ZodString>;
+            payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            completedAt: z.ZodISODateTime;
+            ancestor: z.ZodOptional<z.ZodObject<{
+                runId: z.ZodString;
+                processId: z.ZodString;
+                bundleHash: z.ZodString;
+                stepId: z.ZodString;
+                nodeId: z.ZodString;
+                attempt: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FunctionLatticeHumanCompletionsPage = z.infer<typeof functionLatticeHumanCompletionsPageSchema>;
+export declare const functionLatticeParallelSnapshotSchema: z.ZodObject<{
+    receiverFunctionOrgId: z.ZodString;
+    parent: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        runId: z.ZodString;
+        processId: z.ZodString;
+        processVersion: z.ZodString;
+        bundleHash: z.ZodString;
+        stepId: z.ZodString;
+        nodeId: z.ZodString;
+        attempt: z.ZodNumber;
+        input: z.ZodUnknown;
+        branch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            index: z.ZodNumber;
+            item: z.ZodUnknown;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    run: z.ZodObject<{
+        id: z.ZodString;
+        processId: z.ZodString;
+        processVersion: z.ZodString;
+        bundleHash: z.ZodString;
+        entity: z.ZodNullable<z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+        startProvenance: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            version: z.ZodLiteral<1>;
+            issuer: z.ZodString;
+            runId: z.ZodString;
+            processId: z.ZodString;
+            processVersion: z.ZodString;
+            bundleHash: z.ZodString;
+            actorSub: z.ZodString;
+            startedBy: z.ZodNullable<z.ZodString>;
+            mode: z.ZodEnum<{
+                system: "system";
+                manual: "manual";
+                trigger: "trigger";
+                schedule: "schedule";
+                subprocess: "subprocess";
+                intervention: "intervention";
+            }>;
+            basis: z.ZodEnum<{
+                fga_invoker: "fga_invoker";
+                trusted_trigger: "trusted_trigger";
+                schedule_author: "schedule_author";
+                schedule_no_author: "schedule_no_author";
+                trusted_service: "trusted_service";
+                subprocess_spawn_gate: "subprocess_spawn_gate";
+                subprocess_parent_starter: "subprocess_parent_starter";
+                subprocess_existing_child: "subprocess_existing_child";
+                intervention_actor: "intervention_actor";
+            }>;
+            authorizedAt: z.ZodISODateTime;
+            schedule: z.ZodNullable<z.ZodObject<{
+                scheduleId: z.ZodString;
+                scheduledAt: z.ZodISODateTime;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strip>;
+    step: z.ZodObject<{
+        id: z.ZodString;
+        nodeId: z.ZodString;
+        attempt: z.ZodNumber;
+        runAsServiceAccount: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    receiver: z.ZodObject<{
+        functionId: z.ZodString;
+        versionId: z.ZodString;
+        invocationId: z.ZodString;
+        invoker: z.ZodObject<{
+            sub: z.ZodString;
+            kind: z.ZodString;
+            authenticationMethod: z.ZodString;
+        }, z.core.$strip>;
+        attachedServiceAccountSub: z.ZodString;
+    }, z.core.$strip>;
+    parallel: z.ZodObject<{
+        runId: z.ZodString;
+        processId: z.ZodString;
+        processVersion: z.ZodString;
+        bundleHash: z.ZodString;
+        entity: z.ZodNullable<z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+        stepId: z.ZodString;
+        nodeId: z.ZodString;
+        attempt: z.ZodNumber;
+        status: z.ZodLiteral<"completed">;
+        observedAt: z.ZodISODateTime;
+        proof: z.ZodString;
+        ancestor: z.ZodObject<{
+            runId: z.ZodString;
+            processId: z.ZodString;
+            bundleHash: z.ZodString;
+            stepId: z.ZodString;
+            nodeId: z.ZodString;
+            attempt: z.ZodNumber;
+            receipt: z.ZodString;
+            receiptId: z.ZodString;
+        }, z.core.$strip>;
+        branches: z.ZodArray<z.ZodObject<{
+            branchId: z.ZodString;
+            branchIndex: z.ZodNumber;
+            item: z.ZodUnknown;
+            stepId: z.ZodString;
+            nodeId: z.ZodString;
+            attempt: z.ZodNumber;
+            status: z.ZodEnum<{
+                pending: "pending";
+                running: "running";
+                completed: "completed";
+                failed: "failed";
+                cancelled: "cancelled";
+                timed_out: "timed_out";
+            }>;
+            joinStatus: z.ZodEnum<{
+                pending: "pending";
+                completed: "completed";
+                failed: "failed";
+                cancelled: "cancelled";
+                timed_out: "timed_out";
+            }>;
+            humanStep: z.ZodNullable<z.ZodObject<{
+                runId: z.ZodString;
+                stepId: z.ZodString;
+                nodeId: z.ZodString;
+                attempt: z.ZodNumber;
+                receiptId: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type FunctionLatticeParallelSnapshot = z.infer<typeof functionLatticeParallelSnapshotSchema>;
+export declare class FunctionLatticeContextError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly name = "FunctionLatticeContextError";
+    constructor(status: number, code: string, message: string);
+}

package/dist/lattice-provenance-contract.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionLatticeContextError = exports.functionLatticeParallelSnapshotSchema = exports.functionLatticeHumanCompletionsPageSchema = exports.functionLatticeHumanCompletionSchema = exports.functionLatticeExecutionContextSchema = exports.functionLatticeContextRequestSchema = exports.functionLatticeParallelSnapshotQuerySchema = exports.functionLatticeHumanCompletionsQuerySchema = exports.functionLatticeHumanCompletionQuerySchema = exports.functionLatticeStartProvenanceSchema = exports.FUNCTION_LATTICE_CONTEXT_PATH = exports.FUNCTION_LATTICE_EXECUTION_TOKEN_HEADER = void 0;
+const zod_1 = require("zod");
+exports.FUNCTION_LATTICE_EXECUTION_TOKEN_HEADER = 'x-sequence-lattice-execution-token';
+exports.FUNCTION_LATTICE_CONTEXT_PATH = '/api/managed-functions/lattice/context';
+const identifier = zod_1.z.string().min(1).max(255);
+const principal = zod_1.z.string().min(1).max(512);
+const record = zod_1.z.record(zod_1.z.string(), zod_1.z.unknown());
+const attempt = zod_1.z.number().int().positive();
+const startBasisByMode = {
+    manual: ['fga_invoker'], trigger: ['trusted_trigger'], schedule: ['schedule_author', 'schedule_no_author'],
+    system: ['trusted_service'], subprocess: ['subprocess_spawn_gate', 'subprocess_parent_starter', 'subprocess_existing_child'], intervention: ['intervention_actor'],
+};
+exports.functionLatticeStartProvenanceSchema = zod_1.z.strictObject({
+    version: zod_1.z.literal(1), issuer: zod_1.z.string().min(1).max(8192),
+    runId: identifier, processId: identifier, processVersion: identifier, bundleHash: identifier,
+    actorSub: principal, startedBy: principal.nullable(),
+    mode: zod_1.z.enum(['manual', 'trigger', 'schedule', 'system', 'subprocess', 'intervention']),
+    basis: zod_1.z.enum(['fga_invoker', 'schedule_author', 'schedule_no_author', 'trusted_service', 'trusted_trigger', 'subprocess_spawn_gate', 'subprocess_parent_starter', 'subprocess_existing_child', 'intervention_actor']),
+    authorizedAt: zod_1.z.iso.datetime(), schedule: zod_1.z.strictObject({ scheduleId: identifier, scheduledAt: zod_1.z.iso.datetime() }).nullable(),
+}).refine((value) => startBasisByMode[value.mode].includes(value.basis) && (value.mode === 'schedule') === (value.schedule !== null), 'Start basis and schedule must match the verified authorization mode');
+exports.functionLatticeHumanCompletionQuerySchema = zod_1.z.strictObject({
+    nodeId: identifier,
+    stepId: identifier.optional(),
+    ancestorNodeId: identifier.optional(),
+});
+exports.functionLatticeHumanCompletionsQuerySchema = exports.functionLatticeHumanCompletionQuerySchema.omit({ stepId: true });
+exports.functionLatticeParallelSnapshotQuerySchema = zod_1.z.strictObject({ nodeId: identifier, ancestorNodeId: identifier });
+exports.functionLatticeContextRequestSchema = zod_1.z.discriminatedUnion('operation', [
+    zod_1.z.strictObject({ operation: zod_1.z.literal('getExecutionContext') }),
+    exports.functionLatticeHumanCompletionQuerySchema.extend({
+        operation: zod_1.z.literal('getHumanCompletion'),
+    }),
+    exports.functionLatticeHumanCompletionsQuerySchema.extend({
+        operation: zod_1.z.literal('getHumanCompletions'),
+    }),
+    exports.functionLatticeParallelSnapshotQuerySchema.extend({ operation: zod_1.z.literal('getParallelSnapshot') }),
+]);
+const executionIdentity = zod_1.z.object({
+    receiverFunctionOrgId: identifier,
+    parent: zod_1.z.object({ runId: identifier, processId: identifier, processVersion: identifier, bundleHash: identifier, stepId: identifier, nodeId: identifier, attempt, input: zod_1.z.unknown(), branch: zod_1.z.object({ id: identifier, index: zod_1.z.number().int().nonnegative(), item: zod_1.z.unknown() }).nullable() }).nullable().optional(),
+    run: zod_1.z.object({
+        id: identifier,
+        processId: identifier,
+        processVersion: identifier,
+        bundleHash: identifier,
+        entity: zod_1.z.object({ type: identifier, id: identifier }).nullable(),
+        startProvenance: exports.functionLatticeStartProvenanceSchema.nullable().optional(),
+    }).refine((run) => !run.startProvenance || (run.startProvenance.runId === run.id && run.startProvenance.processId === run.processId && run.startProvenance.processVersion === run.processVersion && run.startProvenance.bundleHash === run.bundleHash), 'Start provenance must identify the exact executing run'),
+    step: zod_1.z.object({
+        id: identifier,
+        nodeId: identifier,
+        attempt,
+        runAsServiceAccount: principal.nullable(),
+    }),
+    receiver: zod_1.z.object({
+        functionId: identifier,
+        versionId: identifier,
+        invocationId: identifier,
+        invoker: zod_1.z.object({ sub: principal, kind: identifier, authenticationMethod: identifier }),
+        attachedServiceAccountSub: principal,
+    }),
+});
+exports.functionLatticeExecutionContextSchema = executionIdentity.extend({
+    input: zod_1.z.unknown(),
+    ctxSnapshot: zod_1.z.object({
+        entity: zod_1.z.unknown(),
+        upstream: record,
+        state: record,
+        run: zod_1.z.object({
+            id: identifier,
+            process_id: identifier,
+            version: identifier,
+            started_at: zod_1.z.iso.datetime({ offset: true }),
+            started_by: principal.nullable(),
+            metadata: record,
+            trigger_reason: record.nullable().optional(),
+        }),
+        branch: zod_1.z.object({ id: identifier, index: zod_1.z.number().int().nonnegative(), item: zod_1.z.unknown() }).optional(),
+    }),
+}).refine((value) => value.ctxSnapshot.run.id === value.run.id &&
+    value.ctxSnapshot.run.process_id === value.run.processId &&
+    value.ctxSnapshot.run.version === value.run.processVersion, 'The context snapshot must identify the executing run');
+exports.functionLatticeHumanCompletionSchema = executionIdentity.extend({
+    human: zod_1.z.object({
+        receipt: zod_1.z.string().min(1).max(16_384),
+        runId: identifier,
+        processId: identifier,
+        bundleHash: identifier,
+        actorSub: principal,
+        receiptId: identifier,
+        stepId: identifier,
+        nodeId: identifier,
+        attempt,
+        edgeId: identifier.nullable(),
+        payload: record,
+        completedAt: zod_1.z.iso.datetime({ offset: true }),
+        ancestor: zod_1.z.object({
+            runId: identifier,
+            processId: identifier,
+            bundleHash: identifier,
+            stepId: identifier,
+            nodeId: identifier,
+            attempt,
+        }).optional(),
+    }),
+}).refine((value) => value.human.receiptId === value.human.stepId, 'The receipt identifier must be the actual human step identifier');
+exports.functionLatticeHumanCompletionsPageSchema = zod_1.z.object({
+    completions: zod_1.z.array(exports.functionLatticeHumanCompletionSchema).max(64),
+});
+const parallelHumanStep = zod_1.z.object({ runId: identifier, stepId: identifier, nodeId: identifier, attempt, receiptId: identifier });
+exports.functionLatticeParallelSnapshotSchema = executionIdentity.extend({
+    parallel: zod_1.z.object({
+        runId: identifier, processId: identifier, processVersion: identifier, bundleHash: identifier,
+        entity: zod_1.z.object({ type: identifier, id: identifier }).nullable(),
+        stepId: identifier, nodeId: identifier, attempt, status: zod_1.z.literal('completed'),
+        observedAt: zod_1.z.iso.datetime({ offset: true }), proof: zod_1.z.string().min(1).max(131_072),
+        ancestor: zod_1.z.object({ runId: identifier, processId: identifier, bundleHash: identifier, stepId: identifier, nodeId: identifier, attempt, receipt: zod_1.z.string().min(1).max(16_384), receiptId: identifier }),
+        branches: zod_1.z.array(zod_1.z.object({
+            branchId: identifier, branchIndex: zod_1.z.number().int().nonnegative(), item: zod_1.z.unknown(),
+            stepId: identifier, nodeId: identifier, attempt,
+            status: zod_1.z.enum(['pending', 'running', 'completed', 'failed', 'cancelled', 'timed_out']),
+            joinStatus: zod_1.z.enum(['pending', 'completed', 'failed', 'cancelled', 'timed_out']), humanStep: parallelHumanStep.nullable(),
+        })).max(64),
+    }),
+}).refine((value) => {
+    const branches = value.parallel.branches;
+    return value.parallel.runId === value.run.id && value.parallel.bundleHash === value.run.bundleHash &&
+        value.parallel.processId === value.run.processId && value.parallel.processVersion === value.run.processVersion &&
+        value.parallel.entity?.id === value.run.entity?.id && value.parallel.entity?.type === value.run.entity?.type &&
+        value.parallel.ancestor.runId === value.run.id && value.parallel.ancestor.processId === value.run.processId &&
+        value.parallel.ancestor.bundleHash === value.run.bundleHash && value.parallel.ancestor.receiptId === value.parallel.ancestor.stepId &&
+        new Set(branches.map((branch) => branch.branchId)).size === branches.length &&
+        new Set(branches.map((branch) => branch.branchIndex)).size === branches.length &&
+        branches.every((branch) => !branch.humanStep || (!['pending', 'timed_out'].includes(branch.joinStatus) && branch.humanStep.runId === value.run.id && branch.humanStep.nodeId === branch.nodeId && branch.humanStep.stepId === branch.stepId && branch.humanStep.attempt === branch.attempt && branch.humanStep.receiptId === branch.stepId));
+}, 'Parallel snapshots must identify one complete causal execution with unique actual branches');
+class FunctionLatticeContextError extends Error {
+    status;
+    code;
+    name = 'FunctionLatticeContextError';
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+exports.FunctionLatticeContextError = FunctionLatticeContextError;

package/dist/lattice-provenance.d.ts

@@ -0,0 +1,16 @@
+import { type FunctionLatticeExecutionContext, type FunctionLatticeHumanCompletion, type FunctionLatticeHumanCompletionQuery, type FunctionLatticeHumanCompletionsQuery, type FunctionLatticeHumanCompletionsPage, type FunctionLatticeParallelSnapshot, type FunctionLatticeParallelSnapshotQuery } from './lattice-provenance-contract';
+export * from './lattice-provenance-contract';
+export interface FunctionLatticeClientOptions {
+    request: {
+        headers: Pick<Headers, 'get'> | Readonly<Record<string, string | readonly string[] | undefined>>;
+    };
+    baseUrl: string;
+    fetchImpl?: typeof globalThis.fetch;
+}
+export interface FunctionLatticeClient {
+    getExecutionContext(): Promise<FunctionLatticeExecutionContext>;
+    getHumanCompletion(query: FunctionLatticeHumanCompletionQuery): Promise<FunctionLatticeHumanCompletion>;
+    getHumanCompletions(query: FunctionLatticeHumanCompletionsQuery): Promise<FunctionLatticeHumanCompletionsPage>;
+    getParallelSnapshot(query: FunctionLatticeParallelSnapshotQuery): Promise<FunctionLatticeParallelSnapshot>;
+}
+export declare function createFunctionLatticeClient({ request, baseUrl, fetchImpl, }: FunctionLatticeClientOptions): FunctionLatticeClient;