@vercel/factory 0.0.14 → 0.0.16

package/dist/schema/change.mjs

@@ -0,0 +1,68 @@
+import { changeIdSchema, repositoryIdSchema, taskIdSchema } from "./id.mjs";
+import { isoDateTimeSchema, schemaVersionSchema } from "./common.mjs";
+import { z } from "zod";
+//#region src/schema/change.ts
+/** Validates the shared ordinal scale used for risk and confidence. */
+const changeLevelSchema = z.enum([
+	"low",
+	"medium",
+	"high"
+]);
+/** Validates the durable lifecycle state of a pull-request Change. */
+const changeStateSchema = z.enum([
+	"verifying",
+	"ready",
+	"merged",
+	"deployed",
+	"rolled_out",
+	"rolled_back",
+	"closed"
+]);
+/** Validates the verification evidence used to assess a Change. */
+const changeEvidenceSchema = z.strictObject({
+	reproVerified: z.boolean(),
+	testsAdded: z.number().int().min(0),
+	checksGreen: z.boolean(),
+	attackPassed: z.boolean(),
+	scopeMatches: z.boolean(),
+	previewUrl: z.url().optional()
+});
+const changeFields = {
+	schemaVersion: schemaVersionSchema,
+	id: changeIdSchema,
+	repositoryId: repositoryIdSchema,
+	taskId: taskIdSchema.optional(),
+	groupId: taskIdSchema.optional(),
+	prNumber: z.number().int().min(1),
+	prUrl: z.url(),
+	author: z.string().min(1),
+	risk: changeLevelSchema,
+	confidence: changeLevelSchema,
+	evidence: changeEvidenceSchema,
+	mergeSha: z.string().regex(/^[0-9a-f]{40}$/).optional().describe("Merge commit sha recorded when the pull request merges, matched against production deployments."),
+	createdAt: isoDateTimeSchema,
+	updatedAt: isoDateTimeSchema
+};
+/** Validates a persisted human-visible pull-request Change and its trust evidence. */
+const changeSchema = z.discriminatedUnion("state", [z.strictObject({
+	...changeFields,
+	state: z.enum([
+		"verifying",
+		"ready",
+		"closed"
+	]),
+	decidedBy: z.string().min(1).optional()
+}), z.strictObject({
+	...changeFields,
+	state: z.enum([
+		"merged",
+		"deployed",
+		"rolled_out",
+		"rolled_back"
+	]),
+	decidedBy: z.string().min(1)
+})]);
+//#endregion
+export { changeEvidenceSchema, changeLevelSchema, changeSchema, changeStateSchema };
+
+//# sourceMappingURL=change.mjs.map

package/dist/schema/change.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"change.mjs","names":[],"sources":["../../src/schema/change.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { isoDateTimeSchema, schemaVersionSchema } from \"./common\";\nimport { changeIdSchema, repositoryIdSchema, taskIdSchema } from \"./id\";\n\n/** Validates the shared ordinal scale used for risk and confidence. */\nexport const changeLevelSchema = z.enum([\"low\", \"medium\", \"high\"]);\n\n/** Validates the durable lifecycle state of a pull-request Change. */\nexport const changeStateSchema = z.enum([\n  \"verifying\",\n  \"ready\",\n  \"merged\",\n  \"deployed\",\n  \"rolled_out\",\n  \"rolled_back\",\n  \"closed\",\n]);\n\n/** Validates the verification evidence used to assess a Change. */\nexport const changeEvidenceSchema = z.strictObject({\n  reproVerified: z.boolean(),\n  testsAdded: z.number().int().min(0),\n  checksGreen: z.boolean(),\n  attackPassed: z.boolean(),\n  scopeMatches: z.boolean(),\n  previewUrl: z.url().optional(),\n});\n\nconst changeFields = {\n  schemaVersion: schemaVersionSchema,\n  id: changeIdSchema,\n  repositoryId: repositoryIdSchema,\n  taskId: taskIdSchema.optional(),\n  groupId: taskIdSchema.optional(),\n  prNumber: z.number().int().min(1),\n  prUrl: z.url(),\n  author: z.string().min(1),\n  risk: changeLevelSchema,\n  confidence: changeLevelSchema,\n  evidence: changeEvidenceSchema,\n  mergeSha: z\n    .string()\n    .regex(/^[0-9a-f]{40}$/)\n    .optional()\n    .describe(\n      \"Merge commit sha recorded when the pull request merges, matched against production deployments.\",\n    ),\n  createdAt: isoDateTimeSchema,\n  updatedAt: isoDateTimeSchema,\n} as const;\n\n/** Validates a persisted human-visible pull-request Change and its trust evidence. */\nexport const changeSchema = z.discriminatedUnion(\"state\", [\n  z.strictObject({\n    ...changeFields,\n    state: z.enum([\"verifying\", \"ready\", \"closed\"]),\n    decidedBy: z.string().min(1).optional(),\n  }),\n  z.strictObject({\n    ...changeFields,\n    state: z.enum([\"merged\", \"deployed\", \"rolled_out\", \"rolled_back\"]),\n    decidedBy: z.string().min(1),\n  }),\n]);\n\n/** Shared low-to-high ordinal value used for risk and confidence. */\nexport type ChangeLevel = z.infer<typeof changeLevelSchema>;\n/** Durable lifecycle state of a human-visible pull-request Change. */\nexport type ChangeState = z.infer<typeof changeStateSchema>;\n/** Verification facts supporting the risk and confidence assigned to a Change. */\nexport type ChangeEvidence = z.infer<typeof changeEvidenceSchema>;\n/** Persisted pull-request Change tracked independently from the Tasks that produced it. */\nexport type Change = z.infer<typeof changeSchema>;\n/** Change read model narrowed to one exact lifecycle state. */\nexport type ChangeInState<State extends ChangeState> = Change & { readonly state: State };\n"],"mappings":";;;;;AAKA,MAAa,oBAAoB,EAAE,KAAK;CAAC;CAAO;CAAU;AAAM,CAAC;;AAGjE,MAAa,oBAAoB,EAAE,KAAK;CACtC;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;AAGD,MAAa,uBAAuB,EAAE,aAAa;CACjD,eAAe,EAAE,QAAQ;CACzB,YAAY,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC;CAClC,aAAa,EAAE,QAAQ;CACvB,cAAc,EAAE,QAAQ;CACxB,cAAc,EAAE,QAAQ;CACxB,YAAY,EAAE,IAAI,CAAC,CAAC,SAAS;AAC/B,CAAC;AAED,MAAM,eAAe;CACnB,eAAe;CACf,IAAI;CACJ,cAAc;CACd,QAAQ,aAAa,SAAS;CAC9B,SAAS,aAAa,SAAS;CAC/B,UAAU,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC;CAChC,OAAO,EAAE,IAAI;CACb,QAAQ,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;CACxB,MAAM;CACN,YAAY;CACZ,UAAU;CACV,UAAU,EACP,OAAO,CAAC,CACR,MAAM,gBAAgB,CAAC,CACvB,SAAS,CAAC,CACV,SACC,iGACF;CACF,WAAW;CACX,WAAW;AACb;;AAGA,MAAa,eAAe,EAAE,mBAAmB,SAAS,CACxD,EAAE,aAAa;CACb,GAAG;CACH,OAAO,EAAE,KAAK;EAAC;EAAa;EAAS;CAAQ,CAAC;CAC9C,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;AACxC,CAAC,GACD,EAAE,aAAa;CACb,GAAG;CACH,OAAO,EAAE,KAAK;EAAC;EAAU;EAAY;EAAc;CAAa,CAAC;CACjE,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC;AAC7B,CAAC,CACH,CAAC"}

