@vibesdotdev/workers 0.0.0-stage → 1.0.0-rc.2

package/dist/graph/recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../../src/graph/recovery.ts"],"names":[],"mappings":"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"}

package/dist/graph/recovery.js

@@ -0,0 +1,53 @@
+import * as z from 'zod/v4';
+import { JsonObjectSchema, JsonValueSchema, keyedRecordSchema } from '@vibesdotdev/kernel/schemas/json';
+import { OutcomeSchema } from '@vibesdotdev/runnable/schemas/outcome';
+import { RunnableAttemptSchema as GraphAttemptReferenceSchema, RunnableAttemptFeedbackSchema as GraphAttemptFeedbackSchema } from '@vibesdotdev/runnable/schemas/runs';
+import { GraphDefinitionSchema, GraphExecutionPolicySchema, GraphAttemptPolicySchema } from "./schemas.js";
+export const GraphNodeResultSchema = z.object({
+    nodeId: z.string(), job: z.string(),
+    status: z.enum(['completed', 'failed', 'skipped', 'cancelled']),
+    result: JsonValueSchema.optional(), taskOutcome: OutcomeSchema.optional(),
+    jobId: z.string().optional(), revision: z.number().int().nonnegative().optional(),
+    nativeGeneration: z.number().int().nonnegative().optional(),
+    attempt: z.number().int().positive().optional(),
+    error: z.object({ message: z.string(), code: z.string().optional(), reason: z.string().optional(), retryable: z.boolean().optional(), details: JsonValueSchema.optional(), receiptObservation: JsonValueSchema.optional() }).optional(),
+    skipReason: z.enum(['condition', 'upstream-failed', 'upstream-skipped', 'graph-stopped', 'graph-cancelled']).optional()
+});
+export const GraphRecoveryPolicySchema = z.object({ maxAttempts: z.number().int().nonnegative() });
+export { GraphAttemptReferenceSchema, GraphAttemptFeedbackSchema };
+export const GraphReworkSchema = z.object({ id: z.string().min(1), input: JsonObjectSchema, reason: z.string().min(1) });
+export const GraphCoordinationResultSchema = z.object({
+    next: z.enum(['continue', 'stop']), rework: z.array(GraphReworkSchema).default([]), report: JsonValueSchema.optional(), outcome: OutcomeSchema.optional()
+});
+export const GraphCoordinationInputSchema = z.object({
+    step: z.number().int().nonnegative(), ids: z.array(z.string()),
+    results: keyedRecordSchema(GraphNodeResultSchema), inputs: keyedRecordSchema(JsonObjectSchema).default({}), reports: z.array(JsonValueSchema),
+    attempts: keyedRecordSchema(z.array(GraphAttemptReferenceSchema)).default({})
+});
+export const GraphNodeCheckpointSchema = z.object({
+    revision: z.number().int().nonnegative(), recoveries: z.number().int().nonnegative(),
+    localRetries: z.number().int().nonnegative().default(0),
+    attemptHistory: z.array(GraphNodeResultSchema).default([]),
+    nextAttempt: z.number().int().positive().default(1),
+    admission: z.object({ attempt: z.number().int().positive(), revision: z.number().int().nonnegative() }).optional(),
+    input: JsonObjectSchema, jobId: z.string().optional(),
+    /** Last queue generation bound to this semantic admission. */
+    nativeGeneration: z.number().int().nonnegative().optional(),
+    /** Exact input of a failed physical admission, retained for same-admission reentry. */
+    admittedInput: JsonObjectSchema.optional(),
+    consumed: keyedRecordSchema(z.number().int().nonnegative()),
+    result: GraphNodeResultSchema.optional(), superseded: z.array(GraphNodeResultSchema),
+    reworkReason: z.string().optional(), exhausted: z.boolean().default(false)
+});
+export const GraphCheckpointSchema = z.object({
+    executionId: z.string().min(1), definition: GraphDefinitionSchema,
+    recovery: GraphRecoveryPolicySchema, policy: GraphExecutionPolicySchema,
+    attempts: GraphAttemptPolicySchema.default({ maxRetries: 0, retryOn: ['not-done'] }),
+    nodes: keyedRecordSchema(GraphNodeCheckpointSchema),
+    step: z.number().int().nonnegative(), reports: z.array(JsonValueSchema),
+    changed: z.array(z.string()), stopped: z.boolean(), coordinationOutcome: OutcomeSchema.optional(),
+    /** Replay the same coordinator child after a crash; apply its requests only once. */
+    coordination: GraphCoordinationInputSchema.optional(),
+    requested: GraphCoordinationResultSchema.optional()
+});
+//# sourceMappingURL=recovery.js.map

