@fungi.computer/workflows-wire 0.0.0-stage → 0.1.0

package/dist/published-definition.d.ts

@@ -0,0 +1,22 @@
+import { type WorkflowDefinition } from "@fungi.computer/braid";
+import type { PublishedDefinitionPort, WorkflowPublicationContext } from "@fungi.computer/braid/runtime";
+/** The slice of {@link WorkflowPublicationContext} this port actually reads. */
+export type WorkflowPublishedDefinitionContext = Pick<WorkflowPublicationContext, "installationId" | "git">;
+/**
+ * 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`.
+ */
+export type WorkflowPublishedReader = Readonly<{
+    published(workflowId: string, at: {
+        version: number;
+    } | {
+        commit: string;
+    }): Promise<Readonly<{
+        definition: WorkflowDefinition;
+        commit: string;
+        version: number | null;
+    }> | null>;
+}>;
+/** Trigger arm verification uses current admitted Git; direct starts carry the App's original row. */
+export declare function createWorkflowPublishedDefinitionPort(createReader: (git: WorkflowPublishedDefinitionContext["git"]) => WorkflowPublishedReader): PublishedDefinitionPort<WorkflowPublishedDefinitionContext>;

package/dist/published-definition.js

@@ -0,0 +1,20 @@
+import { contentDigest } from "@fungi.computer/braid";
+import * as Schema from "effect/Schema";
+/** Trigger arm verification uses current admitted Git; direct starts carry the App's original row. */
+export function createWorkflowPublishedDefinitionPort(createReader) {
+    return {
+        async resolve({ git }, selector) {
+            const reader = createReader(git);
+            const published = await reader.published(selector.workflowId, selector);
+            return published === null
+                ? null
+                : {
+                    workflowId: selector.workflowId,
+                    definition: published.definition,
+                    commit: published.commit,
+                    version: published.version,
+                    digest: await contentDigest(Schema.decodeUnknownSync(Schema.Json)(published.definition)),
+                };
+        },
+    };
+}

package/dist/run-contracts.d.ts