package/dist/schema/common.d.mts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+//#region src/schema/common.d.ts
+/** Clock returning a validated UTC ISO-8601 timestamp string. */
+type IsoDateTimeClock = () => string;
+/** Clock returning a Date for calendar and elapsed-time policy decisions. */
+type DateClock = () => Date;
+/** Monotonic-style clock returning elapsed milliseconds as a number. */
+type MillisecondClock = () => number;
+/** Value supplied synchronously or through a Promise. */
+type MaybePromise<Value> = Value | Promise<Value>;
+/** Version written into every persisted Factory entity snapshot. */
+declare const SCHEMA_VERSION = 1;
+/** Validates the schema version supported by this package release. */
+declare const schemaVersionSchema: z.ZodLiteral<1>;
+/** Validates UTC timestamps serialized in ISO 8601 form. */
+declare const isoDateTimeSchema: z.ZodISODateTime;
+/** Validates a finite, nonnegative monetary amount denominated in US dollars. */
+declare const usdSchema: z.ZodNumber;
+/**
+ * Open vocabulary value. Standard values ship as exported constants; custom
+ * values matching the pattern are equally valid.
+ */
+declare const vocabularySchema: z.ZodString;
+/** Validates a connector-neutral destination for workflow replies. */
+declare const replyToSchema: z.ZodObject<{
+  channel: z.ZodString;
+  address: z.ZodString;
+}, z.core.$strict>;
+/** Connector-neutral destination that preserves where a workflow should reply. */
+type ReplyTo = z.infer<typeof replyToSchema>;
+//#endregion
+export { DateClock, IsoDateTimeClock, MaybePromise, MillisecondClock, ReplyTo, SCHEMA_VERSION, isoDateTimeSchema, replyToSchema, schemaVersionSchema, usdSchema, vocabularySchema };
+//# sourceMappingURL=common.d.mts.map

package/dist/{id-BLIkCVue.mjs → schema/common.mjs}

@@ -1,33 +1,24 @@
 import { z } from "zod";
 //#region src/schema/common.ts
+/** Version written into every persisted Factory entity snapshot. */
 const SCHEMA_VERSION = 1;
+/** Validates the schema version supported by this package release. */
 const schemaVersionSchema = z.literal(1).describe("Version of the entity schema this row was written with.");
+/** Validates UTC timestamps serialized in ISO 8601 form. */
 const isoDateTimeSchema = z.iso.datetime().describe("UTC timestamp in ISO 8601 format, e.g. 2026-08-26T12:00:00Z.");
+/** Validates a finite, nonnegative monetary amount denominated in US dollars. */
 const usdSchema = z.number().finite().nonnegative().describe("Amount in US dollars.");
 /**
 * Open vocabulary value. Standard values ship as exported constants; custom
 * values matching the pattern are equally valid.
 */
 const vocabularySchema = z.string().regex(/^[a-z][a-z0-9_]{0,63}$/, "must be lowercase snake_case starting with a letter").describe("Lowercase snake_case name, e.g. github_issue or sentry_alert.");
+/** Validates a connector-neutral destination for workflow replies. */
 const replyToSchema = z.strictObject({
 	channel: z.string().min(1).describe("Connector that should carry replies, e.g. github or slack."),
 	address: z.string().min(1).describe("Connector-specific reply address, e.g. acme/web#41 or a Slack thread id.")
 });
 //#endregion
-//#region src/schema/id.ts
-function idSchema(prefix) {
-	return z.string().regex(new RegExp(`^${prefix}_[a-z0-9]{6,64}$`));
-}
-const factoryIdSchema = idSchema("fac");
-const repositoryIdSchema = idSchema("repo");
-const signalIdSchema = idSchema("sig");
-const taskIdSchema = idSchema("task");
-const changeIdSchema = idSchema("chg");
-const receiptIdSchema = idSchema("rcpt");
-const outboxIdSchema = idSchema("out");
-const answerIdSchema = idSchema("ans");
-const repositoryIdsSchema = z.array(repositoryIdSchema).min(1);
-//#endregion
-export { receiptIdSchema as a, signalIdSchema as c, isoDateTimeSchema as d, replyToSchema as f, vocabularySchema as h, outboxIdSchema as i, taskIdSchema as l, usdSchema as m, changeIdSchema as n, repositoryIdSchema as o, schemaVersionSchema as p, factoryIdSchema as r, repositoryIdsSchema as s, answerIdSchema as t, SCHEMA_VERSION as u };
+export { SCHEMA_VERSION, isoDateTimeSchema, replyToSchema, schemaVersionSchema, usdSchema, vocabularySchema };
 
