@fungi.computer/braid 0.0.1 → 0.1.0

package/dist/cloudflare/graph-program.js

@@ -103,6 +103,9 @@ export async function runGraphWorkflow(step, params, instanceId, workflows, disp
         throw new NonRetryableError("invalid_input");
     const input = admitted.input;
     const iteration = checked.kind === "run" ? "0" : checked.iteration;
+    const position = checked.kind === "run" ? [] : checked.position;
+    /** Steps inside a loop say which item or round they belong to. */
+    const placed = (record) => position.length === 0 ? record : { ...record, position };
     const values = {};
     values.$input = input;
     const baseEvent = (node, state, attempt = 0, poll) => {
@@ -116,20 +119,21 @@ export async function runGraphWorkflow(step, params, instanceId, workflows, disp
         if (poll !== undefined)
             event = { ...event, poll };
         return checked.kind === "map-item"
-            ? { ...event, graphId: checked.body }
+            ? placed({ ...event, graphId: checked.body })
             : event;
     };
-    const complete = async (node, output, attempt = 0, costMilliunits = 0, durationMs = 0, poll) => {
+    const complete = async (node, output, attempt = 0, costMilliunits = 0, durationMs = 0, poll, row) => {
         const ports = { ...output, after: true };
         if (exceedsResultLimit(ports))
             return fail(node, "step_result_limit", undefined, poll);
-        await dispatcher.recordEvent({
+        const event = {
             ...baseEvent(node, "complete", attempt, poll),
             costMilliunits,
             durationMs,
             outputDigest: await contentDigest(ports),
             output,
-        });
+        };
+        await dispatcher.recordEvent(row === undefined ? event : { ...event, row });
         return ports;
     };
     const fail = async (node, code, cause, poll) => {
@@ -289,7 +293,7 @@ export async function runGraphWorkflow(step, params, instanceId, workflows, disp
                     if (ports === undefined)
                         return fail(node, "invalid_output", undefined, poll);
                     return {
-                        ports: await complete(node, ports, ctx.attempt, result.costMilliunits, Date.now() - start, poll),
+                        ports: await complete(node, ports, ctx.attempt, result.costMilliunits, Date.now() - start, poll, result.row),
                     };
                 });
                 // A pending App call is polled with the same idempotency key, within
@@ -331,7 +335,7 @@ export async function runGraphWorkflow(step, params, instanceId, workflows, disp
                 const eventType = "review_" +
                     (await contentDigest([instanceId, node.id, iteration])).slice(7);
                 const expiresAt = await step.do(name + ":pending", async () => {
-                    const deadline = await dispatcher.openReview({
+                    const deadline = await dispatcher.openReview(placed({
                         runId: checked.runId,
                         nodeId: node.id,
                         iteration,
@@ -342,7 +346,7 @@ export async function runGraphWorkflow(step, params, instanceId, workflows, disp
                         timeout: node.timeout,
                         show: node.show.map((ref) => readPort(values, ref) ?? null),
                         ...reviewChoices(node),
-                    });
+                    }));
                     await dispatcher.recordEvent(baseEvent(node, "waiting"));
                     return deadline;
                 });
@@ -404,6 +408,15 @@ export async function runGraphWorkflow(step, params, instanceId, workflows, disp
                             parentInstanceId: instanceId,
                             completionEvent: eventType,
                             input: { item, round, previous },
+                            position: [
+                                ...position,
+                                {
+                                    node: node.id,
+                                    loop: "repeat",
+                                    index: round,
+                                    count: node.maxRounds,
+                                },
+                            ],
                         };
                         try {
                             await workflows.create({ id: childId, params });
@@ -467,6 +480,15 @@ export async function runGraphWorkflow(step, params, instanceId, workflows, disp
                                         itemIndex,
                                     ])).slice(7),
                                 input: { item, index: itemIndex },
+                                position: [
+                                    ...position,
+                                    {
+                                        node: node.id,
+                                        loop: "map",
+                                        index: itemIndex,
+                                        count: list.length,
+                                    },
+                                ],
                             };
                             try {
                                 await workflows.create({ id: childId, params: childParams });

package/dist/compile.d.ts

@@ -19,6 +19,8 @@ export type DeclaredMethod = Readonly<{
     pending?: true | undefined;
     /** Discovery-only metadata from the App declaration; hidden methods have no graph ports. */
     hidden?: true | undefined;
+    /** Presentation is display metadata and never part of a method's graph contract. */
+    present?: object | undefined;
     description: string;
     input: object;
     output: object;

package/dist/compile.js

@@ -190,6 +190,12 @@ function completionView(method) {
     })(output);
     return Option.isSome(union) ? schemaView(union.value.anyOf[0]) : output;
 }
+/** The graph-facing contract of one method: no discovery or display metadata. */
+function graphContract(method) {
+    const { description, input, output, effect, requires } = method;
+    const contract = { description, input, output, effect, requires };
+    return method.pending === true ? { ...contract, pending: true } : contract;
+}
 /**
  * The catalog entry for one App's declared methods. The digest covers what a
  * node depends on (ports, effect, approval, requires), not the description, so
@@ -198,7 +204,9 @@ function completionView(method) {
  */
 export async function catalogMethods(methods) {
     const entries = await Promise.all(Object.entries(methods)
-        .flatMap(([name, { hidden, ...declared }]) => hidden === true ? [] : [[name, declared]])
+        .flatMap(([name, declared]) => declared.hidden === true
+        ? []
+        : [[name, graphContract(declared)]])
         .map(async ([name, declared]) => {
         const method = S.decodeUnknownSync(methodSchema)({
             ...declared,

package/dist/execution.d.ts

@@ -1,5 +1,25 @@
 import * as S from "effect/Schema";
 import type { ExecutionPlan, Json, Method } from "./schema.js";
+/**
+ * One loop a step runs inside: which Map item or Repeat round this pass is,
+ * counted from 0, of how many. The runtime knows both while it executes; the
+ * iteration id is a digest and says neither.
+ */
+export declare const loopPlaceSchema: S.Struct<{
+    readonly node: S.String;
+    readonly loop: S.Literals<readonly ["map", "repeat"]>;
+    readonly index: S.Number;
+    readonly count: S.Number;
+}>;
+export type LoopPlace = typeof loopPlaceSchema.Type;
+/** Outermost loop first. Nesting needs one loop node per level, so the 64-node graph bound holds. */
+export declare const loopPositionSchema: S.$Array<S.Struct<{
+    readonly node: S.String;
+    readonly loop: S.Literals<readonly ["map", "repeat"]>;
+    readonly index: S.Number;
+    readonly count: S.Number;
+}>>;
+export type LoopPosition = typeof loopPositionSchema.Type;
 export declare const graphParamsSchema: S.Union<readonly [S.Struct<{
     readonly kind: S.Literal<"run">;
     readonly teamId: S.String;
@@ -15,6 +35,12 @@ export declare const graphParamsSchema: S.Union<readonly [S.Struct<{
     readonly parentInstanceId: S.String;
     readonly completionEvent: S.String;
     readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+    readonly position: S.$Array<S.Struct<{
+        readonly node: S.String;
+        readonly loop: S.Literals<readonly ["map", "repeat"]>;
+        readonly index: S.Number;
+        readonly count: S.Number;
+    }>>;
 }>]>;
 export type GraphParams = typeof graphParamsSchema.Type;
 export declare const nodeEventSchema: S.Struct<{
@@ -22,6 +48,13 @@ export declare const nodeEventSchema: S.Struct<{
     readonly graphId: S.optionalKey<S.String>;
     readonly nodeId: S.String;
     readonly iteration: S.String;
+    /** The loops around this step; absent at the top of the run. */
+    readonly position: S.optionalKey<S.$Array<S.Struct<{
+        readonly node: S.String;
+        readonly loop: S.Literals<readonly ["map", "repeat"]>;
+        readonly index: S.Number;
+        readonly count: S.Number;
+    }>>>;
     readonly poll: S.optionalKey<S.Number>;
     readonly state: S.Literals<readonly ["queued", "running", "waiting", "complete", "failed", "skipped"]>;
     readonly attempt: S.Number;
@@ -31,6 +64,27 @@ export declare const nodeEventSchema: S.Struct<{
     readonly costMilliunits: S.optionalKey<S.Number>;
     readonly outputDigest: S.optionalKey<S.String>;
     readonly output: S.optionalKey<S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>>;
+    /** How the finished App call reads to a person; absent when the App declares no presentation. */
+    readonly row: S.optionalKey<S.Struct<{
+        readonly media: S.optional<S.Struct<{
+            readonly path: S.String;
+            readonly format: S.Literals<readonly ["fungi:image", "fungi:video"]>;
+        }>>;
+        readonly id: S.String;
+        readonly title: S.String;
+        readonly detail: S.optional<S.String>;
+        readonly tone: S.optional<S.Literals<readonly ["attention", "running", "error", "settled", "muted"]>>;
+        readonly status: S.optional<S.Struct<{
+            readonly label: S.String;
+            readonly tone: S.Literals<readonly ["neutral", "primary", "secondary", "accent", "success", "info", "warning", "error"]>;
+        }>>;
+        readonly open: S.optional<S.Struct<{
+            readonly params: S.$Array<S.Struct<{
+                readonly key: S.String;
+                readonly value: S.String;
+            }>>;
+        }>>;
+    }>>;
     readonly errorMessage: S.optionalKey<S.String>;
     readonly refusal: S.optionalKey<S.String>;
 }>;
@@ -39,6 +93,13 @@ export declare const graphReviewSchema: S.Struct<{
     readonly runId: S.String;
     readonly nodeId: S.String;
     readonly iteration: S.String;
+    /** The loops around this review; absent at the top of the run. */
+    readonly position: S.optionalKey<S.$Array<S.Struct<{
+        readonly node: S.String;
+        readonly loop: S.Literals<readonly ["map", "repeat"]>;
+        readonly index: S.Number;
+        readonly count: S.Number;
+    }>>>;
     readonly instanceId: S.String;
     readonly eventType: S.String;
     readonly title: S.String;
@@ -66,6 +127,26 @@ export declare const dispatchResultSchema: S.Union<readonly [S.Struct<{
     readonly kind: S.Literal<"complete">;
     readonly output: S.Codec<S.Json, S.Json, never, never>;
     readonly costMilliunits: S.Number;
+    readonly row: S.optionalKey<S.Struct<{
+        readonly media: S.optional<S.Struct<{
+            readonly path: S.String;
+            readonly format: S.Literals<readonly ["fungi:image", "fungi:video"]>;
+        }>>;
+        readonly id: S.String;
+        readonly title: S.String;
+        readonly detail: S.optional<S.String>;
+        readonly tone: S.optional<S.Literals<readonly ["attention", "running", "error", "settled", "muted"]>>;
+        readonly status: S.optional<S.Struct<{
+            readonly label: S.String;
+            readonly tone: S.Literals<readonly ["neutral", "primary", "secondary", "accent", "success", "info", "warning", "error"]>;
+        }>>;
+        readonly open: S.optional<S.Struct<{
+            readonly params: S.$Array<S.Struct<{
+                readonly key: S.String;
+                readonly value: S.String;
+            }>>;
+        }>>;
+    }>>;
 }>, S.Struct<{
     readonly kind: S.Literal<"refused">;
     readonly code: S.Literals<readonly ["not_granted", "invalid_input", "invalid_output", "revoked", "member_revoked", "workflow_run_revoked", "computer_revoked", "budget_exhausted", "unknown_method"]>;

package/dist/execution.js

@@ -1,6 +1,20 @@
 import * as S from "effect/Schema";
+import { resultRowSchemaV1 } from "@fungi.computer/gills";
 const id = S.String.pipe(S.check(S.isMinLength(1)), S.check(S.isMaxLength(256)));
 const natural = S.Number.pipe(S.check(S.isInt()), S.check(S.isGreaterThanOrEqualTo(0)));
+/**
+ * One loop a step runs inside: which Map item or Repeat round this pass is,
+ * counted from 0, of how many. The runtime knows both while it executes; the
+ * iteration id is a digest and says neither.
+ */
+export const loopPlaceSchema = S.Struct({
+    node: id,
+    loop: S.Literals(["map", "repeat"]),
+    index: natural,
+    count: natural,
+});
+/** Outermost loop first. Nesting needs one loop node per level, so the 64-node graph bound holds. */
+export const loopPositionSchema = S.Array(loopPlaceSchema).check(S.isMaxLength(64));
 export const graphParamsSchema = S.Union([
     S.Struct({ kind: S.Literal("run"), teamId: id, runId: id, planDigest: id }),
     S.Struct({
@@ -13,6 +27,7 @@ export const graphParamsSchema = S.Union([
         parentInstanceId: id,
         completionEvent: id,
         input: S.JsonObject,
+        position: loopPositionSchema,
     }),
 ]);
 export const nodeEventSchema = S.Struct({
@@ -20,6 +35,8 @@ export const nodeEventSchema = S.Struct({
     graphId: S.optionalKey(id),
     nodeId: id,
     iteration: id,
+    /** The loops around this step; absent at the top of the run. */
+    position: S.optionalKey(loopPositionSchema),
     poll: S.optionalKey(natural),
     state: S.Literals([
         "queued",
@@ -36,6 +53,8 @@ export const nodeEventSchema = S.Struct({
     costMilliunits: S.optionalKey(natural),
     outputDigest: S.optionalKey(id),
     output: S.optionalKey(S.JsonObject),
+    /** How the finished App call reads to a person; absent when the App declares no presentation. */
+    row: S.optionalKey(resultRowSchemaV1),
     errorMessage: S.optionalKey(S.String.check(S.isMaxLength(1024))),
     refusal: S.optionalKey(id),
 });
@@ -43,6 +62,8 @@ export const graphReviewSchema = S.Struct({
     runId: id,
     nodeId: id,
     iteration: id,
+    /** The loops around this review; absent at the top of the run. */
+    position: S.optionalKey(loopPositionSchema),
     instanceId: id,
     eventType: id,
     title: S.String,
@@ -89,6 +110,7 @@ export const dispatchResultSchema = S.Union([
         kind: S.Literal("complete"),
         output: S.Json,
         costMilliunits: natural,
+        row: S.optionalKey(resultRowSchemaV1),
     }),
     S.Struct({ kind: S.Literal("refused"), code: S.Literals(refusalCodes) }),
     S.Struct({ kind: S.Literal("pending_approval"), actionId: id }),

package/dist/git-access.d.ts

@@ -3,46 +3,46 @@ import { z } from "zod";
 export declare const workflowBindingSchema: z.ZodUnion<readonly [z.ZodObject<{
     appId: z.ZodString;
     installationId: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
+}, z.core.$strict>, z.ZodLazy<z.ZodObject<{
     kind: z.ZodLiteral<"team-source">;
-}, z.core.$strict>]>;
+}, z.core.$strict>>]>;
 /** Installation selections are admitted through the host's catalog before compilation. */
-export declare const bindingsSelectionSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+export declare const bindingsSelectionSchema: z.ZodRecord<z.ZodLazy<z.ZodString>, z.ZodUnion<readonly [z.ZodString, z.ZodLazy<z.ZodObject<{
     kind: z.ZodLiteral<"team-source">;
-}, z.core.$strict>]>>;
+}, z.core.$strict>>]>>;
 export type BindingsSelection = z.output<typeof bindingsSelectionSchema>;
 /** Published node declaration: a write branch ceiling or a read-only scope. */
 export declare const gitAccessSchema: z.ZodUnion<readonly [z.ZodObject<{
-    binding: z.ZodString;
+    binding: z.ZodLazy<z.ZodString>;
     repository: z.ZodString;
-    branches: z.ZodArray<z.ZodString>;
+    branches: z.ZodLazy<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>, z.ZodObject<{
-    binding: z.ZodString;
+    binding: z.ZodLazy<z.ZodString>;
     repository: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"$trigger.repository">]>;
     access: z.ZodLiteral<"read">;
 }, z.core.$strict>]>;
 /** Host-resolved scope carried to a process; data alone never grants this authority. */
-export declare const resolvedGitAccessSchema: z.ZodUnion<readonly [z.ZodObject<{
-    repository: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const resolvedGitAccessSchema: z.ZodLazy<z.ZodUnion<readonly [z.ZodObject<{
+    repository: z.ZodLazy<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"installation">;
         installationId: z.ZodString;
         repository: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"team-source">;
         repository: z.ZodString;
-    }, z.core.$strict>], "kind">;
-    branches: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "kind">>;
+    branches: z.ZodLazy<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>, z.ZodObject<{
-    repository: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    repository: z.ZodLazy<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"installation">;
         installationId: z.ZodString;
         repository: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"team-source">;
         repository: z.ZodString;
-    }, z.core.$strict>], "kind">;
+    }, z.core.$strict>], "kind">>;
     access: z.ZodLiteral<"read">;
-}, z.core.$strict>]>;
+}, z.core.$strict>]>>;
 export type GitAccess = z.infer<typeof gitAccessSchema>;
 export type ResolvedGitAccess = z.infer<typeof resolvedGitAccessSchema>;
 /** The Git scope a pass for this resolved access admits. */

package/dist/git-access.js

@@ -4,13 +4,13 @@ const repository = z
     .string()
     .regex(/^[a-zA-Z0-9._-]{1,128}$/)
     .refine((value) => value !== "." && value !== "..");
-const bindingName = z
+const bindingName = z.lazy(() => z
     .string()
     .min(1)
     .max(80)
-    .regex(/^[A-Za-z][A-Za-z0-9_-]*$/);
+    .regex(/^[A-Za-z][A-Za-z0-9_-]*$/));
 const identity = z.string().min(1).max(256);
-const teamSourceBinding = z.strictObject({ kind: z.literal("team-source") });
+const teamSourceBinding = z.lazy(() => z.strictObject({ kind: z.literal("team-source") }));
 /** Frozen installation identity or explicit registered Team-source namespace. */
 export const workflowBindingSchema = z.union([
     z.strictObject({ appId: identity, installationId: identity }),
@@ -30,11 +30,11 @@ const branch = z
     value
         .split("/")
         .every((part) => !part.startsWith(".") && !part.endsWith(".lock")));
-const branches = z
+const branches = z.lazy(() => z
     .array(branch)
     .min(1)
     .max(256)
-    .refine((values) => new Set(values).size === values.length, "Branches must be unique");
+    .refine((values) => new Set(values).size === values.length, "Branches must be unique"));
 /** Write access names a fixed repository and its exact branch ceiling, admitted at arm time. */
 const writeGitAccessSchema = z.strictObject({
     binding: bindingName,
@@ -57,13 +57,13 @@ export const gitAccessSchema = z.union([
     readGitAccessSchema,
 ]);
 /** Host-resolved scope carried to a process; data alone never grants this authority. */
-export const resolvedGitAccessSchema = z.union([
+export const resolvedGitAccessSchema = z.lazy(() => z.union([
     z.strictObject({ repository: repositoryRefSchema, branches }),
     z.strictObject({
         repository: repositoryRefSchema,
         access: z.literal("read"),
     }),
-]);
+]));
 /** The Git scope a pass for this resolved access admits. */
 export function gitAccessScope(access) {
     return "access" in access ? access.access : "write";

package/dist/index.d.ts

@@ -6,3 +6,4 @@ export * from "./compile.js";
 export * from "./triggers.js";
 export * from "./execution.js";
 export * from "./workflow-id.js";
+export * from "./review-text.js";

package/dist/index.js

@@ -6,3 +6,4 @@ export * from "./compile.js";
 export * from "./triggers.js";
 export * from "./execution.js";
 export * from "./workflow-id.js";
+export * from "./review-text.js";

package/dist/review-text.d.ts

@@ -0,0 +1,15 @@
+import type { LoopPosition } from "./execution.js";
+/**
+ * The words a review's `detail` and choice descriptions may ask for, filled
+ * from the loops around the review: the innermost Map gives the item, the
+ * innermost Repeat the try. Each counts from 1, as a person does.
+ */
+export declare const reviewTextPlaceholders: readonly ["item", "items", "try", "tries"];
+/** Placeholder names in `text` that no review can fill. */
+export declare function unknownReviewPlaceholders(text: string): string[];
+/**
+ * Fill a review's text from where it runs. Text whose placeholders the
+ * position cannot fill (a `{try}` outside any Repeat) is not shown at all,
+ * rather than shown with a hole or a guess.
+ */
+export declare function fillReviewText(text: string, position?: LoopPosition): string | undefined;

package/dist/review-text.js

@@ -0,0 +1,40 @@
+/**
+ * The words a review's `detail` and choice descriptions may ask for, filled
+ * from the loops around the review: the innermost Map gives the item, the
+ * innermost Repeat the try. Each counts from 1, as a person does.
+ */
+export const reviewTextPlaceholders = [
+    "item",
+    "items",
+    "try",
+    "tries",
+];
+const placeholder = /\{([A-Za-z]+)\}/g;
+const known = (name) => reviewTextPlaceholders.some((candidate) => candidate === name);
+/** Placeholder names in `text` that no review can fill. */
+export function unknownReviewPlaceholders(text) {
+    return [...text.matchAll(placeholder)].flatMap(([, name = ""]) => known(name) ? [] : [name]);
+}
+/**
+ * Fill a review's text from where it runs. Text whose placeholders the
+ * position cannot fill (a `{try}` outside any Repeat) is not shown at all,
+ * rather than shown with a hole or a guess.
+ */
+export function fillReviewText(text, position = []) {
+    const map = position.findLast((place) => place.loop === "map");
+    const repeat = position.findLast((place) => place.loop === "repeat");
+    const values = {
+        item: map === undefined ? undefined : map.index + 1,
+        items: map?.count,
+        try: repeat === undefined ? undefined : repeat.index + 1,
+        tries: repeat?.count,
+    };
+    const valueOf = (name) => (known(name) ? values[name] : undefined);
+    const names = [...text.matchAll(placeholder)].map(([, name = ""]) => name);
+    if (names.some((name) => valueOf(name) === undefined))
+        return undefined;
+    return text.replace(placeholder, (whole, name) => {
+        const value = valueOf(name);
+        return value === undefined ? whole : String(value);
+    });
+}

package/dist/runtime/arming-authority.d.ts

@@ -15,7 +15,7 @@ export declare const workflowArmedViaSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
 /** Provenance from the actual connector or approved-policy owner. */
 export type WorkflowArmedVia = z.output<typeof workflowArmedViaSchema>;
 /** The grantor stays the armer; decoding this shape alone grants no authority. */
-export declare const workflowArmingReceiptSchema: z.ZodObject<{
+export declare const workflowArmingReceiptSchema: z.ZodLazy<z.ZodObject<{
     armedBy: z.ZodString;
     armedVia: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"connector">;
@@ -28,12 +28,12 @@ export declare const workflowArmingReceiptSchema: z.ZodObject<{
         policyRevision: z.ZodString;
         grantorMemberId: z.ZodString;
     }, z.core.$strict>], "kind">>;
-    grantorMembershipVersion: z.ZodNumber;
-}, z.core.$strict>;
+    grantorMembershipVersion: z.ZodLazy<z.ZodNumber>;
+}, z.core.$strict>>;
 /** Captured by a host after current frame, installation and member admission. */
 export type WorkflowArmingReceipt = z.output<typeof workflowArmingReceiptSchema>;
 /** Current host-owner readback, after live grantor and approval checks. */
-export declare const workflowArmingAccessSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const workflowArmingAccessSchema: z.ZodLazy<z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"connector">;
     agentId: z.ZodString;
     attachmentId: z.ZodString;
@@ -52,7 +52,7 @@ export declare const workflowArmingAccessSchema: z.ZodDiscriminatedUnion<[z.ZodO
         write: "write";
         read: "read";
     }>;
-}, z.core.$strict>], "kind">;
+}, z.core.$strict>], "kind">>;
 /** The actual source identity plus its currently approved access level. */
 export type WorkflowArmingAccess = z.output<typeof workflowArmingAccessSchema>;
 /** Lookup keys exclude captured versions, revisions and grantors. */

package/dist/runtime/arming-authority.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { decodeWorkflowRunMember } from "./run-member.js";
 const identity = z.string().min(1).max(256);
-const membershipVersion = z.number().int().nonnegative();
+const membershipVersion = z.lazy(() => z.number().int().nonnegative());
 const connector = z.strictObject({
     kind: z.literal("connector"),
     agentId: identity,
@@ -21,7 +21,7 @@ export const workflowArmedViaSchema = z.discriminatedUnion("kind", [
     policy,
 ]);
 /** The grantor stays the armer; decoding this shape alone grants no authority. */
-export const workflowArmingReceiptSchema = z
+export const workflowArmingReceiptSchema = z.lazy(() => z
     .strictObject({
     armedBy: identity,
     /** A human arm has an explicit null; Agent arms retain their actual live source. */
@@ -36,15 +36,15 @@ export const workflowArmingReceiptSchema = z
             path: ["armedVia", "grantorMemberId"],
             message: "The approved policy grantor must be the armer",
         });
-});
+}));
 /** Current host-owner readback, after live grantor and approval checks. */
-export const workflowArmingAccessSchema = z.discriminatedUnion("kind", [
+export const workflowArmingAccessSchema = z.lazy(() => z.discriminatedUnion("kind", [
     connector.extend({
         grantorMemberId: identity,
         level: z.enum(["read", "write"]),
     }),
     policy.extend({ level: z.enum(["read", "write"]) }),
-]);
+]));
 /** Recheck Agent authority only; the host also admits member, Computer and installation grants. */
 export async function recheckWorkflowArming(receipt, ports) {
     const captured = workflowArmingReceiptSchema.safeParse(receipt);

package/dist/runtime/git-pass-contract.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import type { GitWriter } from "@fungi.computer/agar/git";
 /** Non-secret Team-issued authority for one stored Workflow step on its pinned Computer. */
-export declare const workflowGitPassGrantSchema: z.ZodObject<{
+export declare const workflowGitPassGrantSchema: z.ZodLazy<z.ZodObject<{
     teamId: z.ZodString;
     computerId: z.ZodString;
     memberId: z.ZodString;
@@ -28,29 +28,29 @@ export declare const workflowGitPassGrantSchema: z.ZodObject<{
         write: "write";
         read: "read";
     }>;
-    gitAccess: z.ZodUnion<readonly [z.ZodObject<{
-        repository: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    gitAccess: z.ZodLazy<z.ZodUnion<readonly [z.ZodObject<{
+        repository: z.ZodLazy<z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<"installation">;
             installationId: z.ZodString;
             repository: z.ZodString;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"team-source">;
             repository: z.ZodString;
-        }, z.core.$strict>], "kind">;
-        branches: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "kind">>;
+        branches: z.ZodLazy<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>, z.ZodObject<{
-        repository: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        repository: z.ZodLazy<z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<"installation">;
             installationId: z.ZodString;
             repository: z.ZodString;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"team-source">;
             repository: z.ZodString;
-        }, z.core.$strict>], "kind">;
+        }, z.core.$strict>], "kind">>;
         access: z.ZodLiteral<"read">;
-    }, z.core.$strict>]>;
+    }, z.core.$strict>]>>;
     triggerId: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 export type WorkflowGitPassGrant = z.output<typeof workflowGitPassGrantSchema>;
 /** Run cleanup remains valid after the Computer's product data is erased. */
 export declare const workflowGitPassRevocationSchema: z.ZodObject<{

package/dist/runtime/git-pass-contract.js

@@ -3,7 +3,7 @@ import { workflowAttestationSchema } from "@fungi.computer/puffball/app-method-r
 import { gitAccessScope, resolvedGitAccessSchema } from "../git-access.js";
 const id = z.string().min(1).max(256);
 /** Non-secret Team-issued authority for one stored Workflow step on its pinned Computer. */
-export const workflowGitPassGrantSchema = z
+export const workflowGitPassGrantSchema = z.lazy(() => z
     .strictObject({
     teamId: id,
     computerId: id,
@@ -17,7 +17,7 @@ export const workflowGitPassGrantSchema = z
     gitAccess: resolvedGitAccessSchema,
     triggerId: id.optional(),
 })
-    .refine((grant) => grant.scope === gitAccessScope(grant.gitAccess), "A pass's scope is its admitted Git access");
+    .refine((grant) => grant.scope === gitAccessScope(grant.gitAccess), "A pass's scope is its admitted Git access"));
 /** Run cleanup remains valid after the Computer's product data is erased. */
 export const workflowGitPassRevocationSchema = z.strictObject({
     teamId: id,