package/dist/graph/recovery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.js","sourceRoot":"","sources":["../../src/graph/recovery.ts"],"names":[],"mappings":"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"}

package/dist/graph/schemas/checkpoint.d.ts

@@ -0,0 +1,6 @@
+import type { GraphCheckpoint } from '../recovery.ts';
+export interface GraphCheckpointPort {
+    load(): Promise<GraphCheckpoint | undefined>;
+    save(checkpoint: GraphCheckpoint): Promise<void>;
+}
+//# sourceMappingURL=checkpoint.d.ts.map

package/dist/graph/schemas/checkpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint.d.ts","sourceRoot":"","sources":["../../../src/graph/schemas/checkpoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEtD,MAAM,WAAW,mBAAmB;IACnC,IAAI,IAAI,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC,CAAC;IAC7C,IAAI,CAAC,UAAU,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjD"}

package/dist/graph/schemas/checkpoint.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checkpoint.js.map

package/dist/graph/schemas/checkpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint.js","sourceRoot":"","sources":["../../../src/graph/schemas/checkpoint.ts"],"names":[],"mappings":""}

package/dist/graph/schemas/native-admission.d.ts

@@ -0,0 +1,22 @@
+import * as z from 'zod/v4';
+import type { JsonObject } from '@vibesdotdev/kernel/schemas/json';
+/** Allocated by the scheduler before dispatch; physical redelivery retains this identity. */
+export declare const GraphAdmissionSchema: z.ZodObject<{
+    graphId: z.ZodString;
+    executionId: z.ZodString;
+    nodeId: z.ZodString;
+    revision: z.ZodNumber;
+    attempt: z.ZodNumber;
+}, z.core.$strip>;
+export type GraphAdmission = z.infer<typeof GraphAdmissionSchema>;
+export declare const GRAPH_ADMISSION_METADATA_KEY = "workers.graph";
+/** Queue-authoritative observation used to reconcile a retained physical failure. */
+export interface GraphNativeReceipt {
+    jobId: string;
+    generation: number;
+    status: 'delayed' | 'pending' | 'processing' | 'completed' | 'failed' | 'cancelled';
+    input: JsonObject;
+    admission: GraphAdmission;
+    executionClaim: 'none' | 'held' | 'unknown';
+}
+//# sourceMappingURL=native-admission.d.ts.map

package/dist/graph/schemas/native-admission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-admission.d.ts","sourceRoot":"","sources":["../../../src/graph/schemas/native-admission.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAEnE,6FAA6F;AAC7F,eAAO,MAAM,oBAAoB;;;;;;iBAG/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,eAAO,MAAM,4BAA4B,kBAAkB,CAAC;AAE5D,qFAAqF;AACrF,MAAM,WAAW,kBAAkB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,QAAQ,GAAG,WAAW,CAAC;IACpF,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE,cAAc,CAAC;IAC1B,cAAc,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CAC5C"}

package/dist/graph/schemas/native-admission.js

@@ -0,0 +1,8 @@
+import * as z from 'zod/v4';
+/** Allocated by the scheduler before dispatch; physical redelivery retains this identity. */
+export const GraphAdmissionSchema = z.object({
+    graphId: z.string().min(1), executionId: z.string().min(1), nodeId: z.string().min(1),
+    revision: z.number().int().nonnegative(), attempt: z.number().int().positive()
+});
+export const GRAPH_ADMISSION_METADATA_KEY = 'workers.graph';
+//# sourceMappingURL=native-admission.js.map