-//# sourceMappingURL=id-BLIkCVue.mjs.map
+//# sourceMappingURL=common.mjs.map

package/dist/schema/common.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.mjs","names":[],"sources":["../../src/schema/common.ts"],"sourcesContent":["import { z } from \"zod\";\n\n/** Clock returning a validated UTC ISO-8601 timestamp string. */\nexport type IsoDateTimeClock = () => string;\n/** Clock returning a Date for calendar and elapsed-time policy decisions. */\nexport type DateClock = () => Date;\n/** Monotonic-style clock returning elapsed milliseconds as a number. */\nexport type MillisecondClock = () => number;\n/** Value supplied synchronously or through a Promise. */\nexport type MaybePromise<Value> = Value | Promise<Value>;\n\n/** Version written into every persisted Factory entity snapshot. */\nexport const SCHEMA_VERSION = 1;\n\n/** Validates the schema version supported by this package release. */\nexport const schemaVersionSchema = z\n  .literal(SCHEMA_VERSION)\n  .describe(\"Version of the entity schema this row was written with.\");\n\n/** Validates UTC timestamps serialized in ISO 8601 form. */\nexport const isoDateTimeSchema = z.iso\n  .datetime()\n  .describe(\"UTC timestamp in ISO 8601 format, e.g. 2026-08-26T12:00:00Z.\");\n\n/** Validates a finite, nonnegative monetary amount denominated in US dollars. */\nexport const usdSchema = z.number().finite().nonnegative().describe(\"Amount in US dollars.\");\n\n/**\n * Open vocabulary value. Standard values ship as exported constants; custom\n * values matching the pattern are equally valid.\n */\nexport const vocabularySchema = z\n  .string()\n  .regex(/^[a-z][a-z0-9_]{0,63}$/, \"must be lowercase snake_case starting with a letter\")\n  .describe(\"Lowercase snake_case name, e.g. github_issue or sentry_alert.\");\n\n/** Validates a connector-neutral destination for workflow replies. */\nexport const replyToSchema = z.strictObject({\n  channel: z.string().min(1).describe(\"Connector that should carry replies, e.g. github or slack.\"),\n  address: z\n    .string()\n    .min(1)\n    .describe(\"Connector-specific reply address, e.g. acme/web#41 or a Slack thread id.\"),\n});\n\n/** Connector-neutral destination that preserves where a workflow should reply. */\nexport type ReplyTo = z.infer<typeof replyToSchema>;\n"],"mappings":";;;AAYA,MAAa,iBAAiB;;AAG9B,MAAa,sBAAsB,EAChC,QAAA,CAAsB,CAAC,CACvB,SAAS,yDAAyD;;AAGrE,MAAa,oBAAoB,EAAE,IAChC,SAAS,CAAC,CACV,SAAS,8DAA8D;;AAG1E,MAAa,YAAY,EAAE,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,uBAAuB;;;;;AAM3F,MAAa,mBAAmB,EAC7B,OAAO,CAAC,CACR,MAAM,0BAA0B,qDAAqD,CAAC,CACtF,SAAS,+DAA+D;;AAG3E,MAAa,gBAAgB,EAAE,aAAa;CAC1C,SAAS,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,4DAA4D;CAChG,SAAS,EACN,OAAO,CAAC,CACR,IAAI,CAAC,CAAC,CACN,SAAS,0EAA0E;AACxF,CAAC"}

package/dist/schema/communication.d.mts