@@ -0,0 +1,49 @@
+import * as z from "zod";
+/** The App's `WORKFLOWS.runs` read, scoped to one Workflow when given. */
+export declare const runsInputSchema: z.ZodLazy<z.ZodObject<{
+    workflowId: z.ZodOptional<z.ZodString>;
+}, z.core.$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.
+ */
+export declare const runListItemSchema: z.ZodLazy<z.ZodObject<{
+    runId: z.ZodString;
+    workflowId: z.ZodString;
+    commit: z.ZodString;
+    version: z.ZodNullable<z.ZodNumber>;
+    startedAt: z.ZodNumber;
+    title: z.ZodNullable<z.ZodString>;
+    source: z.ZodEnum<{
+        manual: "manual";
+        schedule: "schedule";
+        event: "event";
+        agent: "agent";
+        key: "key";
+    }>;
+    triggerId: z.ZodOptional<z.ZodString>;
+    initiatedBy: z.ZodLazy<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"member">;
+        memberId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"agent">;
+        agentId: z.ZodString;
+        grantorMemberId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"key">;
+        keyId: z.ZodString;
+        grantorMemberId: z.ZodString;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>>;
+export type WorkflowRunListItem = z.output<typeof runListItemSchema>;
+/**
+ * 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.
+ */
+export declare const viewerReplySchema: z.ZodLazy<z.ZodUnion<readonly [z.ZodObject<{
+    memberId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strict>]>>;
+export type ViewerReply = z.output<typeof viewerReplySchema>;

package/dist/run-contracts.js

@@ -0,0 +1,31 @@
+import * as z from "zod";
+import { workflowIdSchema } from "@fungi.computer/braid";
+import { workflowRunSourceSchema, workflowRunInitiatedBySchema, } from "./outcomes.js";
+/** The App's `WORKFLOWS.runs` read, scoped to one Workflow when given. */
+export const runsInputSchema = z.lazy(() => z.strictObject({
+    workflowId: workflowIdSchema.optional(),
+}));
+/**
+ * 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.
+ */
+export const runListItemSchema = z.lazy(() => z.strictObject({
+    runId: z.string(),
+    workflowId: workflowIdSchema,
+    commit: z.string(),
+    version: z.number().int().positive().nullable(),
+    startedAt: z.number(),
+    title: z.string().nullable(),
+    source: workflowRunSourceSchema,
+    triggerId: z.string().optional(),
+    initiatedBy: workflowRunInitiatedBySchema,
+}));
+/**
+ * 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.
+ */
+export const viewerReplySchema = z.lazy(() => z.union([
+    z.strictObject({ memberId: z.string() }),
+    z.strictObject({ error: z.string() }),
+]));

package/dist/run-ids.d.ts

@@ -0,0 +1,5 @@
+/** Typed id codec for Workflow run requests: mint and validate
+ * `workflow_request_*` ids. Hosts derive run ids from the request. */
+export declare const workflowRunRequestIds: Readonly<{
+    readonly request: import("@fungi.computer/cairn/id").IdCodec<"agar-workflow-run", "request", 1>;
+}>;

package/dist/run-ids.js

@@ -0,0 +1,10 @@
+import { defineIdFamily } from "@fungi.computer/cairn/id";
+/** Typed id codec for Workflow run requests: mint and validate
+ * `workflow_request_*` ids. Hosts derive run ids from the request. */
+export const workflowRunRequestIds = defineIdFamily({
+    family: "agar-workflow-run",
+    version: 1,
+    kinds: {
+        request: { prefix: "workflow_request" },
+    },
+});

package/dist/trigger-contracts.d.ts

@@ -0,0 +1,42 @@
+import * as z from "zod";
+/** The Agent Session (chat) that receives the ending of every run it covers. */
+export declare const runDeliverySchema: z.ZodObject<{
+    agentId: z.ZodString;
+    sessionId: z.ZodString;
+}, z.core.$strict>;
+export type RunDelivery = z.output<typeof runDeliverySchema>;
+/** One chat the member may choose for run reports: an existing Agent Session. */
+export declare const chatsReplySchema: z.ZodLazy<z.ZodUnion<readonly [z.ZodObject<{
+    chats: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        sessionId: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodLiteral<"not_granted">;
+}, z.core.$strict>]>>;
+/** The published trigger supplies cadence or event matching; the host supplies authority scope. */
+export declare const triggerTargetSchema: z.ZodLazy<z.ZodObject<{
+    workflowId: z.ZodString;
+    commit: z.ZodString;
+    triggerId: z.ZodString;
+    bindings: z.ZodRecord<z.ZodLazy<z.ZodString>, z.ZodUnion<readonly [z.ZodString, z.ZodLazy<z.ZodObject<{
+        kind: z.ZodLiteral<"team-source">;
+    }, z.core.$strict>>]>>;
+    delivery: z.ZodOptional<z.ZodObject<{
+        agentId: z.ZodString;
+        sessionId: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+export declare const scheduleDisarmInputSchema: z.ZodObject<{
+    scheduleId: z.ZodString;
+}, z.core.$strict>;
+export declare const eventDisarmInputSchema: z.ZodObject<{
+    eventTriggerId: z.ZodString;
+}, z.core.$strict>;
+export declare const triggerListInputSchema: z.ZodObject<{}, z.core.$strict>;
+export type WorkflowTriggerTarget = z.output<typeof triggerTargetSchema>;
+/** Host binding input carries the App-owned immutable row digest, never caller input. */
+export type WorkflowTriggerArmTarget = WorkflowTriggerTarget & Readonly<{
+    digest: string;
+}>;

package/dist/trigger-contracts.js

@@ -0,0 +1,27 @@
+import * as z from "zod";
+import { bindingsSelectionSchema } from "@fungi.computer/braid/git-access";
+import { gitSha1Schema } from "@fungi.computer/puffball/git-representation";
+import { workflowIdSchema } from "@fungi.computer/braid";
+const id = z.string().min(1).max(256);
+/** The Agent Session (chat) that receives the ending of every run it covers. */
+export const runDeliverySchema = z.strictObject({ agentId: id, sessionId: id });
+/** One chat the member may choose for run reports: an existing Agent Session. */
+export const chatsReplySchema = z.lazy(() => z.union([
+    z.strictObject({
+        chats: z
+            .array(runDeliverySchema.extend({ title: z.string().max(4_096) }))
+            .max(200),
+    }),
+    z.strictObject({ error: z.literal("not_granted") }),
+]));
+/** The published trigger supplies cadence or event matching; the host supplies authority scope. */
+export const triggerTargetSchema = z.lazy(() => z.strictObject({
+    workflowId: workflowIdSchema,
+    commit: gitSha1Schema,
+    triggerId: z.string().min(1).max(80),
+    bindings: bindingsSelectionSchema,
+    delivery: runDeliverySchema.optional(),
+}));
+export const scheduleDisarmInputSchema = z.strictObject({ scheduleId: id });
+export const eventDisarmInputSchema = z.strictObject({ eventTriggerId: id });
+export const triggerListInputSchema = z.strictObject({});

package/dist/workflow-repository.d.ts

@@ -0,0 +1,320 @@
+import { type Issue } from "@fungi.computer/braid";
+import type { GitBinding } from "@fungi.computer/agar/git";
+import * as S from "effect/Schema";
+/**
+ * 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,
+ * `workflows`, 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.
+ */
+export declare const workflowLibraryRepository = "trellis";
+/** Where one Workflow's file lives in its library repository. */
+export declare const workflowFilePath: (id: string) => string;
+export declare const workflowDraftSchema: S.Struct<{
+    readonly definition: S.Struct<{
+        readonly format: S.Literal<"fungi.workflow/v1">;
+        readonly title: S.String;
+        readonly description: S.optionalKey<S.String>;
+        readonly apps: S.$Record<S.String, S.Struct<{
+            readonly appId: S.String;
+            readonly role: S.optionalKey<S.String>;
+        }>>;
+        readonly subgraphs: S.optionalKey<S.$Record<S.String, S.Struct<{
+            readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly nodes: S.$Array<S.Union<readonly [S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"code">;
+                readonly source: S.String;
+                readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+                readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+                readonly values: S.$Record<S.String, S.Codec<import("@fungi.computer/braid").Mapping, import("@fungi.computer/braid").Mapping, never, never>>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"app">;
+                readonly app: S.String;
+                readonly method: S.String;
+                readonly methodDigest: S.String;
+                readonly values: S.$Record<S.String, S.Codec<import("@fungi.computer/braid").Mapping, import("@fungi.computer/braid").Mapping, never, never>>;
+                readonly gitAccess: S.optionalKey<S.declare<{
+                    binding: string;
+                    repository: string;
+                    branches: string[];
+                } | {
+                    binding: string;
+                    repository: string;
+                    access: "read";
+                }, {
+                    binding: string;
+                    repository: string;
+                    branches: string[];
+                } | {
+                    binding: string;
+                    repository: string;
+                    access: "read";
+                }>>;
+                readonly retry: S.optionalKey<S.Struct<{
+                    readonly attempts: S.Number;
+                }>>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"review">;
+                readonly title: S.String;
+                readonly detail: S.optionalKey<S.String>;
+                readonly show: S.$Array<S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>>;
+                readonly reviewers: S.Literals<readonly ["runner", "owners"]>;
+                readonly timeout: S.Number;
+                readonly choices: S.optionalKey<S.$Array<S.Struct<{
+                    readonly id: S.String;
+                    readonly label: S.String;
+                    readonly description: S.optionalKey<S.String>;
+                }>>>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"condition">;
+                readonly test: S.Codec<import("@fungi.computer/braid").Predicate, import("@fungi.computer/braid").Predicate, never, never>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"map">;
+                readonly over: S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>;
+                readonly body: S.String;
+                readonly concurrency: S.Number;
+                readonly maxItems: S.Number;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"repeat">;
+                readonly body: S.String;
+                readonly maxRounds: S.Number;
+                readonly until: S.Codec<import("@fungi.computer/braid").Predicate, import("@fungi.computer/braid").Predicate, never, never>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"wait">;
+                readonly for: S.Number;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"transform">;
+                readonly fields: S.$Record<S.String, S.Codec<import("@fungi.computer/braid").Mapping, import("@fungi.computer/braid").Mapping, never, never>>;
+            }>]>>;
+            readonly edges: S.$Array<S.Struct<{
+                readonly from: S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>;
+                readonly to: S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>;
+            }>>;
+            readonly output: S.$Record<S.String, S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>>;
+        }>>>;
+        readonly triggers: S.optionalKey<S.$Array<S.Union<readonly [S.Struct<{
+            readonly id: S.String;
+            readonly on: S.Literal<"webhook">;
+            readonly title: S.optionalKey<S.String>;
+            readonly when: S.optionalKey<S.Codec<import("@fungi.computer/braid").Predicate, import("@fungi.computer/braid").Predicate, never, never>>;
+            readonly input: S.optionalKey<S.$Record<S.String, S.Codec<import("@fungi.computer/braid").Mapping, import("@fungi.computer/braid").Mapping, never, never>>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly on: S.Literal<"schedule">;
+            readonly title: S.optionalKey<S.String>;
+            readonly cron: S.Struct<{
+                readonly expression: S.String;
+                readonly timeZone: S.String;
+            }>;
+            readonly input: S.optionalKey<S.$Record<S.String, S.Codec<import("@fungi.computer/braid").Mapping, import("@fungi.computer/braid").Mapping, never, never>>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly on: S.Literal<"event">;
+            readonly title: S.optionalKey<S.String>;
+            readonly app: S.String;
+            readonly event: S.String;
+            readonly eventDigest: S.String;
+            readonly when: S.optionalKey<S.Codec<import("@fungi.computer/braid").Predicate, import("@fungi.computer/braid").Predicate, never, never>>;
+            readonly input: S.optionalKey<S.$Record<S.String, S.Codec<import("@fungi.computer/braid").Mapping, import("@fungi.computer/braid").Mapping, never, never>>>;
+            readonly repository: S.optionalKey<S.Codec<import("@fungi.computer/braid").Mapping, import("@fungi.computer/braid").Mapping, never, never>>;
+        }>]>>>;
+        readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        readonly nodes: S.$Array<S.Union<readonly [S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"code">;
+            readonly source: S.String;
+            readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly values: S.$Record<S.String, S.Codec<import("@fungi.computer/braid").Mapping, import("@fungi.computer/braid").Mapping, never, never>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"app">;
+            readonly app: S.String;
+            readonly method: S.String;
+            readonly methodDigest: S.String;
+            readonly values: S.$Record<S.String, S.Codec<import("@fungi.computer/braid").Mapping, import("@fungi.computer/braid").Mapping, never, never>>;
+            readonly gitAccess: S.optionalKey<S.declare<{
+                binding: string;
+                repository: string;
+                branches: string[];
+            } | {
+                binding: string;
+                repository: string;
+                access: "read";
+            }, {
+                binding: string;
+                repository: string;
+                branches: string[];
+            } | {
+                binding: string;
+                repository: string;
+                access: "read";
+            }>>;
+            readonly retry: S.optionalKey<S.Struct<{
+                readonly attempts: S.Number;
+            }>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"review">;
+            readonly title: S.String;
+            readonly detail: S.optionalKey<S.String>;
+            readonly show: S.$Array<S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>>;
+            readonly reviewers: S.Literals<readonly ["runner", "owners"]>;
+            readonly timeout: S.Number;
+            readonly choices: S.optionalKey<S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly label: S.String;
+                readonly description: S.optionalKey<S.String>;
+            }>>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"condition">;
+            readonly test: S.Codec<import("@fungi.computer/braid").Predicate, import("@fungi.computer/braid").Predicate, never, never>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"map">;
+            readonly over: S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>;
+            readonly body: S.String;
+            readonly concurrency: S.Number;
+            readonly maxItems: S.Number;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"repeat">;
+            readonly body: S.String;
+            readonly maxRounds: S.Number;
+            readonly until: S.Codec<import("@fungi.computer/braid").Predicate, import("@fungi.computer/braid").Predicate, never, never>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"wait">;
+            readonly for: S.Number;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"transform">;
+            readonly fields: S.$Record<S.String, S.Codec<import("@fungi.computer/braid").Mapping, import("@fungi.computer/braid").Mapping, never, never>>;
+        }>]>>;
+        readonly edges: S.$Array<S.Struct<{
+            readonly from: S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>;
+            readonly to: S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>;
+        }>>;
+        readonly output: S.$Record<S.String, S.Struct<{
+            readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+            readonly port: S.String;
+        }>>;
+    }>;
+    readonly layout: S.$Record<S.String, S.Struct<{
+        readonly x: S.Finite;
+        readonly y: S.Finite;
+    }>>;
+    readonly provenance: S.optionalKey<S.declare<{
+        kind: "import";
+        workflowId: string;
+        version: number;
+        commit: string;
+        sha256: string & {
+            readonly appReleaseKind: "Sha256Digest";
+        };
+        origin?: string | undefined;
+    } | {
+        kind: "fork";
+        workflowId: string;
+        commit: string;
+    }, {
+        kind: "import";
+        workflowId: string;
+        version: number;
+        commit: string;
+        sha256: string & {
+            readonly appReleaseKind: "Sha256Digest";
+        };
+        origin?: string | undefined;
+    } | {
+        kind: "fork";
+        workflowId: string;
+        commit: string;
+    }>>;
+}>;
+/** One Workflow file's decoded content. */
+export type WorkflowDraft = typeof workflowDraftSchema.Type;
+/** A Workflow file's content at the commit it was read from. */
+export type WorkflowDocument = WorkflowDraft & {
+    readonly commit: string;
+};
+export type WorkflowReadGit = Pick<GitBinding, "readCommit" | "readTree" | "readBlob">;
+/** Read the immediate Workflow directory without following symlinks or submodules. */
+export declare function workflowFiles(git: WorkflowReadGit, commit: string | null): Promise<Readonly<{
+    name: string;
+    mode: string;
+    hash: string;
+    type: "blob" | "tree" | "commit";
+}>[]>;
+/** Changed Workflow IDs in one accepted ref update, including deletions and mode changes. */
+export declare function changedWorkflowIds(git: WorkflowReadGit, before: string, after: string): Promise<string[]>;
+/** Decode a pushed file separately from the admitted catalog's semantic validation. */
+export declare function inspectWorkflowFile(git: WorkflowReadGit, workflowId: string, commit: string): Promise<{
+    kind: "missing";
+} | {
+    kind: "valid";
+    draft: WorkflowDraft;
+} | {
+    kind: "invalid";
+    issues: readonly Issue[];
+}>;
+/** One Workflow's file at `commit`, or null when it is absent or invalid. */
+export declare function readWorkflowAt(git: WorkflowReadGit, workflowId: string, commit: string | null): Promise<WorkflowDocument | null>;
+/** A Workflow's published versions, newest first, from its `<id>@v<n>` tags. */
+export declare function versionRefs(workflowId: string, references: Awaited<ReturnType<GitBinding["refs"]>>): {
+    version: number;
+    commit: string;
+}[];
+/** Batched first-parent reads retain every merge parent; the caller owns its IO budget. */
+export declare function workflowCommitIsAncestor(git: GitBinding, before: string, after: string): Promise<boolean>;
+/** Each Git object read at most once while one listing runs. */
+export declare function listingGit(git: GitBinding): WorkflowReadGit;
+/**
+ * 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.
+ */
+export declare function readPublishedWorkflow(git: GitBinding, workflowId: string, at: {
+    version: number;
+} | {
+    commit: string;
+}, copied?: (commit: string) => WorkflowDocument | null): Promise<(WorkflowDocument & {
+    readonly version: number | null;
+}) | null>;