@sequenceholdings/managed-functions 0.4.5 → 0.5.1

package/dist/lattice-provenance-contract.js

@@ -1,157 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FunctionLatticeContextError = exports.functionLatticeParallelSnapshotSchema = exports.functionLatticeHumanCompletionsPageSchema = exports.functionLatticeHumanCompletionSchema = exports.functionLatticeExecutionContextSchema = exports.functionLatticeRunCreatorAccessSchema = 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') }),
-    zod_1.z.strictObject({ operation: zod_1.z.literal('getRunCreatorAccess') }),
-    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.functionLatticeRunCreatorAccessSchema = executionIdentity.extend({
-    creator: zod_1.z.strictObject({
-        sub: principal,
-        tenant: zod_1.z.string().min(1).max(64).nullable(),
-        platformOperator: zod_1.z.boolean(),
-    }).nullable(),
-    observedAt: zod_1.z.iso.datetime({ offset: true }),
-});
-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;
+var contracts_1 = require("@sequenceholdings/platform/contracts");
+Object.defineProperty(exports, "FUNCTION_LATTICE_EXECUTION_TOKEN_HEADER", { enumerable: true, get: function () { return contracts_1.FUNCTION_LATTICE_EXECUTION_TOKEN_HEADER; } });
+Object.defineProperty(exports, "FUNCTION_LATTICE_CONTEXT_PATH", { enumerable: true, get: function () { return contracts_1.FUNCTION_LATTICE_CONTEXT_PATH; } });
+Object.defineProperty(exports, "functionLatticeStartProvenanceSchema", { enumerable: true, get: function () { return contracts_1.functionLatticeStartProvenanceSchema; } });
+Object.defineProperty(exports, "functionLatticeHumanCompletionQuerySchema", { enumerable: true, get: function () { return contracts_1.functionLatticeHumanCompletionQuerySchema; } });
+Object.defineProperty(exports, "functionLatticeHumanCompletionsQuerySchema", { enumerable: true, get: function () { return contracts_1.functionLatticeHumanCompletionsQuerySchema; } });
+Object.defineProperty(exports, "functionLatticeParallelSnapshotQuerySchema", { enumerable: true, get: function () { return contracts_1.functionLatticeParallelSnapshotQuerySchema; } });
+Object.defineProperty(exports, "functionLatticeContextRequestSchema", { enumerable: true, get: function () { return contracts_1.functionLatticeContextRequestSchema; } });
+Object.defineProperty(exports, "functionLatticeRunCreatorAccessSchema", { enumerable: true, get: function () { return contracts_1.functionLatticeRunCreatorAccessSchema; } });
+Object.defineProperty(exports, "functionLatticeExecutionContextSchema", { enumerable: true, get: function () { return contracts_1.functionLatticeExecutionContextSchema; } });
+Object.defineProperty(exports, "functionLatticeHumanCompletionSchema", { enumerable: true, get: function () { return contracts_1.functionLatticeHumanCompletionSchema; } });
+Object.defineProperty(exports, "functionLatticeHumanCompletionsPageSchema", { enumerable: true, get: function () { return contracts_1.functionLatticeHumanCompletionsPageSchema; } });
+Object.defineProperty(exports, "functionLatticeParallelSnapshotSchema", { enumerable: true, get: function () { return contracts_1.functionLatticeParallelSnapshotSchema; } });
+Object.defineProperty(exports, "FunctionLatticeContextError", { enumerable: true, get: function () { return contracts_1.FunctionLatticeContextError; } });

package/dist/lattice-provenance.d.ts

@@ -1,8 +1,8 @@
-import { type FunctionLatticeRunCreatorAccess, type FunctionLatticeExecutionContext, type FunctionLatticeHumanCompletion, type FunctionLatticeHumanCompletionQuery, type FunctionLatticeHumanCompletionsQuery, type FunctionLatticeHumanCompletionsPage, type FunctionLatticeParallelSnapshot, type FunctionLatticeParallelSnapshotQuery } from './lattice-provenance-contract';
-export * from './lattice-provenance-contract';
+import { type FunctionLatticeRunCreatorAccess, 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>>;
+        headers: Pick<Headers, "get"> | Readonly<Record<string, string | readonly string[] | undefined>>;
     };
     baseUrl: string;
     fetchImpl?: typeof globalThis.fetch;