@@ -0,0 +1,52 @@
+import { z } from "zod";
+//#region src/schema/communication.d.ts
+/** Standard connector-neutral outcomes understood by communication presenters. */
+declare const communicationOutcomes: readonly ["accepted", "started", "succeeded", "failed", "cancelled", "needs_human", "question", "digest", "rolled_back", "budget_warning", "budget_exhausted", "message"];
+/** Validates the bounded outcome vocabulary of an outbound communication event. */
+declare const communicationOutcomeSchema: z.ZodEnum<{
+  message: "message";
+  succeeded: "succeeded";
+  failed: "failed";
+  needs_human: "needs_human";
+  cancelled: "cancelled";
+  accepted: "accepted";
+  question: "question";
+  rolled_back: "rolled_back";
+  started: "started";
+  digest: "digest";
+  budget_warning: "budget_warning";
+  budget_exhausted: "budget_exhausted";
+}>;
+/** Validates a connector-neutral event queued for delivery to its original destination. */
+declare const communicationEventSchema: z.ZodObject<{
+  eventId: z.ZodString;
+  repositoryIds: z.ZodReadonly<z.ZodTuple<[z.ZodType<`repo_${string}`, string, z.core.$ZodTypeInternals<`repo_${string}`, string>>], z.ZodType<`repo_${string}`, string, z.core.$ZodTypeInternals<`repo_${string}`, string>>>>;
+  taskId: z.ZodOptional<z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>>;
+  changeId: z.ZodOptional<z.ZodType<`chg_${string}`, string, z.core.$ZodTypeInternals<`chg_${string}`, string>>>;
+  replyTo: z.ZodObject<{
+    channel: z.ZodString;
+    address: z.ZodString;
+  }, z.core.$strict>;
+  outcome: z.ZodEnum<{
+    message: "message";
+    succeeded: "succeeded";
+    failed: "failed";
+    needs_human: "needs_human";
+    cancelled: "cancelled";
+    accepted: "accepted";
+    question: "question";
+    rolled_back: "rolled_back";
+    started: "started";
+    digest: "digest";
+    budget_warning: "budget_warning";
+    budget_exhausted: "budget_exhausted";
+  }>;
+  data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+/** Outcome category used by connector renderers to present a workflow event. */
+type CommunicationOutcome = z.infer<typeof communicationOutcomeSchema>;
+/** Connector-neutral outbound workflow event with a stable delivery identity. */
+type CommunicationEvent = z.infer<typeof communicationEventSchema>;
+//#endregion
+export { CommunicationEvent, CommunicationOutcome, communicationEventSchema, communicationOutcomeSchema, communicationOutcomes };
+//# sourceMappingURL=communication.d.mts.map

package/dist/{communication-Kd9nU5RP.mjs → schema/communication.mjs}

@@ -1,11 +1,14 @@
-import { f as replyToSchema, l as taskIdSchema, n as changeIdSchema, s as repositoryIdsSchema } from "./id-BLIkCVue.mjs";
+import { changeIdSchema, repositoryIdsSchema, taskIdSchema } from "./id.mjs";
+import { replyToSchema } from "./common.mjs";
 import { z } from "zod";
 //#region src/schema/communication.ts
+/** Standard connector-neutral outcomes understood by communication presenters. */
 const communicationOutcomes = [
 	"accepted",
 	"started",
 	"succeeded",
 	"failed",
+	"cancelled",
 	"needs_human",
 	"question",
 	"digest",
@@ -14,7 +17,9 @@ const communicationOutcomes = [
 	"budget_exhausted",
 	"message"
 ];
+/** Validates the bounded outcome vocabulary of an outbound communication event. */
 const communicationOutcomeSchema = z.enum(communicationOutcomes).describe("Lifecycle outcome a connector should render and deliver.");
+/** Validates a connector-neutral event queued for delivery to its original destination. */
 const communicationEventSchema = z.strictObject({
 	eventId: z.string().min(1).describe("Stable idempotency key for this delivery."),
 	repositoryIds: repositoryIdsSchema,
@@ -25,6 +30,6 @@ const communicationEventSchema = z.strictObject({
 	data: z.record(z.string(), z.unknown()).describe("Outcome-specific connector payload.")
 });
 //#endregion
-export { communicationOutcomeSchema as n, communicationOutcomes as r, communicationEventSchema as t };
+export { communicationEventSchema, communicationOutcomeSchema, communicationOutcomes };
 
-//# sourceMappingURL=communication-Kd9nU5RP.mjs.map
+//# sourceMappingURL=communication.mjs.map

package/dist/schema/communication.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"communication.mjs","names":[],"sources":["../../src/schema/communication.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { replyToSchema } from \"./common\";\nimport { changeIdSchema, repositoryIdsSchema, taskIdSchema } from \"./id\";\n\n/** Standard connector-neutral outcomes understood by communication presenters. */\nexport const communicationOutcomes = [\n  \"accepted\",\n  \"started\",\n  \"succeeded\",\n  \"failed\",\n  \"cancelled\",\n  \"needs_human\",\n  \"question\",\n  \"digest\",\n  \"rolled_back\",\n  \"budget_warning\",\n  \"budget_exhausted\",\n  \"message\",\n] as const;\n\n/** Validates the bounded outcome vocabulary of an outbound communication event. */\nexport const communicationOutcomeSchema = z\n  .enum(communicationOutcomes)\n  .describe(\"Lifecycle outcome a connector should render and deliver.\");\n\n/** Validates a connector-neutral event queued for delivery to its original destination. */\nexport const communicationEventSchema = z.strictObject({\n  eventId: z.string().min(1).describe(\"Stable idempotency key for this delivery.\"),\n  repositoryIds: repositoryIdsSchema,\n  taskId: taskIdSchema.optional(),\n  changeId: changeIdSchema.optional(),\n  replyTo: replyToSchema,\n  outcome: communicationOutcomeSchema,\n  data: z.record(z.string(), z.unknown()).describe(\"Outcome-specific connector payload.\"),\n});\n\n/** Outcome category used by connector renderers to present a workflow event. */\nexport type CommunicationOutcome = z.infer<typeof communicationOutcomeSchema>;\n/** Connector-neutral outbound workflow event with a stable delivery identity. */\nexport type CommunicationEvent = z.infer<typeof communicationEventSchema>;\n"],"mappings":";;;;;AAKA,MAAa,wBAAwB;CACnC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;AAGA,MAAa,6BAA6B,EACvC,KAAK,qBAAqB,CAAC,CAC3B,SAAS,0DAA0D;;AAGtE,MAAa,2BAA2B,EAAE,aAAa;CACrD,SAAS,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,2CAA2C;CAC/E,eAAe;CACf,QAAQ,aAAa,SAAS;CAC9B,UAAU,eAAe,SAAS;CAClC,SAAS;CACT,SAAS;CACT,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS,qCAAqC;AACxF,CAAC"}

package/dist/schema/execution.d.mts

@@ -0,0 +1,101 @@
+import { TaskId } from "./id.mjs";
+import { Task } from "./task.mjs";
+import { z } from "zod";
+//#region src/schema/execution.d.ts
+/** Validates a durable evidence reference returned by an execution provider. */
+declare const executionArtifactSchema: z.ZodObject<{
+  kind: z.ZodEnum<{
+    patch: "patch";
+    report: "report";
+    log: "log";
+  }>;
+  ref: z.ZodString;
+}, z.core.$strict>;
+/** Validates a Task identity paired with its positive execution-attempt fence. */
+declare const taskAttemptRefSchema: z.ZodReadonly<z.ZodObject<{
+  taskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+  attempt: z.ZodNumber;
+}, z.core.$strict>>;
+/** Stable provider idempotency key derived from one exact Task attempt. */
+type ExecutionLaunchKey = `factory-task:${TaskId}:${number}`;
+/** Validates the stable provider idempotency key for one exact Task attempt. */
+declare const executionLaunchKeySchema: z.ZodType<ExecutionLaunchKey, string>;
+/** Validates the immutable, bounded coding request captured before provider execution. */
+declare const codingExecutionRequestSchema: z.ZodObject<{
+  repository: z.ZodObject<{
+    slug: z.ZodType<`${string}/${string}`, string, z.core.$ZodTypeInternals<`${string}/${string}`, string>>;
+    baseSha: z.ZodString;
+  }, z.core.$strict>;
+  harness: z.ZodEnum<{
+    "claude-code": "claude-code";
+    codex: "codex";
+    fx: "fx";
+    pi: "pi";
+  }>;
+  prompt: z.ZodString;
+  allowedConstructs: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+  environment: z.ZodObject<{
+    snapshotId: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodNumber;
+  }, z.core.$strict>;
+  limits: z.ZodObject<{
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    maxCostUsd: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>;
+  taskId: z.ZodType<`task_${string}`, string, z.core.$ZodTypeInternals<`task_${string}`, string>>;
+  attempt: z.ZodNumber;
+}, z.core.$strict>;
+declare const executionResultFieldsSchema: z.ZodObject<{
+  execution: z.ZodObject<{
+    provider: z.ZodString;
+    sessionId: z.ZodString;
+    environmentId: z.ZodOptional<z.ZodString>;
+    harness: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>;
+  artifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    kind: z.ZodEnum<{
+      patch: "patch";
+      report: "report";
+      log: "log";
+    }>;
+    ref: z.ZodString;
+  }, z.core.$strict>>>;
+  usage: z.ZodObject<{
+    inputTokens: z.ZodOptional<z.ZodNumber>;
+    outputTokens: z.ZodOptional<z.ZodNumber>;
+    computeMs: z.ZodNumber;
+    costUsd: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>;
+  reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type ExecutionResultFields = z.infer<typeof executionResultFieldsSchema>;
+/** Provider outcome, evidence references, and cumulative usage for one execution attempt. */
+type ExecutionResult = ExecutionResultFields & ({
+  status: "completed";
+  failureCode?: never;
+} | {
+  status: "needs_input";
+  failureCode?: never;
+} | {
+  status: "cancelled";
+  failureCode?: never;
+} | {
+  status: "failed";
+  failureCode?: "missing_output";
+});
+/** Validates a provider outcome and cumulative usage without inferring Task success. */
+declare const executionResultSchema: z.ZodType<ExecutionResult>;
+/** Task identity and attempt fence used by execution operations and launch keys. */
+type TaskAttemptRef = z.infer<typeof taskAttemptRefSchema>;
+/** Constructs and validates a Task identity with its positive execution-attempt fence. */
+declare function taskAttemptRef(taskId: TaskAttemptRef["taskId"], attempt: number): TaskAttemptRef;
+/** Converts a Task-shaped value into the canonical Task identity and attempt fence. */
+declare function taskAttemptRefFromTask(task: Pick<Task, "id" | "attempt">): TaskAttemptRef;
+/** Immutable repository, harness, capability, environment, and limit request for one coding Task attempt. */
+type CodingExecutionRequest = z.infer<typeof codingExecutionRequestSchema>;
+/** Durable evidence reference returned by an execution provider. */
+type ExecutionArtifact = z.infer<typeof executionArtifactSchema>;
+//#endregion
+export { CodingExecutionRequest, ExecutionArtifact, ExecutionLaunchKey, ExecutionResult, TaskAttemptRef, codingExecutionRequestSchema, executionArtifactSchema, executionLaunchKeySchema, executionResultSchema, taskAttemptRef, taskAttemptRefFromTask, taskAttemptRefSchema };
+//# sourceMappingURL=execution.d.mts.map

package/dist/schema/execution.mjs

@@ -0,0 +1,86 @@
+import { taskIdSchema } from "./id.mjs";
+import { usdSchema } from "./common.mjs";
+import { repositorySlugSchema } from "./repository.mjs";
+import { jsonValueSchema } from "./work.mjs";
+import { executionReferenceSchema } from "./task.mjs";
+import { z } from "zod";
+//#region src/schema/execution.ts
+/** Validates a durable evidence reference returned by an execution provider. */
+const executionArtifactSchema = z.strictObject({
+	kind: z.enum([
+		"patch",
+		"report",
+		"log"
+	]).describe("Evidence artifact type."),
+	ref: z.string().min(1).max(2048).describe("Durable artifact reference; grants no read authority.")
+});
+const artifacts = z.array(executionArtifactSchema).max(32).readonly().describe("Bounded durable evidence references.");
+/** Validates a Task ID and execution-attempt fence that must travel together. */
+const taskAttemptRefFields = {
+	taskId: taskIdSchema.describe("Task that owns the operation."),
+	attempt: z.number().int().positive().describe("Current Task execution attempt.")
+};
+/** Validates a Task identity paired with its positive execution-attempt fence. */
+const taskAttemptRefSchema = z.strictObject(taskAttemptRefFields).readonly();
+/** Validates the stable provider idempotency key for one exact Task attempt. */
+const executionLaunchKeySchema = z.string().regex(/^factory-task:task_[a-z0-9]{6,64}:[1-9]\d*$/u, "Expected factory-task:<task-id>:<positive-attempt>");
+/** Validates the immutable, bounded coding request captured before provider execution. */
+const codingExecutionRequestSchema = z.strictObject({
+	...taskAttemptRefFields,
+	repository: z.strictObject({
+		slug: repositorySlugSchema,
+		baseSha: z.string().regex(/^[0-9a-f]{40}$/).describe("Immutable source commit to check out.")
+	}).describe("Explicit repository and immutable starting code."),
+	harness: z.enum([
+		"claude-code",
+		"codex",
+		"fx",
+		"pi"
+	]).describe("Configured V1 coding harness."),
+	prompt: z.string().min(1).max(32e3).describe("Bounded instructions captured before launching."),
+	allowedConstructs: z.array(z.string().min(1).max(128)).max(64).readonly().describe("Only the capabilities granted by the workflow."),
+	environment: z.strictObject({
+		snapshotId: z.string().min(1).max(2048).optional().describe("Optional immutable environment snapshot."),
+		timeoutMs: z.number().int().positive().describe("Maximum execution duration in milliseconds.")
+	}).describe("Reproducible environment policy."),
+	limits: z.strictObject({
+		maxTokens: z.number().int().positive().optional().describe("Maximum tokens for this execution."),
+		maxCostUsd: usdSchema.optional().describe("Maximum execution spend.")
+	}).describe("Adapter-enforced execution limits.")
+}).refine((value) => jsonValueSchema.safeParse(value).success, "Execution request must fit bounded work JSON");
+const executionResultFieldsSchema = z.strictObject({
+	execution: executionReferenceSchema,
+	artifacts,
+	usage: z.strictObject({
+		inputTokens: z.number().int().nonnegative().optional().describe("Total input tokens for this attempt."),
+		outputTokens: z.number().int().nonnegative().optional().describe("Total output tokens for this attempt."),
+		computeMs: z.number().int().nonnegative().describe("Observed compute duration."),
+		costUsd: usdSchema.optional().describe("Observed attempt cost; absent means unknown, never free.")
+	}).describe("Cumulative usage for this attempt, recorded once."),
+	reason: z.string().min(1).max(2e3).optional().describe("Human-readable outcome explanation.")
+});
+/** Validates a provider outcome and cumulative usage without inferring Task success. */
+const executionResultSchema = z.discriminatedUnion("status", [
+	executionResultFieldsSchema.extend({ status: z.literal("completed").describe("The provider completed its bounded execution.") }),
+	executionResultFieldsSchema.extend({ status: z.literal("needs_input").describe("The provider requires additional input.") }),
+	executionResultFieldsSchema.extend({ status: z.literal("cancelled").describe("The execution was cancelled.") }),
+	executionResultFieldsSchema.extend({
+		status: z.literal("failed").describe("The execution failed."),
+		failureCode: z.literal("missing_output").optional().describe("Required output was absent. Workflow policy, not this code, authorizes replacement.")
+	})
+]).refine((value) => jsonValueSchema.safeParse(value).success, "Execution result must fit bounded work JSON");
+/** Constructs and validates a Task identity with its positive execution-attempt fence. */
+function taskAttemptRef(taskId, attempt) {
+	return taskAttemptRefSchema.parse({
+		taskId,
+		attempt
+	});
+}
+/** Converts a Task-shaped value into the canonical Task identity and attempt fence. */
+function taskAttemptRefFromTask(task) {
+	return taskAttemptRef(task.id, task.attempt);
+}
+//#endregion
+export { codingExecutionRequestSchema, executionArtifactSchema, executionLaunchKeySchema, executionResultSchema, taskAttemptRef, taskAttemptRefFromTask, taskAttemptRefSchema };
+
+//# sourceMappingURL=execution.mjs.map

package/dist/schema/execution.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution.mjs","names":[],"sources":["../../src/schema/execution.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { usdSchema } from \"./common\";\nimport { taskIdSchema, type TaskId } from \"./id\";\nimport { repositorySlugSchema } from \"./repository\";\nimport { jsonValueSchema } from \"./work\";\n\nimport { executionReferenceSchema } from \"./task\";\n\n/** Validates a durable evidence reference returned by an execution provider. */\nexport const executionArtifactSchema = z.strictObject({\n  kind: z.enum([\"patch\", \"report\", \"log\"]).describe(\"Evidence artifact type.\"),\n  ref: z\n    .string()\n    .min(1)\n    .max(2048)\n    .describe(\"Durable artifact reference; grants no read authority.\"),\n});\nconst artifacts = z\n  .array(executionArtifactSchema)\n  .max(32)\n  .readonly()\n  .describe(\"Bounded durable evidence references.\");\n/** Validates a Task ID and execution-attempt fence that must travel together. */\nconst taskAttemptRefFields = {\n  taskId: taskIdSchema.describe(\"Task that owns the operation.\"),\n  attempt: z.number().int().positive().describe(\"Current Task execution attempt.\"),\n} as const;\n/** Validates a Task identity paired with its positive execution-attempt fence. */\nexport const taskAttemptRefSchema = z.strictObject(taskAttemptRefFields).readonly();\n\n/** Stable provider idempotency key derived from one exact Task attempt. */\nexport type ExecutionLaunchKey = `factory-task:${TaskId}:${number}`;\n/** Validates the stable provider idempotency key for one exact Task attempt. */\nexport const executionLaunchKeySchema = z\n  .string()\n  .regex(\n    /^factory-task:task_[a-z0-9]{6,64}:[1-9]\\d*$/u,\n    \"Expected factory-task:<task-id>:<positive-attempt>\",\n  ) as z.ZodType<ExecutionLaunchKey, string>;\n\n/** Validates the immutable, bounded coding request captured before provider execution. */\nexport const codingExecutionRequestSchema = z\n  .strictObject({\n    ...taskAttemptRefFields,\n    repository: z\n      .strictObject({\n        slug: repositorySlugSchema,\n        baseSha: z\n          .string()\n          .regex(/^[0-9a-f]{40}$/)\n          .describe(\"Immutable source commit to check out.\"),\n      })\n      .describe(\"Explicit repository and immutable starting code.\"),\n    harness: z.enum([\"claude-code\", \"codex\", \"fx\", \"pi\"]).describe(\"Configured V1 coding harness.\"),\n    prompt: z\n      .string()\n      .min(1)\n      .max(32_000)\n      .describe(\"Bounded instructions captured before launching.\"),\n    allowedConstructs: z\n      .array(z.string().min(1).max(128))\n      .max(64)\n      .readonly()\n      .describe(\"Only the capabilities granted by the workflow.\"),\n    environment: z\n      .strictObject({\n        snapshotId: z\n          .string()\n          .min(1)\n          .max(2048)\n          .optional()\n          .describe(\"Optional immutable environment snapshot.\"),\n        timeoutMs: z\n          .number()\n          .int()\n          .positive()\n          .describe(\"Maximum execution duration in milliseconds.\"),\n      })\n      .describe(\"Reproducible environment policy.\"),\n    limits: z\n      .strictObject({\n        maxTokens: z\n          .number()\n          .int()\n          .positive()\n          .optional()\n          .describe(\"Maximum tokens for this execution.\"),\n        maxCostUsd: usdSchema.optional().describe(\"Maximum execution spend.\"),\n      })\n      .describe(\"Adapter-enforced execution limits.\"),\n  })\n  .refine(\n    (value) => jsonValueSchema.safeParse(value).success,\n    \"Execution request must fit bounded work JSON\",\n  );\n\nconst executionResultFieldsSchema = z.strictObject({\n  execution: executionReferenceSchema,\n  artifacts,\n  usage: z\n    .strictObject({\n      inputTokens: z\n        .number()\n        .int()\n        .nonnegative()\n        .optional()\n        .describe(\"Total input tokens for this attempt.\"),\n      outputTokens: z\n        .number()\n        .int()\n        .nonnegative()\n        .optional()\n        .describe(\"Total output tokens for this attempt.\"),\n      computeMs: z.number().int().nonnegative().describe(\"Observed compute duration.\"),\n      costUsd: usdSchema\n        .optional()\n        .describe(\"Observed attempt cost; absent means unknown, never free.\"),\n    })\n    .describe(\"Cumulative usage for this attempt, recorded once.\"),\n  reason: z.string().min(1).max(2000).optional().describe(\"Human-readable outcome explanation.\"),\n});\n\ntype ExecutionResultFields = z.infer<typeof executionResultFieldsSchema>;\n\n/** Provider outcome, evidence references, and cumulative usage for one execution attempt. */\nexport type ExecutionResult = ExecutionResultFields &\n  (\n    | { status: \"completed\"; failureCode?: never }\n    | { status: \"needs_input\"; failureCode?: never }\n    | { status: \"cancelled\"; failureCode?: never }\n    | { status: \"failed\"; failureCode?: \"missing_output\" }\n  );\n\n/** Validates a provider outcome and cumulative usage without inferring Task success. */\nexport const executionResultSchema = z\n  .discriminatedUnion(\"status\", [\n    executionResultFieldsSchema.extend({\n      status: z.literal(\"completed\").describe(\"The provider completed its bounded execution.\"),\n    }),\n    executionResultFieldsSchema.extend({\n      status: z.literal(\"needs_input\").describe(\"The provider requires additional input.\"),\n    }),\n    executionResultFieldsSchema.extend({\n      status: z.literal(\"cancelled\").describe(\"The execution was cancelled.\"),\n    }),\n    executionResultFieldsSchema.extend({\n      status: z.literal(\"failed\").describe(\"The execution failed.\"),\n      failureCode: z\n        .literal(\"missing_output\")\n        .optional()\n        .describe(\n          \"Required output was absent. Workflow policy, not this code, authorizes replacement.\",\n        ),\n    }),\n  ])\n  .refine(\n    (value) => jsonValueSchema.safeParse(value).success,\n    \"Execution result must fit bounded work JSON\",\n  ) as z.ZodType<ExecutionResult>;\n\n/** Task identity and attempt fence used by execution operations and launch keys. */\nexport type TaskAttemptRef = z.infer<typeof taskAttemptRefSchema>;\n/** Constructs and validates a Task identity with its positive execution-attempt fence. */\nexport function taskAttemptRef(taskId: TaskAttemptRef[\"taskId\"], attempt: number): TaskAttemptRef {\n  return taskAttemptRefSchema.parse({ taskId, attempt });\n}\n/** Converts a Task-shaped value into the canonical Task identity and attempt fence. */\nexport function taskAttemptRefFromTask(\n  task: Pick<import(\"./task\").Task, \"id\" | \"attempt\">,\n): TaskAttemptRef {\n  return taskAttemptRef(task.id, task.attempt);\n}\n/** Immutable repository, harness, capability, environment, and limit request for one coding Task attempt. */\nexport type CodingExecutionRequest = z.infer<typeof codingExecutionRequestSchema>;\n/** Durable evidence reference returned by an execution provider. */\nexport type ExecutionArtifact = z.infer<typeof executionArtifactSchema>;\n"],"mappings":"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"}

package/dist/schema/factory-config.d.mts

@@ -0,0 +1,122 @@
+import { RepositorySlug } from "./repository.mjs";
+import { TaskKind } from "./task.mjs";
+import { z } from "zod";
+//#region src/schema/factory-config.d.ts
+/** Validates one repository allowlist entry and its configured dependency ordering. */
+declare const factoryConfigRepositorySchema: z.ZodReadonly<z.ZodObject<{
+  slug: z.ZodType<`${string}/${string}`, string, z.core.$ZodTypeInternals<`${string}/${string}`, string>>;
+  defaultBranch: z.ZodDefault<z.ZodString>;
+  dependsOn: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodType<`${string}/${string}`, string, z.core.$ZodTypeInternals<`${string}/${string}`, string>>>>>;
+}, z.core.$strict>>;
+declare const githubConnectorSchema: z.ZodReadonly<z.ZodObject<{
+  owner: z.ZodString;
+  connector: z.ZodString;
+}, z.core.$strict>>;
+declare const slackConnectorSchema: z.ZodReadonly<z.ZodObject<{
+  connector: z.ZodString;
+  operatorDirectMessages: z.ZodDefault<z.ZodBoolean>;
+  approvalChannel: z.ZodOptional<z.ZodString>;
+  autonomousPullRequests: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+    channelId: z.ZodString;
+    mentionUserIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>>>;
+  autonomousPullRequestsByRepository: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodType<`${string}/${string}`, string, z.core.$ZodTypeInternals<`${string}/${string}`, string>>, z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+    channelId: z.ZodString;
+    mentionUserIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>>>>>>;
+}, z.core.$strict>>;
+/** Validates stall detection and replacement-attempt limits for running Tasks. */
+declare const executionPolicySchema: z.ZodReadonly<z.ZodObject<{
+  maxAttempts: z.ZodNumber;
+  stallMinutes: z.ZodNumber;
+  stallMinutesByKind: z.ZodDefault<z.ZodReadonly<z.ZodRecord<z.ZodType<TaskKind, unknown, z.core.$ZodTypeInternals<TaskKind, unknown>> & z.core.$partial, z.ZodNumber>>>;
+}, z.core.$strict>>;
+/** Stall detection and retry limits applied to running Tasks. */
+type ExecutionPolicy = z.infer<typeof executionPolicySchema>;
+/** Conservative default stall window and three-attempt execution policy. */
+declare const defaultExecutionPolicy: Readonly<{
+  maxAttempts: number;
+  stallMinutes: number;
+  stallMinutesByKind: Readonly<Partial<Record<TaskKind, number>>>;
+}>;
+/** Validates the repositories, operators, connectors, budget, and policies of a Factory. */
+declare const factoryConfigSchema: z.ZodReadonly<z.ZodObject<{
+  connectors: z.ZodDefault<z.ZodReadonly<z.ZodObject<{
+    github: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+      owner: z.ZodString;
+      connector: z.ZodString;
+    }, z.core.$strict>>>>;
+    slack: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+      connector: z.ZodString;
+      operatorDirectMessages: z.ZodDefault<z.ZodBoolean>;
+      approvalChannel: z.ZodOptional<z.ZodString>;
+      autonomousPullRequests: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        channelId: z.ZodString;
+        mentionUserIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+      }, z.core.$strict>>>;
+      autonomousPullRequestsByRepository: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodType<`${string}/${string}`, string, z.core.$ZodTypeInternals<`${string}/${string}`, string>>, z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+        channelId: z.ZodString;
+        mentionUserIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+      }, z.core.$strict>>>>>>;
+    }, z.core.$strict>>>>>;
+  }, z.core.$strict>>>;
+  repositories: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    slug: z.ZodType<`${string}/${string}`, string, z.core.$ZodTypeInternals<`${string}/${string}`, string>>;
+    defaultBranch: z.ZodDefault<z.ZodString>;
+    dependsOn: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodType<`${string}/${string}`, string, z.core.$ZodTypeInternals<`${string}/${string}`, string>>>>>;
+  }, z.core.$strict>>>>;
+  operators: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+  sandboxGitHubCredentials: z.ZodDefault<z.ZodEnum<{
+    connect: "connect";
+    vercel: "vercel";
+  }>>;
+  commitIdentity: z.ZodDefault<z.ZodReadonly<z.ZodObject<{
+    name: z.ZodString;
+    email: z.ZodString;
+  }, z.core.$strict>>>;
+  approval: z.ZodDefault<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    source: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    require: z.ZodBoolean;
+  }, z.core.$strict>>>>>;
+  budget: z.ZodDefault<z.ZodReadonly<z.ZodObject<{
+    totalUsd: z.ZodNumber;
+    investigationUsd: z.ZodNumber;
+    perTaskReservationUsd: z.ZodNumber;
+    warningPercent: z.ZodNumber;
+    perRepositoryUsd: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodType<`${string}/${string}`, string, z.core.$ZodTypeInternals<`${string}/${string}`, string>>, z.ZodNumber>>>;
+  }, z.core.$strict>>>;
+  enforceBudget: z.ZodDefault<z.ZodBoolean>;
+  execution: z.ZodDefault<z.ZodReadonly<z.ZodObject<{
+    maxAttempts: z.ZodNumber;
+    stallMinutes: z.ZodNumber;
+    stallMinutesByKind: z.ZodDefault<z.ZodReadonly<z.ZodRecord<z.ZodType<TaskKind, unknown, z.core.$ZodTypeInternals<TaskKind, unknown>> & z.core.$partial, z.ZodNumber>>>;
+  }, z.core.$strict>>>;
+}, z.core.$strict>>;
+/** Fully resolved repository allowlist entry in a Factory configuration. */
+type FactoryConfigRepository = z.infer<typeof factoryConfigRepositorySchema>;
+/** Fully resolved and validated Factory configuration. */
+type FactoryConfig = z.infer<typeof factoryConfigSchema>;
+type FactoryConfigSchemaInput = z.input<typeof factoryConfigSchema>;
+type FactoryConfigConnectorsInput = Readonly<{
+  github: readonly Readonly<z.input<typeof githubConnectorSchema>>[];
+  slack?: readonly Readonly<z.input<typeof slackConnectorSchema>>[];
+}>;
+/** Repository allowlist entry accepted when defining a Factory, before defaults are applied. */
+type FactoryConfigRepositoryInput = Readonly<{
+  slug: RepositorySlug;
+  defaultBranch?: string;
+  dependsOn?: readonly RepositorySlug[];
+}>;
+/** Caller input accepted when defining a Factory, before schema defaults are applied. */
+type FactoryConfigInput = Readonly<Omit<FactoryConfigSchemaInput, "connectors" | "repositories" | "operators"> & {
+  connectors?: FactoryConfigConnectorsInput;
+  repositories: readonly FactoryConfigRepositoryInput[];
+  operators: readonly string[];
+}>;
+/** Validates a Factory configuration and applies its declared defaults. */
+declare function defineFactory(config: FactoryConfigInput): FactoryConfig;
+//#endregion
+export { ExecutionPolicy, FactoryConfig, FactoryConfigInput, FactoryConfigRepository, FactoryConfigRepositoryInput, defaultExecutionPolicy, defineFactory, executionPolicySchema, factoryConfigRepositorySchema, factoryConfigSchema };
+//# sourceMappingURL=factory-config.d.mts.map