package/dist/graph/schemas/native-admission.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-admission.js","sourceRoot":"","sources":["../../../src/graph/schemas/native-admission.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,6FAA6F;AAC7F,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACrF,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;CAC9E,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,4BAA4B,GAAG,eAAe,CAAC"}

package/dist/graph/schemas.d.ts

@@ -0,0 +1,332 @@
+/**
+ * Workers job graph contract.
+ *
+ * A graph is a set of nodes (each one a `workers/job` run) joined by edges. An
+ * edge orders its target after its source, optionally carries a value from the
+ * source's result into a field of the target's input, and optionally gates the
+ * target on a condition over the source's result.
+ */
+import * as z from 'zod/v4';
+import { type Outcome } from '@vibesdotdev/runnable/schemas/outcome';
+import type { GraphCheckpoint, GraphCoordinationInput, GraphCoordinationResult } from './recovery.ts';
+import { JsonValueSchema, type JsonValue, type JsonObject } from '@vibesdotdev/kernel/schemas/json';
+import type { GraphCheckpointPort } from './schemas/checkpoint.ts';
+import type { GraphNativeReceipt } from './schemas/native-admission.ts';
+export { GraphAdmissionSchema, GRAPH_ADMISSION_METADATA_KEY } from './schemas/native-admission.ts';
+export type { GraphAdmission, GraphNativeReceipt } from './schemas/native-admission.ts';
+/** What an edge tests on its source node's result (the whole result when `path` is absent). */
+export declare const GraphConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"equals">;
+    path: z.ZodOptional<z.ZodString>;
+    value: z.ZodType<JsonValue, JsonValue, z.core.$ZodTypeInternals<JsonValue, JsonValue>>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"not-equals">;
+    path: z.ZodOptional<z.ZodString>;
+    value: z.ZodType<JsonValue, JsonValue, z.core.$ZodTypeInternals<JsonValue, JsonValue>>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"exists">;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"truthy">;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"falsy">;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "op">;
+export type GraphCondition = z.infer<typeof GraphConditionSchema>;
+/** Local semantic admissions, separate from physical job retries and coordinator rework. */
+export declare const GraphAttemptPolicySchema: z.ZodObject<{
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    retryOn: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        "not-done": "not-done";
+        disputed: "disputed";
+    }>>>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        op: z.ZodLiteral<"equals">;
+        path: z.ZodOptional<z.ZodString>;
+        value: z.ZodType<JsonValue, JsonValue, z.core.$ZodTypeInternals<JsonValue, JsonValue>>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"not-equals">;
+        path: z.ZodOptional<z.ZodString>;
+        value: z.ZodType<JsonValue, JsonValue, z.core.$ZodTypeInternals<JsonValue, JsonValue>>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"exists">;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"truthy">;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"falsy">;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "op">>;
+}, z.core.$strip>;
+export type GraphAttemptPolicy = z.output<typeof GraphAttemptPolicySchema>;
+export declare const GraphNodeSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    job: z.ZodString;
+    input: z.ZodDefault<z.ZodType<JsonObject, JsonObject, z.core.$ZodTypeInternals<JsonObject, JsonObject>>>;
+    metadata: z.ZodOptional<z.ZodType<JsonObject, JsonObject, z.core.$ZodTypeInternals<JsonObject, JsonObject>>>;
+    jobId: z.ZodOptional<z.ZodString>;
+    completion: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodLiteral<"outcome">;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    dependencyOutcomesInput: z.ZodOptional<z.ZodString>;
+    attemptFeedbackInput: z.ZodOptional<z.ZodString>;
+    attempts: z.ZodOptional<z.ZodObject<{
+        maxRetries: z.ZodDefault<z.ZodNumber>;
+        retryOn: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            "not-done": "not-done";
+            disputed: "disputed";
+        }>>>;
+        when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            op: z.ZodLiteral<"equals">;
+            path: z.ZodOptional<z.ZodString>;
+            value: z.ZodType<JsonValue, JsonValue, z.core.$ZodTypeInternals<JsonValue, JsonValue>>;
+        }, z.core.$strip>, z.ZodObject<{
+            op: z.ZodLiteral<"not-equals">;
+            path: z.ZodOptional<z.ZodString>;
+            value: z.ZodType<JsonValue, JsonValue, z.core.$ZodTypeInternals<JsonValue, JsonValue>>;
+        }, z.core.$strip>, z.ZodObject<{
+            op: z.ZodLiteral<"exists">;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            op: z.ZodLiteral<"truthy">;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            op: z.ZodLiteral<"falsy">;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "op">>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type GraphNode = z.input<typeof GraphNodeSchema>;
+export declare const GraphEdgeSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    output: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodString>;
+    when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        op: z.ZodLiteral<"equals">;
+        path: z.ZodOptional<z.ZodString>;
+        value: z.ZodType<JsonValue, JsonValue, z.core.$ZodTypeInternals<JsonValue, JsonValue>>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"not-equals">;
+        path: z.ZodOptional<z.ZodString>;
+        value: z.ZodType<JsonValue, JsonValue, z.core.$ZodTypeInternals<JsonValue, JsonValue>>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"exists">;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"truthy">;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"falsy">;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "op">>;
+}, z.core.$strip>;
+export type GraphEdge = z.input<typeof GraphEdgeSchema>;
+export declare const GraphFailurePolicySchema: z.ZodEnum<{
+    continue: "continue";
+    stop: "stop";
+    "skip-dependents": "skip-dependents";
+}>;
+export type GraphFailurePolicy = z.infer<typeof GraphFailurePolicySchema>;
+export declare const GraphExecutionPolicySchema: z.ZodObject<{
+    concurrency: z.ZodNumber;
+    failurePolicy: z.ZodEnum<{
+        continue: "continue";
+        stop: "stop";
+        "skip-dependents": "skip-dependents";
+    }>;
+}, z.core.$strip>;
+export declare const GraphDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        job: z.ZodString;
+        input: z.ZodDefault<z.ZodType<JsonObject, JsonObject, z.core.$ZodTypeInternals<JsonObject, JsonObject>>>;
+        metadata: z.ZodOptional<z.ZodType<JsonObject, JsonObject, z.core.$ZodTypeInternals<JsonObject, JsonObject>>>;
+        jobId: z.ZodOptional<z.ZodString>;
+        completion: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodLiteral<"outcome">;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        dependencyOutcomesInput: z.ZodOptional<z.ZodString>;
+        attemptFeedbackInput: z.ZodOptional<z.ZodString>;
+        attempts: z.ZodOptional<z.ZodObject<{
+            maxRetries: z.ZodDefault<z.ZodNumber>;
+            retryOn: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                "not-done": "not-done";
+                disputed: "disputed";
+            }>>>;
+            when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"equals">;
+                path: z.ZodOptional<z.ZodString>;
+                value: z.ZodType<JsonValue, JsonValue, z.core.$ZodTypeInternals<JsonValue, JsonValue>>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"not-equals">;
+                path: z.ZodOptional<z.ZodString>;
+                value: z.ZodType<JsonValue, JsonValue, z.core.$ZodTypeInternals<JsonValue, JsonValue>>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"exists">;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"truthy">;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"falsy">;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "op">>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    edges: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        output: z.ZodOptional<z.ZodString>;
+        input: z.ZodOptional<z.ZodString>;
+        when: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            op: z.ZodLiteral<"equals">;
+            path: z.ZodOptional<z.ZodString>;
+            value: z.ZodType<JsonValue, JsonValue, z.core.$ZodTypeInternals<JsonValue, JsonValue>>;
+        }, z.core.$strip>, z.ZodObject<{
+            op: z.ZodLiteral<"not-equals">;
+            path: z.ZodOptional<z.ZodString>;
+            value: z.ZodType<JsonValue, JsonValue, z.core.$ZodTypeInternals<JsonValue, JsonValue>>;
+        }, z.core.$strip>, z.ZodObject<{
+            op: z.ZodLiteral<"exists">;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            op: z.ZodLiteral<"truthy">;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            op: z.ZodLiteral<"falsy">;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "op">>;
+    }, z.core.$strip>>>;
+    cohorts: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodString>>>;
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    failurePolicy: z.ZodDefault<z.ZodEnum<{
+        continue: "continue";
+        stop: "stop";
+        "skip-dependents": "skip-dependents";
+    }>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$catchall<z.ZodType<JsonValue, JsonValue, z.core.$ZodTypeInternals<JsonValue, JsonValue>>>>>;
+}, z.core.$strip>;
+export type GraphDefinitionInput = z.input<typeof GraphDefinitionSchema>;
+export type GraphDefinition = z.output<typeof GraphDefinitionSchema>;
+export type GraphNodeStatus = 'completed' | 'failed' | 'skipped' | 'cancelled';
+export type GraphSkipReason = 'condition' | 'upstream-failed' | 'upstream-skipped' | 'graph-stopped' | 'graph-cancelled';
+export interface GraphNodeResult {
+    nodeId: string;
+    job: string;
+    status: GraphNodeStatus;
+    result?: JsonValue;
+    /** Declared task result, separate from transport completion. */
+    taskOutcome?: Outcome;
+    jobId?: string;
+    /** The physical queue generation that produced this result, when owner-observed. */
+    nativeGeneration?: number;
+    revision?: number;
+    /** Stable admission sequence; it is allocated before execution, not when the result arrives. */
+    attempt?: number;
+    /** `details` carries a typed refusal's JSON-safe context; `retryable` its own retry fact — absent for untyped failures or non-JSON details. */
+    error?: {
+        message: string;
+        code?: string;
+        reason?: string;
+        retryable?: boolean;
+        details?: JsonValue;
+        receiptObservation?: JsonValue;
+    };
+    skipReason?: GraphSkipReason;
+}
+export interface GraphRunResult {
+    graphId: string;
+    status: 'completed' | 'failed' | 'cancelled';
+    nodes: Record<string, GraphNodeResult>;
+    checkpoint?: GraphCheckpoint;
+    coordination?: Outcome;
+}
+/** Streamed to the caller as the graph runs. */
+export type GraphEvent = {
+    type: 'node-started';
+    nodeId: string;
+    job: string;
+} | {
+    type: 'node-event';
+    nodeId: string;
+    job: string;
+    event: string;
+    data: JsonValue;
+} | {
+    type: 'node-completed';
+    nodeId: string;
+    job: string;
+    result: JsonValue;
+    taskOutcome?: Outcome;
+} | {
+    type: 'node-failed';
+    nodeId: string;
+    job: string;
+    error: NonNullable<GraphNodeResult['error']>;
+} | {
+    type: 'node-cancelled';
+    nodeId: string;
+    job: string;
+} | {
+    type: 'node-skipped';
+    nodeId: string;
+    job: string;
+    reason: GraphSkipReason;
+} | {
+    type: 'graph-completed';
+    result: GraphRunResult;
+};
+export interface RunGraphOptions {
+    /** Cancels running node jobs and skips the nodes not yet started. */
+    signal?: AbortSignal;
+    /** Overrides the definition's concurrency. */
+    concurrency?: number;
+    /** Overrides the definition's failure policy. */
+    failurePolicy?: GraphFailurePolicy;
+    /**
+     * A parent running inside a job passes `JobExecutionContext.park` so the graph
+     * waits without holding the parent's queue slot.
+     */
+    park?: <T>(work: () => Promise<T>) => Promise<T>;
+    checkpoint?: GraphCheckpointPort;
+    recovery?: {
+        maxAttempts: number;
+    };
+    attempts?: z.input<typeof GraphAttemptPolicySchema>;
+    coordinate?: (input: GraphCoordinationInput) => Promise<GraphCoordinationResult>;
+}
+export interface ResolvedNode {
+    id: string;
+    job: string;
+    input: JsonObject;
+    metadata?: JsonObject;
+    jobId?: string;
+    completion?: {
+        mode: 'outcome';
+        path?: string;
+    };
+    dependencyOutcomesInput?: string;
+    attemptFeedbackInput?: string;
+    attempts?: GraphAttemptPolicy;
+}
+export interface ResolvedGraph {
+    definition: GraphDefinition;
+    nodes: ResolvedNode[];
+    edges: GraphDefinition['edges'];
+}
+export interface GraphExecutorDeps {
+    runNode(node: ResolvedNode, input: JsonObject, signal: AbortSignal, emit: (event: string, data: JsonValue) => void, admitted?: (jobId: string) => Promise<void>): Promise<z.input<typeof JsonValueSchema>>;
+    readNativeReceipt?(node: ResolvedNode, jobId: string): Promise<GraphNativeReceipt | undefined>;
+    emit?(event: GraphEvent): void;
+}
+//# sourceMappingURL=schemas.d.ts.map

