@fungi.computer/workflows-wire 0.0.1 → 0.2.0

package/docs/api/README.md

@@ -0,0 +1,2445 @@
+<!-- Generated by Botanical API docs (TypeDoc + typedoc-plugin-markdown). Do not edit. -->
+
+**@fungi.computer/workflows-wire**
+
+---
+
+# @fungi.computer/workflows-wire
+
+## Type Aliases
+
+### WorkflowPublishedDefinitionContext
+
+```ts
+type WorkflowPublishedDefinitionContext = Pick<
+  WorkflowPublicationContext,
+  "installationId" | "git"
+>;
+```
+
+The installation identity and Git access read from the Workflow publication
+context.
+
+---
+
+### WorkflowPublishedReader
+
+```ts
+type WorkflowPublishedReader = Readonly<{
+  published: Promise<Readonly<{
+    definition: WorkflowDefinition;
+    commit: string;
+    version: number | null;
+  }> | null>;
+}>;
+```
+
+How a host reads one published Workflow definition back out of Git. The Trellis
+App owns the Git layout (drafts, versions, the copy index); this port only wraps
+that read into the braid-shaped `PublishedDefinition`.
+
+---
+
+### WorkflowRunListItem
+
+```ts
+type WorkflowRunListItem = z.output<typeof runListItemSchema>;
+```
+
+Decoded run row with its pinned publication and display metadata.
+
+---
+
+### ViewerReply
+
+```ts
+type ViewerReply = z.output<typeof viewerReplySchema>;
+```
+
+Calling member identity, or a refusal returned by the viewer read.
+
+---
+
+### RunDelivery
+
+```ts
+type RunDelivery = z.output<typeof runDeliverySchema>;
+```
+
+Agent and Session selected to receive run endings.
+
+---
+
+### WorkflowTriggerTarget
+
+```ts
+type WorkflowTriggerTarget = z.output<typeof triggerTargetSchema>;
+```
+
+Published trigger, pinned commit, selected bindings and optional run delivery.
+
+---
+
+### WorkflowTriggerArmTarget
+
+```ts
+type WorkflowTriggerArmTarget = WorkflowTriggerTarget &
+  Readonly<{
+    digest: string;
+  }>;
+```
+
+Host binding input carries the App-owned immutable row digest, never caller
+input.
+
+---
+
+### WorkflowDraft
+
+```ts
+type WorkflowDraft = typeof workflowDraftSchema.Type;
+```
+
+One Workflow file's decoded content.
+
+---
+
+### WorkflowDocument
+
+```ts
+type WorkflowDocument = WorkflowDraft & object;
+```
+
+A Workflow file's content at the commit it was read from.
+
+#### Type Declaration
+
+| Name     | Type     | Description                                        |
+| -------- | -------- | -------------------------------------------------- |
+| `commit` | `string` | Exact Git commit from which the document was read. |
+
+---
+
+### WorkflowReadGit
+
+```ts
+type WorkflowReadGit = Pick<GitBinding, "readCommit" | "readTree" | "readBlob">;
+```
+
+Read-only Git operations needed to traverse and decode library files.
+
+## Variables
+
+### provenanceSchema
+
+```ts
+const provenanceSchema: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodObject<
+        {
+          kind: ZodLiteral<"import">;
+          workflowId: ZodString;
+          version: ZodNumber;
+          commit: ZodString;
+          sha256: ZodString &
+            ZodType<
+              string & object,
+              string,
+              $ZodTypeInternals<string & object, string>
+            >;
+          origin: ZodOptional<ZodString>;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          kind: ZodLiteral<"fork">;
+          workflowId: ZodString;
+          commit: ZodString;
+        },
+        $strict
+      >,
+    ]
+  >
+>;
+```
+
+Source Workflow and commit recorded when importing or forking a document.
+
+---
+
+### runBase
+
+```ts
+const runBase: ZodObject<
+  {
+    requestId: ZodString;
+    workflowId: ZodString;
+    bindings: ZodRecord<
+      ZodLazy<ZodString>,
+      ZodUnion<
+        readonly [
+          ZodString,
+          ZodLazy<
+            ZodObject<
+              {
+                kind: ZodLiteral<"team-source">;
+              },
+              $strict
+            >
+          >,
+        ]
+      >
+    >;
+    input: ZodRecord<ZodString, ZodJSONSchema>;
+    delivery: ZodOptional<
+      ZodObject<
+        {
+          agentId: ZodString;
+          sessionId: ZodString;
+        },
+        $strict
+      >
+    >;
+  },
+  $strict
+>;
+```
+
+Shared run request fields: identity, bindings, JSON input and optional delivery.
+
+---
+
+### publishedRun
+
+```ts
+const publishedRun: ZodLazy<ZodUnion<readonly [ZodObject<{
+  requestId: ZodString;
+  workflowId: ZodString;
+  bindings: ZodRecord<ZodLazy<ZodString>, ZodUnion<readonly [ZodString, ZodLazy<ZodObject<{
+     kind: ...;
+  }, $strict>>]>>;
+  input: ZodRecord<ZodString, ZodJSONSchema>;
+  delivery: ZodOptional<ZodObject<{
+     agentId: ZodString;
+     sessionId: ZodString;
+  }, $strict>>;
+  version: ZodNumber;
+}, $strict>, ZodObject<{
+  requestId: ZodString;
+  workflowId: ZodString;
+  bindings: ZodRecord<ZodLazy<ZodString>, ZodUnion<readonly [ZodString, ZodLazy<ZodObject<{
+     kind: ...;
+  }, $strict>>]>>;
+  input: ZodRecord<ZodString, ZodJSONSchema>;
+  delivery: ZodOptional<ZodObject<{
+     agentId: ZodString;
+     sessionId: ZodString;
+  }, $strict>>;
+  commit: ZodString;
+}, $strict>]>>;
+```
+
+Run request pinned to either a published version or an exact Git commit.
+
+---
+
+### document
+
+```ts
+const document: ZodObject<{
+  provenance: ZodOptional<ZodLazy<ZodUnion<readonly [ZodObject<{
+     kind: ZodLiteral<"import">;
+     workflowId: ZodString;
+     version: ZodNumber;
+     commit: ZodString;
+     sha256: ZodString & ZodType<... & ..., string, $ZodTypeInternals<..., ...>>;
+     origin: ZodOptional<ZodString>;
+   }, $strict>, ZodObject<{
+     kind: ZodLiteral<"fork">;
+     workflowId: ZodString;
+     commit: ZodString;
+  }, $strict>]>>>;
+  definition: ZodRecord<ZodString, ZodJSONSchema>;
+  layout: ZodRecord<ZodString, ZodObject<{
+     x: ZodNumber;
+     y: ZodNumber;
+  }, $strict>>;
+  commit: ZodString;
+}, $strict>;
+```
+
+Wire document containing definition, node layout, provenance and commit.
+
+---
+
+### revisionSchema
+
+```ts
+const revisionSchema: ZodNumber;
+```
+
+Nonnegative revision used to fence draft replacements.
+
+---
+
+### draftDocument
+
+```ts
+const draftDocument: ZodObject<{
+  provenance: ZodOptional<ZodLazy<ZodUnion<readonly [ZodObject<{
+     kind: ZodLiteral<"import">;
+     workflowId: ZodString;
+     version: ZodNumber;
+     commit: ZodString;
+     sha256: ZodString & ZodType<... & ..., string, $ZodTypeInternals<..., ...>>;
+     origin: ZodOptional<ZodString>;
+   }, $strict>, ZodObject<{
+     kind: ZodLiteral<"fork">;
+     workflowId: ZodString;
+     commit: ZodString;
+  }, $strict>]>>>;
+  definition: ZodRecord<ZodString, ZodJSONSchema>;
+  layout: ZodRecord<ZodString, ZodObject<{
+     x: ZodNumber;
+     y: ZodNumber;
+  }, $strict>>;
+  revision: ZodNumber;
+}, $strict>;
+```
+
+Editable document with a draft revision instead of a published commit.
+
+---
+
+### publishedDocument
+
+```ts
+const publishedDocument: ZodObject<{
+  provenance: ZodOptional<ZodLazy<ZodUnion<readonly [ZodObject<{
+     kind: ZodLiteral<"import">;
+     workflowId: ZodString;
+     version: ZodNumber;
+     commit: ZodString;
+     sha256: ZodString & ZodType<... & ..., string, $ZodTypeInternals<..., ...>>;
+     origin: ZodOptional<ZodString>;
+   }, $strict>, ZodObject<{
+     kind: ZodLiteral<"fork">;
+     workflowId: ZodString;
+     commit: ZodString;
+  }, $strict>]>>>;
+  definition: ZodRecord<ZodString, ZodJSONSchema>;
+  layout: ZodRecord<ZodString, ZodObject<{
+     x: ZodNumber;
+     y: ZodNumber;
+  }, $strict>>;
+  commit: ZodString;
+  workflowId: ZodString;
+  version: ZodNumber;
+  digest: ZodString & ZodType<string & object, string, $ZodTypeInternals<string & object, string>>;
+}, $strict>;
+```
+
+Published document identified by Workflow, version, commit and content digest.
+
+---
+
+### saveReply
+
+```ts
+const saveReply: ZodUnion<readonly [ZodObject<{
+  kind: ZodLiteral<"saved">;
+  revision: ZodNumber;
+}, $strict>, ZodObject<{
+  kind: ZodLiteral<"conflict">;
+  current: ZodNullable<ZodObject<{
+     provenance: ZodOptional<ZodLazy<ZodUnion<readonly [..., ...]>>>;
+     definition: ZodRecord<ZodString, ZodJSONSchema>;
+     layout: ZodRecord<ZodString, ZodObject<{
+        x: ZodNumber;
+        y: ZodNumber;
+     }, $strict>>;
+     revision: ZodNumber;
+  }, $strict>>;
+}, $strict>, ZodObject<{
+  kind: ZodLiteral<"invalid">;
+  issues: ZodArray<ZodLazy<ZodObject<{
+     code: ZodString;
+     message: ZodString;
+     graph: ZodOptional<ZodString>;
+     node: ZodOptional<ZodString>;
+     trigger: ZodOptional<ZodString>;
+     port: ZodOptional<ZodString>;
+     edge: ZodOptional<ZodNumber>;
+  }, $strip>>>;
+}, $strict>]>;
+```
+
+Draft save result, including revision conflict or validation issues.
+
+---
+
+### shareReview
+
+```ts
+const shareReview: ZodObject<
+  {
+    gitAccess: ZodArray<
+      ZodUnion<
+        readonly [
+          ZodObject<
+            {
+              binding: ZodLazy<ZodString>;
+              repository: ZodString;
+              branches: ZodLazy<ZodArray<ZodString>>;
+              graph: ZodString;
+              node: ZodString;
+            },
+            $strict
+          >,
+          ZodObject<
+            {
+              binding: ZodLazy<ZodString>;
+              repository: ZodUnion<
+                readonly [ZodString, ZodLiteral<"$trigger.repository">]
+              >;
+              access: ZodLiteral<"read">;
+              graph: ZodString;
+              node: ZodString;
+            },
+            $strict
+          >,
+        ]
+      >
+    >;
+    writeNodes: ZodArray<
+      ZodObject<
+        {
+          graph: ZodString;
+          node: ZodString;
+          appId: ZodString;
+          method: ZodString;
+          effect: ZodEnum<{
+            write: "write";
+            external: "external";
+          }>;
+        },
+        $strict
+      >
+    >;
+    triggers: ZodArray<ZodJSONSchema>;
+  },
+  $strict
+>;
+```
+
+Share review listing Git access, write/external nodes and trigger configuration.
+
+---
+
+### shareCopyReply
+
+```ts
+const shareCopyReply: ZodLazy<ZodUnion<readonly [ZodObject<{
+  kind: ZodLiteral<"saved">;
+  revision: ZodNumber;
+  title: ZodString;
+  review: ZodObject<{
+     gitAccess: ZodArray<ZodUnion<readonly [ZodObject<..., ...>, ZodObject<..., ...>]>>;
+     writeNodes: ZodArray<ZodObject<{
+        graph: ZodString;
+        node: ZodString;
+        appId: ZodString;
+        method: ZodString;
+        effect: ZodEnum<...>;
+     }, $strict>>;
+     triggers: ZodArray<ZodJSONSchema>;
+  }, $strict>;
+}, $strict>, ZodObject<{
+  kind: ZodLiteral<"conflict">;
+  current: ZodNullable<ZodObject<{
+     provenance: ZodOptional<ZodLazy<ZodUnion<...>>>;
+     definition: ZodRecord<ZodString, ZodJSONSchema>;
+     layout: ZodRecord<ZodString, ZodObject<{
+        x: ...;
+        y: ...;
+     }, $strict>>;
+     revision: ZodNumber;
+  }, $strict>>;
+}, $strict>, ZodObject<{
+  kind: ZodLiteral<"invalid">;
+  issues: ZodArray<ZodLazy<ZodObject<{
+     code: ZodString;
+     message: ZodString;
+     graph: ZodOptional<ZodString>;
+     node: ZodOptional<ZodString>;
+     trigger: ZodOptional<ZodString>;
+     port: ZodOptional<ZodString>;
+     edge: ZodOptional<ZodNumber>;
+  }, $strip>>>;
+}, $strict>, ZodObject<{
+  kind: ZodLiteral<"missing_apps">;
+  appIds: ZodArray<ZodString>;
+}, $strict>, ZodObject<{
+  kind: ZodEnum<{
+     not_found: "not_found";
+     too_large: "too_large";
+     digest_mismatch: "digest_mismatch";
+     invalid_bundle: "invalid_bundle";
+  }>;
+}, $strict>]>>;
+```
+
+Import/fork result with the saved draft and review, or a typed refusal.
+
+---
+
+### shareExportReply
+
+```ts
+const shareExportReply: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodObject<
+        {
+          bytes: ZodString;
+          sha256: ZodString &
+            ZodType<
+              string & object,
+              string,
+              $ZodTypeInternals<string & object, string>
+            >;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          kind: ZodEnum<{
+            not_found: "not_found";
+            too_large: "too_large";
+          }>;
+        },
+        $strict
+      >,
+    ]
+  >
+>;
+```
+
+Exported bundle bytes and digest, or a missing/oversized bundle result.
+
+---
+
+### publicationIds
+
+```ts
+const publicationIds: Readonly<{
+  publication: IdCodec<"workflow-publication", "publication", 1>;
+}>;
+```
+
+Mint and validate identities for asynchronous Workflow publication attempts.
+
+---
+
+### publicationIdSchema
+
+```ts
+const publicationIdSchema: ZodLazy<
+  ZodString &
+    ZodType<
+      CairnId<"workflow-publication", "publication", 1>,
+      string,
+      $ZodTypeInternals<
+        CairnId<"workflow-publication", "publication", 1>,
+        string
+      >
+    >
+>;
+```
+
+Publication identity accepted by the maintained publication id family.
+
+---
+
+### publicationFailure
+
+```ts
+const publicationFailure: ZodEnum<{
+  too_large: "too_large";
+  git_conflict: "git_conflict";
+  publication_failed: "publication_failed";
+  access_changed: "access_changed";
+}>;
+```
+
+Publication failure categories returned by the host.
+
+---
+
+### publicationComplete
+
+```ts
+const publicationComplete: ZodLazy<
+  ZodObject<
+    {
+      kind: ZodLiteral<"published">;
+      commit: ZodString;
+      version: ZodNumber;
+    },
+    $strict
+  >
+>;
+```
+
+Completed publication's exact commit and assigned version.
+
+---
+
+### publicationPending
+
+```ts
+const publicationPending: ZodLazy<
+  ZodObject<
+    {
+      kind: ZodLiteral<"publishing">;
+      publicationId: ZodLazy<
+        ZodString &
+          ZodType<
+            CairnId<"workflow-publication", "publication", 1>,
+            string,
+            $ZodTypeInternals<
+              CairnId<"workflow-publication", "publication", 1>,
+              string
+            >
+          >
+      >;
+    },
+    $strict
+  >
+>;
+```
+
+Pending publication identified for subsequent status reads.
+
+---
+
+### publicationFailed
+
+```ts
+const publicationFailed: ZodLazy<
+  ZodObject<
+    {
+      kind: ZodLiteral<"failed">;
+      reason: ZodEnum<{
+        too_large: "too_large";
+        git_conflict: "git_conflict";
+        publication_failed: "publication_failed";
+        access_changed: "access_changed";
+      }>;
+    },
+    $strict
+  >
+>;
+```
+
+Failed publication and its typed failure reason.
+
+---
+
+### publicationStatus
+
+```ts
+const publicationStatus: ZodLazy<ZodUnion<readonly [ZodLazy<ZodObject<{
+  kind: ZodLiteral<"publishing">;
+  publicationId: ZodLazy<ZodString & ZodType<CairnId<"workflow-publication", "publication", 1>, string, $ZodTypeInternals<CairnId<..., ..., ...>, string>>>;
+}, $strict>>, ZodLazy<ZodObject<{
+  kind: ZodLiteral<"published">;
+  commit: ZodString;
+  version: ZodNumber;
+}, $strict>>, ZodLazy<ZodObject<{
+  kind: ZodLiteral<"failed">;
+  reason: ZodEnum<{
+     too_large: "too_large";
+     git_conflict: "git_conflict";
+     publication_failed: "publication_failed";
+     access_changed: "access_changed";
+  }>;
+}, $strict>>, ZodObject<{
+  kind: ZodLiteral<"not_found">;
+}, $strict>]>>;
+```
+
+Current publication outcome, including an unknown publication identity.
+
+---
+
+### publicationElsewhere
+
+```ts
+const publicationElsewhere: ZodLazy<
+  ZodObject<
+    {
+      kind: ZodLiteral<"publishing_elsewhere">;
+    },
+    $strict
+  >
+>;
+```
+
+Another publication attempt currently owns the publication operation.
+
+---
+
+### publishReply
+
+```ts
+const publishReply: ZodLazy<ZodUnion<readonly [ZodLazy<ZodObject<{
+  kind: ZodLiteral<"publishing_elsewhere">;
+}, $strict>>, ZodLazy<ZodObject<{
+  kind: ZodLiteral<"published">;
+  commit: ZodString;
+  version: ZodNumber;
+}, $strict>>, ZodLazy<ZodObject<{
+  kind: ZodLiteral<"publishing">;
+  publicationId: ZodLazy<ZodString & ZodType<CairnId<"workflow-publication", "publication", 1>, string, $ZodTypeInternals<CairnId<..., ..., ...>, string>>>;
+}, $strict>>, ZodLazy<ZodObject<{
+  kind: ZodLiteral<"failed">;
+  reason: ZodEnum<{
+     too_large: "too_large";
+     git_conflict: "git_conflict";
+     publication_failed: "publication_failed";
+     access_changed: "access_changed";
+  }>;
+}, $strict>>, ZodObject<{
+  kind: ZodLiteral<"conflict">;
+  head: ZodNullable<ZodString>;
+}, $strict>, ZodObject<{
+  kind: ZodLiteral<"invalid">;
+  issues: ZodArray<ZodLazy<ZodObject<{
+     code: ZodString;
+     message: ZodString;
+     graph: ZodOptional<ZodString>;
+     node: ZodOptional<ZodString>;
+     trigger: ZodOptional<ZodString>;
+     port: ZodOptional<ZodString>;
+     edge: ZodOptional<ZodNumber>;
+  }, $strip>>>;
+}, $strict>]>>;
+```
+
+Publication command result, including pending work, conflict or validation
+issues.
+
+---
+
+### version
+
+```ts
+const version: ZodObject<
+  {
+    version: ZodNumber;
+    commit: ZodString;
+    committedAt: ZodNumber;
+    message: ZodString;
+  },
+  $strict
+>;
+```
+
+Published version with commit identity, commit time and commit message.
+
+---
+
+### workflow
+
+```ts
+const workflow: ZodObject<
+  {
+    workflowId: ZodString;
+  },
+  $strict
+>;
+```
+
+Identify one Workflow within the library.
+
+---
+
+### listings
+
+```ts
+const listings: ZodLazy<
+  ZodArray<
+    ZodObject<
+      {
+        workflowId: ZodString;
+        title: ZodString;
+        draftRevision: ZodNullable<ZodNumber>;
+        published: ZodNullable<
+          ZodObject<
+            {
+              commit: ZodString;
+              version: ZodNullable<ZodNumber>;
+            },
+            $strict
+          >
+        >;
+      },
+      $strict
+    >
+  >
+>;
+```
+
+Bounded library rows with draft revision and optional published reference.
+
+---
+
+### history
+
+```ts
+const history: ZodArray<
+  ZodObject<
+    {
+      commit: ZodString;
+      committedAt: ZodNumber;
+      message: ZodString;
+    },
+    $strict
+  >
+>;
+```
+
+Bounded Git history rows without a published-version number.
+
+---
+
+### libraryPageInput
+
+```ts
+const libraryPageInput: ZodLazy<
+  ZodObject<
+    {
+      limit: ZodDefault<ZodNumber>;
+      after: ZodOptional<ZodString>;
+    },
+    $strict
+  >
+>;
+```
+
+A missing index is not an empty Git repository; only write paths reconstruct it.
+
+---
+
+### libraryPage
+
+```ts
+const libraryPage: ZodLazy<ZodObject<{
+  items: ZodLazy<ZodArray<ZodObject<{
+     workflowId: ZodString;
+     title: ZodString;
+     draftRevision: ZodNullable<ZodNumber>;
+     published: ZodNullable<ZodObject<{
+        commit: ZodString;
+        version: ZodNullable<...>;
+     }, $strict>>;
+  }, $strict>>>;
+  next: ZodOptional<ZodString>;
+}, $strict>>;
+```
+
+One library page with an optional exclusive cursor for the next page.
+
+---
+
+### libraryListing
+
+```ts
+const libraryListing: ZodLazy<ZodUnion<readonly [ZodLazy<ZodObject<{
+  items: ZodLazy<ZodArray<ZodObject<{
+     workflowId: ZodString;
+     title: ZodString;
+     draftRevision: ZodNullable<...>;
+     published: ZodNullable<...>;
+  }, $strict>>>;
+  next: ZodOptional<ZodString>;
+}, $strict>>, ZodObject<{
+  kind: ZodLiteral<"unindexed">;
+}, $strict>]>>;
+```
+
+Indexed library page, or an explicit indication that its index is missing.
+
+---
+
+### rebuilding
+
+```ts
+const rebuilding: ZodLazy<
+  ZodObject<
+    {
+      kind: ZodLiteral<"rebuilding">;
+    },
+    $strict
+  >
+>;
+```
+
+A missing screen copy needs an explicit foreground rebuild, never a hidden Git
+read.
+
+---
+
+### documentRead
+
+```ts
+const documentRead: ZodLazy<ZodUnion<readonly [ZodObject<{
+  provenance: ZodOptional<ZodLazy<ZodUnion<readonly [ZodObject<{
+     kind: ...;
+     workflowId: ...;
+     version: ...;
+     commit: ...;
+     sha256: ...;
+     origin: ...;
+   }, $strict>, ZodObject<{
+     kind: ...;
+     workflowId: ...;
+     commit: ...;
+  }, $strict>]>>>;
+  definition: ZodRecord<ZodString, ZodJSONSchema>;
+  layout: ZodRecord<ZodString, ZodObject<{
+     x: ZodNumber;
+     y: ZodNumber;
+  }, $strict>>;
+  revision: ZodNumber;
+}, $strict>, ZodObject<{
+  provenance: ZodOptional<ZodLazy<ZodUnion<readonly [ZodObject<{
+     kind: ...;
+     workflowId: ...;
+     version: ...;
+     commit: ...;
+     sha256: ...;
+     origin: ...;
+   }, $strict>, ZodObject<{
+     kind: ...;
+     workflowId: ...;
+     commit: ...;
+  }, $strict>]>>>;
+  definition: ZodRecord<ZodString, ZodJSONSchema>;
+  layout: ZodRecord<ZodString, ZodObject<{
+     x: ZodNumber;
+     y: ZodNumber;
+  }, $strict>>;
+  commit: ZodString;
+}, $strict>, ZodNull, ZodLazy<ZodObject<{
+  kind: ZodLiteral<"rebuilding">;
+}, $strict>>]>>;
+```
+
+Draft/published document read, absence, or an explicit copy-rebuild state.
+
+---
+
+### versionsRead
+
+```ts
+const versionsRead: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodArray<
+        ZodObject<
+          {
+            version: ZodNumber;
+            commit: ZodString;
+            committedAt: ZodNumber;
+            message: ZodString;
+          },
+          $strict
+        >
+      >,
+      ZodLazy<
+        ZodObject<
+          {
+            kind: ZodLiteral<"rebuilding">;
+          },
+          $strict
+        >
+      >,
+    ]
+  >
+>;
+```
+
+Published version rows, or an explicit copy-rebuild state.
+
+---
+
+### rebuildCopiesInput
+
+```ts
+const rebuildCopiesInput: ZodLazy<
+  ZodObject<
+    {
+      cursor: ZodNullable<ZodString>;
+      target: ZodOptional<
+        ZodObject<
+          {
+            workflowId: ZodString;
+            at: ZodObject<
+              {
+                commit: ZodString;
+              },
+              $strict
+            >;
+          },
+          $strict
+        >
+      >;
+    },
+    $strict
+  >
+>;
+```
+
+Bounded copy-rebuild continuation, optionally targeting one pinned document.
+
+---
+
+### rebuildCopiesReply
+
+```ts
+const rebuildCopiesReply: ZodLazy<
+  ZodObject<
+    {
+      done: ZodBoolean;
+      cursor: ZodNullable<ZodString>;
+    },
+    $strict
+  >
+>;
+```
+
+Copy-rebuild progress and the cursor needed to continue unfinished work.
+
+---
+
+### workflowIdSchema
+
+```ts
+const workflowIdSchema: ZodString;
+```
+
+Lowercase Workflow slug used by library files and host commands.
+
+---
+
+### catalogInputSchema
+
+```ts
+const catalogInputSchema: ZodLazy<
+  ZodObject<
+    {
+      installationId: ZodOptional<ZodString>;
+    },
+    $strict
+  >
+>;
+```
+
+Select the palette index, or one installation's complete port declarations.
+
+---
+
+### catalogReplySchema
+
+```ts
+const catalogReplySchema: ZodLazy<ZodUnion<readonly [ZodObject<{
+  apps: ZodArray<ZodLazy<ZodObject<{
+     installationId: ZodString;
+     appId: ZodString;
+     displayName: ZodString;
+     icon: ZodOptional<ZodString>;
+     capabilities: ZodOptional<ZodArray<...>>;
+     workflowPublishGranted: ZodOptional<ZodBoolean>;
+     workflowRunGranted: ZodOptional<ZodBoolean>;
+     methods: ZodRecord<ZodString, ZodLazy<...>>;
+     events: ZodOptional<ZodRecord<..., ...>>;
+  }, $strict>>>;
+}, $strict>, ZodObject<{
+  app: ZodLazy<ZodObject<{
+     installationId: ZodString;
+     appId: ZodString;
+     displayName: ZodString;
+     icon: ZodOptional<ZodString>;
+     capabilities: ZodOptional<ZodArray<ZodEnum<...>>>;
+     workflowPublishGranted: ZodOptional<ZodBoolean>;
+     workflowRunGranted: ZodOptional<ZodBoolean>;
+     methods: ZodRecord<ZodString, ZodJSONSchema>;
+     events: ZodOptional<ZodRecord<ZodString, ZodJSONSchema>>;
+  }, $strict>>;
+}, $strict>, ZodObject<{
+  error: ZodString;
+}, $strict>]>>;
+```
+
+App method declarations admitted by the host for the current invocation.
+
+---
+
+### workflowIssueSchema
+
+```ts
+const workflowIssueSchema: ZodLazy<
+  ZodObject<
+    {
+      code: ZodString;
+      message: ZodString;
+      graph: ZodOptional<ZodString>;
+      node: ZodOptional<ZodString>;
+      trigger: ZodOptional<ZodString>;
+      port: ZodOptional<ZodString>;
+      edge: ZodOptional<ZodNumber>;
+    },
+    $strip
+  >
+>;
+```
+
+Validation issue with optional graph, node, trigger, port or edge location.
+
+---
+
+### runReply
+
+```ts
+const runReply: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodObject<
+        {
+          kind: ZodEnum<{
+            started: "started";
+            replay: "replay";
+            conflict: "conflict";
+          }>;
+          runId: ZodString;
+          planDigest: ZodString;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          kind: ZodLiteral<"invalid">;
+          issues: ZodArray<
+            ZodLazy<
+              ZodObject<
+                {
+                  code: ZodString;
+                  message: ZodString;
+                  graph: ZodOptional<ZodString>;
+                  node: ZodOptional<ZodString>;
+                  trigger: ZodOptional<ZodString>;
+                  port: ZodOptional<ZodString>;
+                  edge: ZodOptional<ZodNumber>;
+                },
+                $strip
+              >
+            >
+          >;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          error: ZodString;
+        },
+        $strict
+      >,
+    ]
+  >
+>;
+```
+
+Run admission result, including replay/conflict, invalid input or refusal.
+
+---
+
+### cancelReplySchema
+
+```ts
+const cancelReplySchema: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodObject<
+        {
+          kind: ZodEnum<{
+            cancelled: "cancelled";
+            terminal: "terminal";
+          }>;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          kind: ZodLiteral<"refused">;
+          reason: ZodLiteral<"denied">;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          error: ZodString;
+        },
+        $strict
+      >,
+    ]
+  >
+>;
+```
+
+Cancellation result, an already-terminal run, or an authority refusal.
+
+---
+
+### runOutcomeSchema
+
+```ts
+const runOutcomeSchema: ZodEnum<{
+  cancelled: "cancelled";
+  terminal: "terminal";
+  active: "active";
+}>;
+```
+
+Lifecycle outcome reported for a Workflow run.
+
+---
+
+### statusReply
+
+```ts
+const statusReply: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodObject<
+        {
+          runId: ZodString;
+          planDigest: ZodString;
+          outcome: ZodEnum<{
+            cancelled: "cancelled";
+            terminal: "terminal";
+            active: "active";
+          }>;
+          title: ZodString;
+          events: ZodArray<ZodRecord<ZodString, ZodJSONSchema>>;
+          reviews: ZodArray<ZodRecord<ZodString, ZodJSONSchema>>;
+          status: ZodString;
+          output: ZodJSONSchema;
+          error: ZodJSONSchema;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          error: ZodString;
+        },
+        $strict
+      >,
+    ]
+  >
+>;
+```
+
+Bounded run status snapshot with events, reviews, output and error.
+
+---
+
+### answerReviewReply
+
+```ts
+const answerReviewReply: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodObject<
+        {
+          result: ZodEnum<{
+            invalid: "invalid";
+            denied: "denied";
+            accepted: "accepted";
+            not_waiting: "not_waiting";
+          }>;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          error: ZodString;
+        },
+        $strict
+      >,
+    ]
+  >
+>;
+```
+
+Result of answering a waiting run review, or an invocation refusal.
+
+---
+
+### scheduleArmReplySchema
+
+```ts
+const scheduleArmReplySchema: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodObject<
+        {
+          kind: ZodLiteral<"armed">;
+          scheduleId: ZodString;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          kind: ZodLiteral<"refused">;
+          reason: ZodString;
+          issues: ZodOptional<ZodArray<ZodJSONSchema>>;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          error: ZodString;
+        },
+        $strict
+      >,
+    ]
+  >
+>;
+```
+
+Schedule-trigger admission or its refusal details.
+
+---
+
+### triggerDisarmReplySchema
+
+```ts
+const triggerDisarmReplySchema: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodObject<
+        {
+          kind: ZodEnum<{
+            disarmed: "disarmed";
+            not_found: "not_found";
+          }>;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          error: ZodString;
+        },
+        $strict
+      >,
+    ]
+  >
+>;
+```
+
+Trigger disarm result, including an absent trigger or denied invocation.
+
+---
+
+### schedulesReplySchema
+
+```ts
+const schedulesReplySchema: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodObject<
+        {
+          schedules: ZodArray<
+            ZodObject<
+              {
+                scheduleId: ZodString;
+                installationId: ZodString;
+                workflowId: ZodString;
+                triggerId: ZodString;
+                nextDueAt: ZodNumber;
+                state: ZodEnum<{
+                  cancelled: "cancelled";
+                  active: "active";
+                  paused: "paused";
+                  finished: "finished";
+                }>;
+                lastError: ZodNullable<ZodString>;
+              },
+              $strict
+            >
+          >;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          error: ZodString;
+        },
+        $strict
+      >,
+    ]
+  >
+>;
+```
+
+Visible schedule-trigger rows with their next due time and lifecycle state.
+
+---
+
+### workflowRunSourceSchema
+
+```ts
+const workflowRunSourceSchema: ZodEnum<{
+  manual: "manual";
+  schedule: "schedule";
+  event: "event";
+  agent: "agent";
+  key: "key";
+}>;
+```
+
+Origin category recorded for a run: manual, schedule, event, Agent or key.
+
+---
+
+### workflowRunInitiatedBySchema
+
+```ts
+const workflowRunInitiatedBySchema: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodObject<
+        {
+          kind: ZodLiteral<"member">;
+          memberId: ZodString;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          kind: ZodLiteral<"agent">;
+          agentId: ZodString;
+          grantorMemberId: ZodString;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          kind: ZodLiteral<"key">;
+          keyId: ZodString;
+          grantorMemberId: ZodString;
+        },
+        $strict
+      >,
+    ]
+  >
+>;
+```
+
+The Agent Session (`sessionId`) stays host-side; the wire names only the
+Agent/key and its grantor.
+
+---
+
+### runsReplySchema
+
+```ts
+const runsReplySchema: ZodLazy<ZodUnion<readonly [ZodObject<{
+  runs: ZodArray<ZodObject<{
+     runId: ZodString;
+     workflowId: ZodString;
+     commit: ZodString;
+     source: ZodEnum<{
+        manual: "manual";
+        schedule: "schedule";
+        event: "event";
+        agent: "agent";
+        key: "key";
+     }>;
+     triggerId: ZodOptional<ZodString>;
+     initiatedBy: ZodLazy<ZodUnion<readonly [..., ..., ...]>>;
+     startedAt: ZodNumber;
+  }, $strict>>;
+}, $strict>, ZodObject<{
+  error: ZodString;
+}, $strict>]>>;
+```
+
+Bounded recent-run rows with their source, initiator and pinned commit.
+
+---
+
+### eventArmReplySchema
+
+```ts
+const eventArmReplySchema: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodObject<
+        {
+          kind: ZodLiteral<"armed">;
+          eventTriggerId: ZodString;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          kind: ZodLiteral<"refused">;
+          reason: ZodString;
+          issues: ZodOptional<ZodArray<ZodJSONSchema>>;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          error: ZodString;
+        },
+        $strict
+      >,
+    ]
+  >
+>;
+```
+
+Event-trigger admission or its refusal details.
+
+---
+
+### eventTriggersReplySchema
+
+```ts
+const eventTriggersReplySchema: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodObject<
+        {
+          eventTriggers: ZodArray<
+            ZodObject<
+              {
+                eventTriggerId: ZodString;
+                workflowId: ZodString;
+                triggerId: ZodString;
+                emitterInstallationId: ZodString;
+                event: ZodString;
+                state: ZodEnum<{
+                  active: "active";
+                  paused: "paused";
+                }>;
+                lastError: ZodNullable<ZodString>;
+              },
+              $strict
+            >
+          >;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          error: ZodString;
+        },
+        $strict
+      >,
+    ]
+  >
+>;
+```
+
+Visible event-trigger rows with emitter, event and current state.
+
+---
+
+### repositoryWorkflowSourceSchema
+
+```ts
+const repositoryWorkflowSourceSchema: Struct<{
+  appId: refine<AppId, String>;
+  installationId: String;
+  callerAppId: refine<AppId, String>;
+  callerSourceRevision: refine<SourceRevision, String>;
+}>;
+```
+
+A registered repository App as the host reports it to the calling installation:
+read-only identity from the source owner and the live caller. Hosts and Apps
+share this wire; an App never imports the host package for it. Reading it
+neither registers a repository nor selects or runs a Computer.
+
+---
+
+### runsInputSchema
+
+```ts
+const runsInputSchema: ZodLazy<
+  ZodObject<
+    {
+      workflowId: ZodOptional<ZodString>;
+    },
+    $strict
+  >
+>;
+```
+
+The App's `WORKFLOWS.runs` read, scoped to one Workflow when given.
+
+---
+
+### runListItemSchema
+
+```ts
+const runListItemSchema: ZodLazy<
+  ZodObject<
+    {
+      runId: ZodString;
+      workflowId: ZodString;
+      commit: ZodString;
+      version: ZodNullable<ZodNumber>;
+      startedAt: ZodNumber;
+      title: ZodNullable<ZodString>;
+      source: ZodEnum<{
+        manual: "manual";
+        schedule: "schedule";
+        event: "event";
+        agent: "agent";
+        key: "key";
+      }>;
+      triggerId: ZodOptional<ZodString>;
+      initiatedBy: ZodLazy<
+        ZodUnion<
+          readonly [
+            ZodObject<
+              {
+                kind: ZodLiteral<"member">;
+                memberId: ZodString;
+              },
+              $strict
+            >,
+            ZodObject<
+              {
+                kind: ZodLiteral<"agent">;
+                agentId: ZodString;
+                grantorMemberId: ZodString;
+              },
+              $strict
+            >,
+            ZodObject<
+              {
+                kind: ZodLiteral<"key">;
+                keyId: ZodString;
+                grantorMemberId: ZodString;
+              },
+              $strict
+            >,
+          ]
+        >
+      >;
+    },
+    $strict
+  >
+>;
+```
+
+One listed run, from the stored source of truth plus the App's own copy of the
+published document at `commit`; display metadata never comes from Git.
+
+---
+
+### viewerReplySchema
+
+```ts
+const viewerReplySchema: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodObject<
+        {
+          memberId: ZodString;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          error: ZodString;
+        },
+        $strict
+      >,
+    ]
+  >
+>;
+```
+
+The calling member's own id, so the Runs UI can tell its own runs from a
+teammate's (an owner now sees every run in the installation, not only their own)
+without guessing identity from the list itself.
+
+---
+
+### workflowRunRequestIds
+
+```ts
+const workflowRunRequestIds: Readonly<{
+  request: IdCodec<"agar-workflow-run", "request", 1>;
+}>;
+```
+
+Typed id codec for Workflow run requests: mint and validate `workflow_request_*`
+ids. Hosts derive run ids from the request.
+
+---
+
+### runDeliverySchema
+
+```ts
+const runDeliverySchema: ZodObject<
+  {
+    agentId: ZodString;
+    sessionId: ZodString;
+  },
+  $strict
+>;
+```
+
+The Agent Session (chat) that receives the ending of every run it covers.
+
+---
+
+### chatsReplySchema
+
+```ts
+const chatsReplySchema: ZodLazy<
+  ZodUnion<
+    readonly [
+      ZodObject<
+        {
+          chats: ZodArray<
+            ZodObject<
+              {
+                agentId: ZodString;
+                sessionId: ZodString;
+                title: ZodString;
+              },
+              $strict
+            >
+          >;
+        },
+        $strict
+      >,
+      ZodObject<
+        {
+          error: ZodLiteral<"not_granted">;
+        },
+        $strict
+      >,
+    ]
+  >
+>;
+```
+
+One chat the member may choose for run reports: an existing Agent Session.
+
+---
+
+### triggerTargetSchema
+
+```ts
+const triggerTargetSchema: ZodLazy<
+  ZodObject<
+    {
+      workflowId: ZodString;
+      commit: ZodString;
+      triggerId: ZodString;
+      bindings: ZodRecord<
+        ZodLazy<ZodString>,
+        ZodUnion<
+          readonly [
+            ZodString,
+            ZodLazy<
+              ZodObject<
+                {
+                  kind: ZodLiteral<"team-source">;
+                },
+                $strict
+              >
+            >,
+          ]
+        >
+      >;
+      delivery: ZodOptional<
+        ZodObject<
+          {
+            agentId: ZodString;
+            sessionId: ZodString;
+          },
+          $strict
+        >
+      >;
+    },
+    $strict
+  >
+>;
+```
+
+The published trigger supplies cadence or event matching; the host supplies
+authority scope.
+
+---
+
+### scheduleDisarmInputSchema
+
+```ts
+const scheduleDisarmInputSchema: ZodObject<
+  {
+    scheduleId: ZodString;
+  },
+  $strict
+>;
+```
+
+Identify the schedule-trigger registration to disarm.
+
+---
+
+### eventDisarmInputSchema
+
+```ts
+const eventDisarmInputSchema: ZodObject<
+  {
+    eventTriggerId: ZodString;
+  },
+  $strict
+>;
+```
+
+Identify the event-trigger registration to disarm.
+
+---
+
+### triggerListInputSchema
+
+```ts
+const triggerListInputSchema: ZodObject<{}, $strict>;
+```
+
+Trigger listing takes no caller-supplied filters.
+
+---
+
+### workflowLibraryRepository
+
+```ts
+const workflowLibraryRepository: "trellis" = "trellis";
+```
+
+The read side of a Workflows library's Git layout, shared by the Workflows App
+and the hosts that read its published definitions: one repository, `trellis`,
+one `workflows/<id>.json` file per Workflow (its definition plus `layout` and
+optional `provenance`), and one `<id>@v<n>` tag per published version on
+`main`'s ancestry.
+
+---
+
+### workflowDraftSchema
+
+```ts
+const workflowDraftSchema: Struct<{
+  definition: Struct<{
+     format: Literal<"fungi.workflow/v1">;
+     title: String;
+     description: optionalKey<String>;
+     apps: $Record<String, Struct<{
+        appId: String;
+        role: optionalKey<String>;
+     }>>;
+     subgraphs: optionalKey<$Record<String, Struct<{
+        input: $Record<String, Codec<Json, Json, never, never>>;
+        nodes: $Array<Union<readonly [..., ..., ..., ..., ..., ..., ..., ...]>>;
+        edges: $Array<Struct<{
+           from: ...;
+           to: ...;
+        }>>;
+        output: $Record<String, Struct<{
+           node: ...;
+           port: ...;
+        }>>;
+     }>>>;
+     triggers: optionalKey<$Array<Union<readonly [Struct<{
+        id: String;
+        on: Literal<...>;
+        title: optionalKey<...>;
+        when: optionalKey<...>;
+        input: optionalKey<...>;
+      }>, Struct<{
+        id: String;
+        on: Literal<...>;
+        title: optionalKey<...>;
+        cron: Struct<...>;
+        input: optionalKey<...>;
+      }>, Struct<{
+        id: String;
+        on: Literal<...>;
+        title: optionalKey<...>;
+        app: String;
+        event: String;
+        eventDigest: String;
+        when: optionalKey<...>;
+        input: optionalKey<...>;
+        repository: optionalKey<...>;
+     }>]>>>;
+     input: $Record<String, Codec<Json, Json, never, never>>;
+     nodes: $Array<Union<readonly [Struct<{
+        id: String;
+        kind: Literal<"code">;
+        source: String;
+        input: $Record<String, Codec<..., ..., ..., ...>>;
+        output: $Record<String, Codec<..., ..., ..., ...>>;
+        values: $Record<String, Codec<..., ..., ..., ...>>;
+      }>, Struct<{
+        id: String;
+        kind: Literal<"app">;
+        app: String;
+        method: String;
+        methodDigest: String;
+        values: $Record<String, Codec<..., ..., ..., ...>>;
+        gitAccess: optionalKey<declare<..., ...>>;
+        retry: optionalKey<Struct<...>>;
+      }>, Struct<{
+        id: String;
+        kind: Literal<"review">;
+        title: String;
+        detail: optionalKey<String>;
+        show: $Array<Struct<...>>;
+        reviewers: Literals<readonly [..., ...]>;
+        timeout: Number;
+        choices: optionalKey<$Array<...>>;
+      }>, Struct<{
+        id: String;
+        kind: Literal<"condition">;
+        test: Codec<Predicate, Predicate, never, never>;
+      }>, Struct<{
+        id: String;
+        kind: Literal<"map">;
+        over: Struct<{
+           node: ...;
+           port: ...;
+        }>;
+        body: String;
+        concurrency: Number;
+        maxItems: Number;
+      }>, Struct<{
+        id: String;
+        kind: Literal<"repeat">;
+        body: String;
+        maxRounds: Number;
+        until: Codec<Predicate, Predicate, never, never>;
+      }>, Struct<{
+        id: String;
+        kind: Literal<"wait">;
+        for: Number;
+      }>, Struct<{
+        id: String;
+        kind: Literal<"transform">;
+        fields: $Record<String, Codec<..., ..., ..., ...>>;
+     }>]>>;
+     edges: $Array<Struct<{
+        from: Struct<{
+           node: Union<readonly [..., ...]>;
+           port: String;
+        }>;
+        to: Struct<{
+           node: Union<readonly [..., ...]>;
+           port: String;
+        }>;
+     }>>;
+     output: $Record<String, Struct<{
+        node: Union<readonly [String, Literals<readonly [..., ...]>]>;
+        port: String;
+     }>>;
+  }>;
+  layout: $Record<String, Struct<{
+     x: Finite;
+     y: Finite;
+  }>>;
+  provenance: optionalKey<declare<
+     | {
+     kind: "import";
+     workflowId: string;
+     version: number;
+     commit: string;
+     sha256: string & object;
+     origin?: string;
+   }
+     | {
+     kind: "fork";
+     workflowId: string;
+     commit: string;
+   },
+     | {
+     kind: "import";
+     workflowId: string;
+     version: number;
+     commit: string;
+     sha256: string & object;
+     origin?: string;
+   }
+     | {
+     kind: "fork";
+     workflowId: string;
+     commit: string;
+  }>>;
+}>;
+```
+
+Decode stored definition, node layout and optional import/fork provenance.
+
+## Functions
+
+### createWorkflowPublishedDefinitionPort()
+
+```ts
+function createWorkflowPublishedDefinitionPort(
+  createReader,
+): PublishedDefinitionPort<WorkflowPublishedDefinitionContext>;
+```
+
+Trigger arm verification uses current admitted Git; direct starts carry the
+App's original row.
+
+#### Parameters
+
+| Parameter      | Type                                                             |
+| -------------- | ---------------------------------------------------------------- |
+| `createReader` | (`git`) => [`WorkflowPublishedReader`](#workflowpublishedreader) |
+
+#### Returns
+
+`PublishedDefinitionPort`\<[`WorkflowPublishedDefinitionContext`](#workflowpublisheddefinitioncontext)\>
+
+---
+
+### workflowFilePath()
+
+```ts
+function workflowFilePath(id): string;
+```
+
+Where one Workflow's file lives in its library repository.
+
+#### Parameters
+
+| Parameter | Type     |
+| --------- | -------- |
+| `id`      | `string` |
+
+#### Returns
+
+`string`
+
+---
+
+### workflowFiles()
+
+```ts
+function workflowFiles(
+  git,
+  commit,
+): Promise<
+  Readonly<{
+    name: string;
+    mode: string;
+    hash: string;
+    type: "commit" | "blob" | "tree";
+  }>[]
+>;
+```
+
+Read the immediate Workflow directory without following symlinks or submodules.
+
+#### Parameters
+
+| Parameter | Type                                  |
+| --------- | ------------------------------------- |
+| `git`     | [`WorkflowReadGit`](#workflowreadgit) |
+| `commit`  | `string` \| `null`                    |
+
+#### Returns
+
+`Promise`\<`Readonly`\<\{ `name`: `string`; `mode`: `string`; `hash`: `string`;
+`type`: `"commit"` \| `"blob"` \| `"tree"`; \}\>[]\>
+
+---
+
+### changedWorkflowIds()
+
+```ts
+function changedWorkflowIds(git, before, after): Promise<string[]>;
+```
+
+Changed Workflow IDs in one accepted ref update, including deletions and mode
+changes.
+
+#### Parameters
+
+| Parameter | Type                                  |
+| --------- | ------------------------------------- |
+| `git`     | [`WorkflowReadGit`](#workflowreadgit) |
+| `before`  | `string`                              |
+| `after`   | `string`                              |
+
+#### Returns
+
+`Promise`\<`string`[]\>
+
+---
+
+### inspectWorkflowFile()
+
+```ts
+function inspectWorkflowFile(
+   git,
+   workflowId,
+   commit
+): Promise<
+  | {
+  kind: "missing";
+}
+  | {
+  kind: "valid";
+  draft: {
+     definition: {
+        format: "fungi.workflow/v1";
+        title: string;
+        description?: string;
+        apps: {
+         [key: string]: object;
+        };
+        subgraphs?: {
+         [key: string]: object;
+        };
+        triggers?: readonly (
+           | {
+           id: string;
+           on: "webhook";
+           title?: string;
+           when?: Predicate;
+           input?: {
+            [key: ...]: ...;
+           };
+         }
+           | {
+           id: string;
+           on: "schedule";
+           title?: string;
+           cron: {
+              expression: string;
+              timeZone: string;
+           };
+           input?: {
+            [key: ...]: ...;
+           };
+         }
+           | {
+           id: string;
+           on: "event";
+           title?: string;
+           app: string;
+           event: string;
+           eventDigest: string;
+           when?: Predicate;
+           input?: {
+            [key: ...]: ...;
+           };
+           repository?: Mapping;
+        })[];
+        input: {
+         [key: string]: Json;
+        };
+        nodes: readonly (
+           | {
+           id: string;
+           kind: "code";
+           source: string;
+           input: {
+            [key: string]: Json;
+           };
+           output: {
+            [key: string]: Json;
+           };
+           values: {
+            [key: string]: Mapping;
+           };
+         }
+           | {
+           id: string;
+           kind: "app";
+           app: string;
+           method: string;
+           methodDigest: string;
+           values: {
+            [key: string]: Mapping;
+           };
+           gitAccess?:   | {
+              binding: string;
+              repository: string;
+              branches: ...[];
+            }
+              | {
+              binding: string;
+              repository: string;
+              access: "read";
+            };
+           retry?: {
+              attempts: number;
+           };
+         }
+           | {
+           id: string;
+           kind: "review";
+           title: string;
+           detail?: string;
+           show: readonly object[];
+           reviewers: "runner" | "owners";
+           timeout: number;
+           choices?: readonly object[];
+         }
+           | {
+           id: string;
+           kind: "condition";
+           test: Predicate;
+         }
+           | {
+           id: string;
+           kind: "map";
+           over: {
+              node: string;
+              port: string;
+           };
+           body: string;
+           concurrency: number;
+           maxItems: number;
+         }
+           | {
+           id: string;
+           kind: "repeat";
+           body: string;
+           maxRounds: number;
+           until: Predicate;
+         }
+           | {
+           id: string;
+           kind: "wait";
+           for: number;
+         }
+           | {
+           id: string;
+           kind: "transform";
+           fields: {
+            [key: string]: Mapping;
+           };
+        })[];
+        edges: readonly object[];
+        output: {
+         [key: string]: object;
+        };
+     };
+     layout: {
+      [key: string]: object;
+     };
+     provenance?:   | {
+        kind: "import";
+        workflowId: string;
+        version: number;
+        commit: string;
+        sha256: string & object;
+        origin?: string;
+      }
+        | {
+        kind: "fork";
+        workflowId: string;
+        commit: string;
+      };
+  };
+}
+  | {
+  kind: "invalid";
+  issues: readonly Issue[];
+}>;
+```
+
+Decode a pushed file separately from the admitted catalog's semantic validation.
+
+#### Parameters
+
+| Parameter    | Type                                  |
+| ------------ | ------------------------------------- |
+| `git`        | [`WorkflowReadGit`](#workflowreadgit) |
+| `workflowId` | `string`                              |
+| `commit`     | `string`                              |
+
+#### Returns
+
+`Promise`\< \| \{ `kind`: `"missing"`; \} \| \{ `kind`: `"valid"`; `draft`: \{
+`definition`: \{ `format`: `"fungi.workflow/v1"`; `title`: `string`;
+`description?`: `string`; `apps`: \{ \[`key`: `string`\]: `object`; \};
+`subgraphs?`: \{ \[`key`: `string`\]: `object`; \}; `triggers?`: readonly ( \|
+\{ `id`: `string`; `on`: `"webhook"`; `title?`: `string`; `when?`: `Predicate`;
+`input?`: \{ \[`key`: ...\]: ...; \}; \} \| \{ `id`: `string`; `on`:
+`"schedule"`; `title?`: `string`; `cron`: \{ `expression`: `string`; `timeZone`:
+`string`; \}; `input?`: \{ \[`key`: ...\]: ...; \}; \} \| \{ `id`: `string`;
+`on`: `"event"`; `title?`: `string`; `app`: `string`; `event`: `string`;
+`eventDigest`: `string`; `when?`: `Predicate`; `input?`: \{ \[`key`: ...\]: ...;
+\}; `repository?`: `Mapping`; \})[]; `input`: \{ \[`key`: `string`\]: `Json`;
+\}; `nodes`: readonly ( \| \{ `id`: `string`; `kind`: `"code"`; `source`:
+`string`; `input`: \{ \[`key`: `string`\]: `Json`; \}; `output`: \{ \[`key`:
+`string`\]: `Json`; \}; `values`: \{ \[`key`: `string`\]: `Mapping`; \}; \} \|
+\{ `id`: `string`; `kind`: `"app"`; `app`: `string`; `method`: `string`;
+`methodDigest`: `string`; `values`: \{ \[`key`: `string`\]: `Mapping`; \};
+`gitAccess?`: \| \{ `binding`: `string`; `repository`: `string`; `branches`:
+...[]; \} \| \{ `binding`: `string`; `repository`: `string`; `access`: `"read"`;
+\}; `retry?`: \{ `attempts`: `number`; \}; \} \| \{ `id`: `string`; `kind`:
+`"review"`; `title`: `string`; `detail?`: `string`; `show`: readonly `object`[];
+`reviewers`: `"runner"` \| `"owners"`; `timeout`: `number`; `choices?`: readonly
+`object`[]; \} \| \{ `id`: `string`; `kind`: `"condition"`; `test`: `Predicate`;
+\} \| \{ `id`: `string`; `kind`: `"map"`; `over`: \{ `node`: `string`; `port`:
+`string`; \}; `body`: `string`; `concurrency`: `number`; `maxItems`: `number`;
+\} \| \{ `id`: `string`; `kind`: `"repeat"`; `body`: `string`; `maxRounds`:
+`number`; `until`: `Predicate`; \} \| \{ `id`: `string`; `kind`: `"wait"`;
+`for`: `number`; \} \| \{ `id`: `string`; `kind`: `"transform"`; `fields`: \{
+\[`key`: `string`\]: `Mapping`; \}; \})[]; `edges`: readonly `object`[];
+`output`: \{ \[`key`: `string`\]: `object`; \}; \}; `layout`: \{ \[`key`:
+`string`\]: `object`; \}; `provenance?`: \| \{ `kind`: `"import"`; `workflowId`:
+`string`; `version`: `number`; `commit`: `string`; `sha256`: `string` &
+`object`; `origin?`: `string`; \} \| \{ `kind`: `"fork"`; `workflowId`:
+`string`; `commit`: `string`; \}; \}; \} \| \{ `kind`: `"invalid"`; `issues`:
+readonly `Issue`[]; \}\>
+
+---
+
+### readWorkflowAt()
+
+```ts
+function readWorkflowAt(
+  git,
+  workflowId,
+  commit,
+): Promise<WorkflowDocument | null>;
+```
+
+One Workflow's file at `commit`, or null when it is absent or invalid.
+
+#### Parameters
+
+| Parameter    | Type                                  |
+| ------------ | ------------------------------------- |
+| `git`        | [`WorkflowReadGit`](#workflowreadgit) |
+| `workflowId` | `string`                              |
+| `commit`     | `string` \| `null`                    |
+
+#### Returns
+
+`Promise`\<[`WorkflowDocument`](#workflowdocument) \| `null`\>
+
+---
+
+### versionRefs()
+
+```ts
+function versionRefs(workflowId, references): object[];
+```
+
+A Workflow's published versions, newest first, from its `<id>@v<n>` tags.
+
+#### Parameters
+
+| Parameter    | Type       |
+| ------------ | ---------- |
+| `workflowId` | `string`   |
+| `references` | `object`[] |
+
+#### Returns
+
+`object`[]
+
+---
+
+### workflowCommitIsAncestor()
+
+```ts
+function workflowCommitIsAncestor(git, before, after): Promise<boolean>;
+```
+
+Batched first-parent reads retain every merge parent; the caller owns its IO
+budget.
+
+#### Parameters
+
+| Parameter | Type         |
+| --------- | ------------ |
+| `git`     | `GitBinding` |
+| `before`  | `string`     |
+| `after`   | `string`     |
+
+#### Returns
+
+`Promise`\<`boolean`\>
+
+---
+
+### listingGit()
+
+```ts
+function listingGit(git): WorkflowReadGit;
+```
+
+Each Git object read at most once while one listing runs.
+
+#### Parameters
+
+| Parameter | Type         |
+| --------- | ------------ |
+| `git`     | `GitBinding` |
+
+#### Returns
+
+[`WorkflowReadGit`](#workflowreadgit)
+
+---
+
+### readPublishedWorkflow()
+
+```ts
+function readPublishedWorkflow(
+  git,
+  workflowId,
+  at,
+  copied?,
+): Promise<(object & object & object) | null>;
+```
+
+One published Workflow: a version tag, or a commit, on `main`'s ancestry.
+`copied` answers from a caller's own read copy of that commit when it has one;
+otherwise the file is read from Git within a bounded read budget.
+
+#### Parameters
+
+| Parameter    | Type                                                            |
+| ------------ | --------------------------------------------------------------- |
+| `git`        | `GitBinding`                                                    |
+| `workflowId` | `string`                                                        |
+| `at`         | \| \{ `version`: `number`; \} \| \{ `commit`: `string`; \}      |
+| `copied`     | (`commit`) => [`WorkflowDocument`](#workflowdocument) \| `null` |
+
+#### Returns
+
+`Promise`\<`object` & `object` & `object` \| `null`\>