package/dist/lattice-provenance.js

@@ -15,11 +15,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFunctionLatticeClient = createFunctionLatticeClient;
+const adapters_1 = require("@sequenceholdings/platform/adapters");
 const zod_1 = require("zod");
 const lattice_provenance_contract_1 = require("./lattice-provenance-contract");
 __exportStar(require("./lattice-provenance-contract"), exports);
 const tokenClaimsSchema = zod_1.z.object({
-    audience: zod_1.z.literal('atlas-managed-function-lattice-execution'),
+    audience: zod_1.z.literal("atlas-managed-function-lattice-execution"),
     functionId: zod_1.z.string().min(1).max(255),
     versionId: zod_1.z.string().min(1).max(255),
     invocationId: zod_1.z.string().min(1).max(255),
@@ -32,29 +33,33 @@ const tokenClaimsSchema = zod_1.z.object({
     nodeId: zod_1.z.string().min(1).max(255),
     stepAttempt: zod_1.z.number().int().positive(),
     serviceAccountId: zod_1.z.string().min(1).max(255),
-    callerSub: zod_1.z.string().min(1).max(512), callerKind: zod_1.z.string().min(1).max(64), callerAuthenticationMethod: zod_1.z.string().min(1).max(64),
+    callerSub: zod_1.z.string().min(1).max(512),
+    callerKind: zod_1.z.string().min(1).max(64),
+    callerAuthenticationMethod: zod_1.z.string().min(1).max(64),
     exp: zod_1.z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
 });
-const invalidContext = () => new lattice_provenance_contract_1.FunctionLatticeContextError(401, 'invalid_context', 'This invocation has no valid Lattice execution credential');
+const invalidContext = () => new lattice_provenance_contract_1.FunctionLatticeContextError(401, "invalid_context", "This invocation has no valid Lattice execution credential");
 function readCredential({ request, }) {
     const { headers } = request;
-    const matches = typeof headers.get === 'function'
+    const matches = typeof headers.get === "function"
         ? [headers.get(lattice_provenance_contract_1.FUNCTION_LATTICE_EXECUTION_TOKEN_HEADER)]
         : Object.entries(headers)
             .filter(([name]) => name.toLowerCase() === lattice_provenance_contract_1.FUNCTION_LATTICE_EXECUTION_TOKEN_HEADER)
             .map(([, value]) => value);
     const token = matches[0];
-    if (matches.length !== 1 || typeof token !== 'string' || token.length > 16_384)
+    if (matches.length !== 1 ||
+        typeof token !== "string" ||
+        token.length > 16_384)
         throw invalidContext();
     const envelope = /^([A-Za-z0-9_-]+)\.([A-Za-z0-9_-]{43})$/.exec(token);
     if (!envelope?.[1])
         throw invalidContext();
     let value;
     try {
-        const decoded = Buffer.from(envelope[1], 'base64url');
-        if (decoded.toString('base64url') !== envelope[1])
+        const decoded = Buffer.from(envelope[1], "base64url");
+        if (decoded.toString("base64url") !== envelope[1])
             throw invalidContext();
-        value = JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(decoded));
+        value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(decoded));
     }
     catch {
         throw invalidContext();
@@ -65,7 +70,7 @@ function readCredential({ request, }) {
     return { token, claims: parsed.data };
 }
 function trustedOrigin(baseUrl) {
-    const invalid = () => new lattice_provenance_contract_1.FunctionLatticeContextError(400, 'invalid_configuration', 'Configure a trusted HTTPS Atlas origin without credentials, path, query or fragment');
+    const invalid = () => new lattice_provenance_contract_1.FunctionLatticeContextError(400, "invalid_configuration", "Configure a trusted HTTPS Atlas origin without credentials, path, query or fragment");
     let url;
     try {
         url = new URL(baseUrl);
@@ -73,98 +78,42 @@ function trustedOrigin(baseUrl) {
     catch {
         throw invalid();
     }
-    const loopback = url.protocol === 'http:' &&
-        ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname);
-    if ((!loopback && url.protocol !== 'https:') || url.username || url.password ||
-        url.pathname !== '/' || url.search || url.hash)
+    const loopback = url.protocol === "http:" &&
+        ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    if ((!loopback && url.protocol !== "https:") ||
+        url.username ||
+        url.password ||
+        url.pathname !== "/" ||
+        url.search ||
+        url.hash)
         throw invalid();
     return url.origin;
 }
-function matchesExecution({ execution, claims, }) {
-    return execution.receiver.functionId === claims.functionId &&
-        execution.receiver.versionId === claims.versionId &&
-        execution.receiver.invocationId === claims.invocationId &&
-        execution.receiverFunctionOrgId === claims.org &&
-        execution.run.id === claims.runId && execution.run.processId === claims.processId &&
-        execution.run.processVersion === claims.processVersion && execution.run.bundleHash === claims.bundleHash &&
-        execution.step.id === claims.stepId && execution.step.nodeId === claims.nodeId &&
-        execution.step.attempt === claims.stepAttempt && execution.receiver.invoker.sub === claims.callerSub &&
-        execution.receiver.invoker.kind === claims.callerKind && execution.receiver.invoker.authenticationMethod === claims.callerAuthenticationMethod &&
-        execution.receiver.attachedServiceAccountSub === `service-account|${claims.serviceAccountId}`;
-}
-function validateHumanSelection({ completion, query, }) {
-    if (completion.human.nodeId !== query.nodeId ||
-        (query.stepId !== undefined && completion.human.stepId !== query.stepId) ||
-        (query.ancestorNodeId !== undefined && completion.human.ancestor?.nodeId !== query.ancestorNodeId))
-        throw new lattice_provenance_contract_1.FunctionLatticeContextError(502, 'malformed_response', 'Atlas returned a different completed human step');
-}
 function createFunctionLatticeClient({ request, baseUrl, fetchImpl = globalThis.fetch, }) {
-    const url = `${trustedOrigin(baseUrl)}${lattice_provenance_contract_1.FUNCTION_LATTICE_CONTEXT_PATH}`;
+    trustedOrigin(baseUrl);
     const { token, claims } = readCredential({ request });
-    async function read({ body, schema, executions, }) {
-        if (claims.exp <= Date.now() / 1000)
-            throw new lattice_provenance_contract_1.FunctionLatticeContextError(401, 'expired_context', 'The execution credential expired; start a new invocation');
-        const parsed = lattice_provenance_contract_1.functionLatticeContextRequestSchema.safeParse(body);
-        if (!parsed.success)
-            throw new lattice_provenance_contract_1.FunctionLatticeContextError(400, 'invalid_request', 'Select a valid Lattice context operation and human step');
-        let response;
-        try {
-            response = await fetchImpl(url, {
-                method: 'POST',
-                headers: {
-                    'content-type': 'application/json',
-                    [lattice_provenance_contract_1.FUNCTION_LATTICE_EXECUTION_TOKEN_HEADER]: token,
-                },
-                body: JSON.stringify(parsed.data),
-                redirect: 'error',
-                signal: AbortSignal.timeout(30_000),
-            });
-        }
-        catch {
-            throw new lattice_provenance_contract_1.FunctionLatticeContextError(502, 'context_request_failed', 'The Lattice context request failed');
-        }
-        if (response.redirected || (response.status >= 300 && response.status < 400))
-            throw new lattice_provenance_contract_1.FunctionLatticeContextError(502, 'redirect_refused', 'The Lattice context request must not redirect');
-        const result = await response.json().catch(() => null);
-        if (!response.ok) {
-            const error = zod_1.z.object({ code: zod_1.z.string().min(1).max(128), detail: zod_1.z.string().min(1).max(2000) }).safeParse(result);
-            throw new lattice_provenance_contract_1.FunctionLatticeContextError(response.status, error.success ? error.data.code : 'context_read_failed', error.success ? error.data.detail : 'Lattice context read failed');
-        }
-        const validated = schema.safeParse(result);
-        if (!validated.success || executions(validated.data).some((execution) => !matchesExecution({ execution, claims })))
-            throw new lattice_provenance_contract_1.FunctionLatticeContextError(502, 'malformed_response', 'Atlas returned an invalid Lattice context response');
-        return validated.data;
-    }
-    return {
-        getExecutionContext() {
-            return read({ body: { operation: 'getExecutionContext' }, schema: lattice_provenance_contract_1.functionLatticeExecutionContextSchema, executions: (value) => [value] });
-        },
-        getRunCreatorAccess() {
-            return read({ body: { operation: 'getRunCreatorAccess' }, schema: lattice_provenance_contract_1.functionLatticeRunCreatorAccessSchema, executions: value => [value] });
-        },
-        async getHumanCompletion(query) {
-            const completion = await read({
-                body: { ...query, operation: 'getHumanCompletion' },
-                schema: lattice_provenance_contract_1.functionLatticeHumanCompletionSchema,
-                executions: (value) => [value],
-            });
-            validateHumanSelection({ completion, query });
-            return completion;
-        },
-        async getHumanCompletions(query) {
-            const page = await read({
-                body: { ...query, operation: 'getHumanCompletions' },
-                schema: lattice_provenance_contract_1.functionLatticeHumanCompletionsPageSchema,
-                executions: (value) => value.completions,
-            });
-            page.completions.forEach((completion) => validateHumanSelection({ completion, query }));
-            return page;
-        },
-        async getParallelSnapshot(query) {
-            const snapshot = await read({ body: { ...query, operation: 'getParallelSnapshot' }, schema: lattice_provenance_contract_1.functionLatticeParallelSnapshotSchema, executions: (value) => [value] });
-            if (snapshot.parallel.nodeId !== query.nodeId || snapshot.parallel.ancestor.nodeId !== query.ancestorNodeId)
-                throw new lattice_provenance_contract_1.FunctionLatticeContextError(502, 'malformed_response', 'Atlas returned a different causal parallel execution');
-            return snapshot;
+    const send = (0, adapters_1.createInvocationDomainTransport)({
+        baseUrl,
+        fetchImpl,
+        domain: "lattice-execution",
+        credentials: [
+            {
+                header: lattice_provenance_contract_1.FUNCTION_LATTICE_EXECUTION_TOKEN_HEADER,
+                token,
+                expiresAt: claims.exp,
+            },
+        ],
+        error: (status, code, message) => new lattice_provenance_contract_1.FunctionLatticeContextError(["transport_failed", "timeout", "redirect_refused"].includes(code)
+            ? 502
+            : status, ["transport_failed", "timeout"].includes(code)
+            ? "context_request_failed"
+            : code, ["transport_failed", "timeout"].includes(code)
+            ? "The Lattice context request failed"
+            : message),
+        failure: {
+            code: "context_read_failed",
+            message: "Lattice context read failed",
         },
-    };
+    });
+    return (0, adapters_1.createLatticeExecutionClient)({ claims, send });
 }

package/dist/monitoring-annotations.d.ts

@@ -1,53 +1,2 @@
-import { z } from 'zod';
-export type MonitoringJson = string | number | boolean | null | MonitoringJson[] | {
-    [key: string]: MonitoringJson;
-};
-export declare const functionMonitoringAnnotationSchema: z.ZodObject<{
-    sourceType: z.ZodString;
-    sourceRef: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    generatingSubject: z.ZodObject<{
-        subjectId: z.ZodString;
-        subjectKind: z.ZodEnum<{
-            workflow: "workflow";
-            agent: "agent";
-        }>;
-    }, z.core.$strict>;
-    occurredAt: z.ZodISODateTime;
-    summary: z.ZodNullable<z.ZodString>;
-    metrics: z.ZodCustom<MonitoringJson, MonitoringJson>;
-    conversationFindings: z.ZodArray<z.ZodObject<{
-        type: z.ZodString;
-        description: z.ZodString;
-        excerpt: z.ZodString;
-        severity: z.ZodEnum<{
-            high: "high";
-            medium: "medium";
-            low: "low";
-        }>;
-    }, z.core.$strict>>;
-    classifications: z.ZodArray<z.ZodObject<{
-        matchedBucketSlug: z.ZodNullable<z.ZodString>;
-        newBucketProposal: z.ZodNullable<z.ZodObject<{
-            name: z.ZodString;
-            description: z.ZodString;
-            severity: z.ZodEnum<{
-                critical: "critical";
-                high: "high";
-                medium: "medium";
-                low: "low";
-            }>;
-            category: z.ZodString;
-        }, z.core.$strict>>;
-        excerpt: z.ZodString;
-        inputTags: z.ZodArray<z.ZodObject<{
-            type: z.ZodString;
-            value: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    coarseFallbacks: z.ZodArray<z.ZodObject<{
-        bucketSlug: z.ZodString;
-        excerpt: z.ZodString;
-        coarseCategory: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type FunctionMonitoringAnnotation = z.infer<typeof functionMonitoringAnnotationSchema>;
+export { functionMonitoringAnnotationSchema } from "@sequenceholdings/platform/contracts";
+export type { MonitoringJson, FunctionMonitoringAnnotation, } from "@sequenceholdings/platform/contracts";

package/dist/monitoring-annotations.js

@@ -1,54 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.functionMonitoringAnnotationSchema = void 0;
-const zod_1 = require("zod");
-function boundedJson(value, depth = 0) {
-    if (depth > 6)
-        return false;
-    if (value === null || typeof value === 'boolean')
-        return true;
-    if (typeof value === 'number')
-        return Number.isFinite(value);
-    if (typeof value === 'string')
-        return value.length <= 50_000;
-    if (Array.isArray(value)) {
-        if (Object.getPrototypeOf(value) !== Array.prototype || value.length > 100 || Object.getOwnPropertyNames(value).length !== value.length + 1 || Object.getOwnPropertySymbols(value).length > 0)
-            return false;
-        for (let index = 0; index < value.length; index++) {
-            const entry = Object.getOwnPropertyDescriptor(value, String(index));
-            if (!entry?.enumerable || !('value' in entry) || !boundedJson(entry.value, depth + 1))
-                return false;
-        }
-        return true;
-    }
-    if (typeof value !== 'object')
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    if ((prototype !== Object.prototype && prototype !== null) || Object.getOwnPropertySymbols(value).length > 0)
-        return false;
-    const entries = Object.entries(Object.getOwnPropertyDescriptors(value));
-    return entries.length <= 64 && entries.every(([key, entry]) => key.length <= 128 && entry.enumerable && 'value' in entry && boundedJson(entry.value, depth + 1));
-}
-const json = zod_1.z.custom(value => boundedJson(value) && Buffer.byteLength(JSON.stringify(value), 'utf8') <= 100_000, 'Expected bounded JSON metrics');
-const text = zod_1.z.string().max(50_000);
-const id = zod_1.z.string().min(1).max(512);
-const severity = zod_1.z.enum(['critical', 'high', 'medium', 'low']);
-const inputTag = zod_1.z.strictObject({ type: zod_1.z.string().min(1).max(128), value: zod_1.z.string().max(8_000) });
-exports.functionMonitoringAnnotationSchema = zod_1.z.strictObject({
-    sourceType: id,
-    sourceRef: zod_1.z.record(zod_1.z.string().min(1).max(128), zod_1.z.union([zod_1.z.string().max(8_000), zod_1.z.number().finite()])).refine(ref => Object.keys(ref).length > 0 && Object.keys(ref).length <= 64, 'Source references must be bounded and nonempty'),
-    generatingSubject: zod_1.z.strictObject({ subjectId: id, subjectKind: zod_1.z.enum(['agent', 'workflow']) }),
-    occurredAt: zod_1.z.iso.datetime({ offset: true }),
-    summary: text.nullable(),
-    metrics: json,
-    conversationFindings: zod_1.z.array(zod_1.z.strictObject({ type: id, description: text, excerpt: text, severity: zod_1.z.enum(['high', 'medium', 'low']) })).max(100),
-    classifications: zod_1.z.array(zod_1.z.strictObject({
-        matchedBucketSlug: id.nullable(),
-        newBucketProposal: zod_1.z.strictObject({ name: id, description: text, severity, category: id }).nullable(),
-        excerpt: text, inputTags: zod_1.z.array(inputTag).max(64),
-    }).refine(classification => (classification.matchedBucketSlug === null) !== (classification.newBucketProposal === null), 'Name exactly one matched bucket or proposal')).max(100),
-    coarseFallbacks: zod_1.z.array(zod_1.z.strictObject({ bucketSlug: id, excerpt: text, coarseCategory: id })).max(100),
-}).superRefine((annotation, context) => {
-    if (Buffer.byteLength(JSON.stringify(annotation), 'utf8') > 256 * 1024)
-        context.addIssue({ code: 'custom', message: 'Monitoring annotations exceed the size limit' });
-});
+var contracts_1 = require("@sequenceholdings/platform/contracts");
+Object.defineProperty(exports, "functionMonitoringAnnotationSchema", { enumerable: true, get: function () { return contracts_1.functionMonitoringAnnotationSchema; } });