package/dist/graph/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/graph/schemas.ts"],"names":[],"mappings":"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"}

package/dist/graph/schemas.js

@@ -0,0 +1,87 @@
+/**
+ * Workers job graph contract.
+ *
+ * A graph is a set of nodes (each one a `workers/job` run) joined by edges. An
+ * edge orders its target after its source, optionally carries a value from the
+ * source's result into a field of the target's input, and optionally gates the
+ * target on a condition over the source's result.
+ */
+import * as z from 'zod/v4';
+import {} from '@vibesdotdev/runnable/schemas/outcome';
+import { JsonValueSchema, JsonObjectSchema } from '@vibesdotdev/kernel/schemas/json';
+export { GraphAdmissionSchema, GRAPH_ADMISSION_METADATA_KEY } from "./schemas/native-admission.js";
+/** `a.b.c` addresses a nested field; segments are plain keys, never `__proto__`-style names. */
+const PathSchema = z.string().min(1).refine((path) => path.split('.').every((segment) => segment.length > 0 && segment !== '__proto__' && segment !== 'constructor' && segment !== 'prototype'), { message: 'path segments must be non-empty plain keys' });
+/** What an edge tests on its source node's result (the whole result when `path` is absent). */
+export const GraphConditionSchema = z.discriminatedUnion('op', [
+    z.object({ op: z.literal('equals'), path: PathSchema.optional(), value: JsonValueSchema }),
+    z.object({ op: z.literal('not-equals'), path: PathSchema.optional(), value: JsonValueSchema }),
+    z.object({ op: z.literal('exists'), path: PathSchema.optional() }),
+    z.object({ op: z.literal('truthy'), path: PathSchema.optional() }),
+    z.object({ op: z.literal('falsy'), path: PathSchema.optional() })
+]);
+/** Local semantic admissions, separate from physical job retries and coordinator rework. */
+export const GraphAttemptPolicySchema = z.object({
+    maxRetries: z.number().int().nonnegative().default(0),
+    retryOn: z.array(z.enum(['not-done', 'disputed'])).default(['not-done']),
+    when: GraphConditionSchema.optional()
+});
+export const GraphNodeSchema = z.object({
+    /** Unique within the graph; defaults to the job id when that is unique. */
+    id: z.string().min(1).optional(),
+    /** The `workers/job` descriptor id this node runs. */
+    job: z.string().min(1),
+    /** Static input; data edges write into it. */
+    input: JsonObjectSchema.default({}),
+    metadata: JsonObjectSchema.optional(),
+    /**
+     * The node job's admission id. A graph re-entered under the same ids (a resumed run) reattaches
+     * to each node's job: a completed node returns its stored result, a running one is followed.
+     */
+    jobId: z.string().min(1).optional(),
+    /** Explicit task mapping; native transport completion remains the default. */
+    completion: z.object({ mode: z.literal('outcome'), path: PathSchema.optional() }).optional(),
+    /** Refresh a target input object with current full task outcomes keyed by dependency id. */
+    dependencyOutcomesInput: PathSchema.optional(),
+    /** Next attempt's owner-recorded feedback, relative to this node's authored input. */
+    attemptFeedbackInput: PathSchema.optional(),
+    /** This node's admitted local policy overrides the graph default. */
+    attempts: GraphAttemptPolicySchema.optional()
+});
+export const GraphEdgeSchema = z.object({
+    from: z.string().min(1),
+    to: z.string().min(1),
+    /** Field of the source result to carry (the whole result when absent); read only with `input`. */
+    output: PathSchema.optional(),
+    /** Field of the target input to write; absent means the edge only orders and gates. */
+    input: PathSchema.optional(),
+    /** The target runs only when every incoming edge's condition holds. */
+    when: GraphConditionSchema.optional()
+});
+export const GraphFailurePolicySchema = z.enum(['stop', 'continue', 'skip-dependents']);
+export const GraphExecutionPolicySchema = z.object({
+    concurrency: z.number().int().min(1),
+    failurePolicy: GraphFailurePolicySchema
+});
+export const GraphDefinitionSchema = z.object({
+    id: z.string().min(1),
+    nodes: z.array(GraphNodeSchema),
+    edges: z.array(GraphEdgeSchema).default([]),
+    /** Planner-owned strongly connected groups; internal edges are omitted from admission ordering. */
+    cohorts: z.array(z.array(z.string().min(1)).min(1)).default([]),
+    /** Most nodes running at once. */
+    concurrency: z.number().int().min(1).default(4),
+    /**
+     * `stop`: the first failure cancels running nodes and skips the rest.
+     * `skip-dependents`: dependents of a failed node are skipped; independent nodes continue.
+     * `continue`: dependents still run; data edges from the failed node supply nothing and
+     * conditioned edges from it do not hold.
+     */
+    failurePolicy: GraphFailurePolicySchema.default('stop'),
+    metadata: z.object({
+        name: z.string().optional(),
+        description: z.string().optional(),
+        tags: z.array(z.string()).optional()
+    }).catchall(JsonValueSchema).optional()
+});
+//# sourceMappingURL=schemas.js.map

package/dist/graph/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../src/graph/schemas.ts"],"names":[],"mappings":"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"}

package/dist/graph/stream.d.ts

@@ -0,0 +1,8 @@
+/** Turns the executor's push events into an async iterable that cancels the graph when abandoned. */
+import type { GraphEvent, GraphRunResult, RunGraphOptions } from './schemas.ts';
+/**
+ * `start` runs the graph with the given `emit` and abort signal. Breaking out of
+ * the iteration, or throwing in the loop body, aborts the graph.
+ */
+export declare function createGraphEventStream(options: RunGraphOptions, start: (emit: (event: GraphEvent) => void, signal: AbortSignal) => Promise<GraphRunResult>): AsyncGenerator<GraphEvent>;
+//# sourceMappingURL=stream.d.ts.map

package/dist/graph/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/graph/stream.ts"],"names":[],"mappings":"AAAA,qGAAqG;AAGrG,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEhF;;;GAGG;AACH,wBAAuB,sBAAsB,CAC5C,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,cAAc,CAAC,GACxF,cAAc,CAAC,UAAU,CAAC,CAuC5B"}

package/dist/graph/stream.js

@@ -0,0 +1,52 @@
+/** Turns the executor's push events into an async iterable that cancels the graph when abandoned. */
+import { settle } from '@vibesdotdev/kernel';
+/**
+ * `start` runs the graph with the given `emit` and abort signal. Breaking out of
+ * the iteration, or throwing in the loop body, aborts the graph.
+ */
+export async function* createGraphEventStream(options, start) {
+    const abandon = new AbortController();
+    const onCaller = () => abandon.abort();
+    options.signal?.addEventListener('abort', onCaller, { once: true });
+    if (options.signal?.aborted)
+        abandon.abort();
+    const pending = [];
+    let wake;
+    let failure;
+    let done = false;
+    const notify = () => {
+        const resume = wake;
+        wake = undefined;
+        resume?.();
+    };
+    const running = settle(() => start((event) => {
+        pending.push(event);
+        notify();
+    }, abandon.signal)).then((outcome) => {
+        if (!outcome.ok)
+            failure = outcome.cause;
+        done = true;
+        notify();
+    });
+    try {
+        while (!done || pending.length > 0) {
+            const event = pending.shift();
+            if (event) {
+                yield event;
+                continue;
+            }
+            await new Promise((resolve) => {
+                wake = resolve;
+            });
+        }
+        if (failure)
+            throw failure;
+    }
+    finally {
+        options.signal?.removeEventListener('abort', onCaller);
+        if (!done)
+            abandon.abort();
+        await running;
+    }
+}
+//# sourceMappingURL=stream.js.map