@method-ai-hq/sdk 0.0.0-stage → 0.14.3

package/dist/packages/workflow-language/src/inspection.js

@@ -0,0 +1,130 @@
+import { AttachedFileSchema, MAX_RESULT_FILES } from "./result-files.js";
+import { z } from "zod";
+import { JsonSchema, WorkflowSchema, effectiveOutputs, executionText } from "./schema.js";
+import { producers, references, referenceShape } from "./validate.js";
+export const FailureSchema = z.strictObject({ phase: z.enum(["environment", "input", "action", "check", "change"]), expected: z.string(), observed: z.string(), evidence: z.array(z.string()) });
+// What a script process was seen to do (runtime observed_effects): hosts, paths, variable names, and program names.
+const observedList = z.array(z.string()).max(200);
+export const ObservedEffectsSchema = z.union([
+    z.strictObject({ network: observedList, reads: observedList, writes: observedList, env: observedList, runs: observedList, truncated: z.literal(true).optional() }),
+    z.strictObject({ unavailable: z.string() }),
+]);
+export const RunEventSchema = z.strictObject({
+    provider: z.string().optional(), model: z.string().optional(), kind: z.literal('classify').optional(),
+    request_id: z.string().optional(), operation_id: z.string().optional(), confidence: z.number().finite().min(0).max(1).nullable().optional(),
+    usage: z.strictObject({ input_tokens: z.number().int().nonnegative(), output_tokens: z.number().int().nonnegative(), cost: z.number().finite().nonnegative().optional() }).nullable().optional(),
+    duration_ms: z.number().finite().nonnegative().optional(),
+    at: z.string(), type: z.string(), detail: z.string().optional(),
+    sequence: z.number().int().nonnegative().optional(), phase: z.enum(["action", "check"]).optional(),
+    tool: z.string().optional(), call_id: z.string().optional(), command: z.string().optional(),
+    exit_code: z.number().int().nullable().optional(), diagnostics: z.string().optional(),
+    child: z.string().max(100).optional(), completed: z.number().int().nonnegative().optional(),
+    total: z.number().int().positive().optional(), unit: z.string().max(50).optional(),
+});
+export const InspectionSchema = z.strictObject({
+    started_at: z.string().optional(), device_name: z.string().optional(),
+    local_run_directory: z.string().optional(),
+    // run_data: device. The run's content stays on the device that ran it.
+    content: z.literal("device").optional(),
+    schema: z.literal("workflow-inspection/2"), workflow: WorkflowSchema, run_id: z.string(), status: z.string(), error: z.string().optional(), failure: FailureSchema.optional(),
+    inputs: z.record(JsonSchema), state: z.record(JsonSchema).optional(), resources: z.record(z.strictObject({ description: z.string(), setup: z.string().optional(), path: z.string().optional() })),
+    environment: z.record(z.object({ result: z.enum(["pass", "fail", "ambiguous"]), summary: z.string(), evidence: z.array(z.string()) })).optional(),
+    files: z.array(AttachedFileSchema).max(MAX_RESULT_FILES).optional(),
+    events: z.array(RunEventSchema).optional(),
+    invocations: z.record(z.strictObject({
+        step_id: z.string(), status: z.string(), verification: z.enum(["checked", "unchecked"]).optional(), error: z.string().optional(), failure: FailureSchema.optional(), inputs: z.record(JsonSchema).optional(), outputs: z.record(JsonSchema).optional(),
+        checks: z.array(z.object({ id: z.string(), result: z.enum(["pass", "fail", "ambiguous"]), summary: z.string(), evidence: z.array(z.string()), method: z.string() })), changes: z.record(JsonSchema),
+        prompts: z.array(z.strictObject({ sequence: z.number().int(), phase: z.enum(["action", "check"]), template: z.string(), rendered: z.string() })).optional(),
+        events: z.array(RunEventSchema),
+        observed_effects: ObservedEffectsSchema.optional(),
+    }))
+});
+export function label(value) { return value.replace(/[_-]+/g, " ").trim(); }
+export function stepTitle(step, id = "Step") { return step.name ?? label(id); }
+export function canonical(value) {
+    const sort = (v) => Array.isArray(v) ? v.map(sort) : v && typeof v === "object" ? Object.fromEntries(Object.keys(v).sort().map(k => [k, sort(v[k])])) : v;
+    return JSON.stringify(sort(value));
+}
+export function inspectCatalog(workflow) {
+    const items = new Map();
+    const producer = producers(workflow);
+    function itemFor(ref) {
+        if (items.has(ref))
+            return items.get(ref);
+        const parts = ref.split("."), root = parts[0];
+        const definition = root === "environment" ? workflow.environment?.[parts[1]] : root === "inputs" ? workflow.inputs?.[parts[1]] : root === "state" ? workflow.state?.[parts[1]] : effectiveOutputs(workflow.steps[producer.get(root) ?? ""] ?? {})[root];
+        const shape = referenceShape(workflow, ref);
+        const item = { id: ref, name: label(parts.at(-1)), description: definition?.description ?? "The time this run started.", kind: root === "environment" ? `${definition?.type} connection` : typeof shape === "string" ? shape : shape?.type ?? "connection", ...(shape ? { shape } : {}), createdBy: producer.has(root) ? [producer.get(root)] : [], usedBy: [], checkedBy: [], changedBy: [] };
+        items.set(ref, item);
+        return item;
+    }
+    for (const section of ["inputs", "state", "environment"])
+        for (const name of Object.keys(workflow[section] ?? {}))
+            itemFor(`${section}.${name}`);
+    for (const name of producer.keys())
+        itemFor(name);
+    for (const [id, step] of Object.entries(workflow.steps)) {
+        for (const ref of references(step)) {
+            const item = itemFor(ref);
+            item.usedBy.push(id);
+            if (step.check)
+                item.checkedBy.push(id);
+        }
+        for (const name of Object.keys(effectiveOutputs(step)))
+            if (step.check)
+                itemFor(name).checkedBy.push(id);
+        for (const target of step.changes ?? []) {
+            itemFor(target).changedBy.push(id);
+            if (step.check)
+                itemFor(target).checkedBy.push(id);
+        }
+    }
+    for (const item of items.values()) {
+        item.usedBy = [...new Set(item.usedBy)];
+        item.checkedBy = [...new Set(item.checkedBy)];
+        item.changedBy = [...new Set(item.changedBy)];
+    }
+    return { items, itemFor };
+}
+export function copyInstructions(step, inputs, resources) {
+    return [executionText(step), inputs ? `Inputs:\n${JSON.stringify(inputs, null, 2)}` : `Supply these named inputs before running:\n${JSON.stringify({ ...step.in, ...step.each }, null, 2)}`, `Return:\n${JSON.stringify(effectiveOutputs(step), null, 2)}`, ...(resources ? [`Connections:\n${JSON.stringify(resources, null, 2)}`] : [])].join("\n\n");
+}
+export function observedValue(item, inspection, invocation) {
+    const [root, ...parts] = item.id.split(".");
+    let value;
+    if (root === "inputs")
+        value = inspection.inputs;
+    else if (root === "state")
+        value = inspection.state;
+    else if (root === "environment")
+        value = inspection.resources;
+    else {
+        const rows = Object.entries(inspection.invocations).filter(([id, row]) => item.createdBy.includes(row.step_id) && (!invocation || id === invocation));
+        if (!rows.length)
+            return undefined;
+        value = rows.length === 1 ? rows[0][1].outputs?.[root] : rows.map(([, row]) => row.outputs?.[root] ?? null);
+    }
+    for (const part of parts) {
+        if (!value || !Object.hasOwn(value, part))
+            return undefined;
+        value = value[part];
+    }
+    return value;
+}
+/**
+ * The device form of a run record (run_data: device). Keep step status, kinds, names, and timing., kinds, names, and timing. Remove inputs, outputs,
+ * prompts, files, and free text. The server accepts only this form when an organization keeps run content on devices.
+ */
+export function deviceOnly(inspection) {
+    const event = ({ at, type, sequence, phase, duration_ms, usage, provider, model, kind, exit_code }) => Object.fromEntries(Object.entries({ at, type, sequence, phase, duration_ms, usage, provider, model, kind, exit_code }).filter(([, value]) => value !== undefined));
+    return {
+        schema: inspection.schema, content: 'device', workflow: inspection.workflow, run_id: inspection.run_id, status: inspection.status,
+        ...(inspection.started_at ? { started_at: inspection.started_at } : {}), ...(inspection.device_name ? { device_name: inspection.device_name } : {}),
+        inputs: {}, resources: Object.fromEntries(Object.entries(inspection.resources).map(([name, value]) => [name, { description: value.description }])),
+        ...(inspection.events ? { events: inspection.events.map(event) } : {}),
+        invocations: Object.fromEntries(Object.entries(inspection.invocations).map(([id, value]) => [id, {
+                step_id: value.step_id, status: value.status, ...(value.verification ? { verification: value.verification } : {}),
+                checks: value.checks.map(check => ({ id: check.id, result: check.result, summary: '', evidence: [], method: check.method })), changes: {}, events: value.events.map(event),
+            }])),
+    };
+}

package/dist/packages/workflow-language/src/result-files.d.ts

@@ -0,0 +1,160 @@
+import { z } from "zod";
+export declare const MAX_RESULT_FILES = 20000;
+export declare const MAX_RESULT_BYTES = 100000000;
+export declare const MAX_RESULT_TRANSFER_BYTES = 20000000;
+export declare const ResultPathSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const WebsiteFileSchema: z.ZodObject<{
+    path: z.ZodEffects<z.ZodString, string, string>;
+    sha256: z.ZodString;
+    media_type: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    sha256: string;
+    path: string;
+    media_type: string;
+}, {
+    sha256: string;
+    path: string;
+    media_type: string;
+}>;
+/** A declared file output with format: method-website contains this manifest. */
+export declare const WebsiteManifestSchema: z.ZodEffects<z.ZodObject<{
+    schema: z.ZodLiteral<"method-website/1">;
+    title: z.ZodString;
+    entrypoint: z.ZodEffects<z.ZodString, string, string>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodEffects<z.ZodString, string, string>;
+        sha256: z.ZodString;
+        media_type: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        sha256: string;
+        path: string;
+        media_type: string;
+    }, {
+        sha256: string;
+        path: string;
+        media_type: string;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    files: {
+        sha256: string;
+        path: string;
+        media_type: string;
+    }[];
+    schema: "method-website/1";
+    title: string;
+    entrypoint: string;
+}, {
+    files: {
+        sha256: string;
+        path: string;
+        media_type: string;
+    }[];
+    schema: "method-website/1";
+    title: string;
+    entrypoint: string;
+}>, {
+    files: {
+        sha256: string;
+        path: string;
+        media_type: string;
+    }[];
+    schema: "method-website/1";
+    title: string;
+    entrypoint: string;
+}, {
+    files: {
+        sha256: string;
+        path: string;
+        media_type: string;
+    }[];
+    schema: "method-website/1";
+    title: string;
+    entrypoint: string;
+}>;
+export declare const AttachedFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    sha256: z.ZodString;
+    status: z.ZodEnum<["verified", "unavailable"]>;
+    observed_at: z.ZodString;
+    text: z.ZodOptional<z.ZodString>;
+    bytes: z.ZodOptional<z.ZodNumber>;
+    reason: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    media_type: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodString>;
+    encoding: z.ZodOptional<z.ZodLiteral<"gzip">>;
+    stored: z.ZodOptional<z.ZodBoolean>;
+    website: z.ZodOptional<z.ZodObject<{
+        entrypoint: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            sha256: z.ZodString;
+            media_type: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            sha256: string;
+            path: string;
+            media_type: string;
+        }, {
+            sha256: string;
+            path: string;
+            media_type: string;
+        }>, "many">;
+    }, "strict", z.ZodTypeAny, {
+        files: {
+            sha256: string;
+            path: string;
+            media_type: string;
+        }[];
+        entrypoint: string;
+    }, {
+        files: {
+            sha256: string;
+            path: string;
+            media_type: string;
+        }[];
+        entrypoint: string;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    sha256: string;
+    status: "verified" | "unavailable";
+    path: string;
+    observed_at: string;
+    text?: string | undefined;
+    bytes?: number | undefined;
+    encoding?: "gzip" | undefined;
+    media_type?: string | undefined;
+    title?: string | undefined;
+    reason?: string | undefined;
+    data?: string | undefined;
+    stored?: boolean | undefined;
+    website?: {
+        files: {
+            sha256: string;
+            path: string;
+            media_type: string;
+        }[];
+        entrypoint: string;
+    } | undefined;
+}, {
+    sha256: string;
+    status: "verified" | "unavailable";
+    path: string;
+    observed_at: string;
+    text?: string | undefined;
+    bytes?: number | undefined;
+    encoding?: "gzip" | undefined;
+    media_type?: string | undefined;
+    title?: string | undefined;
+    reason?: string | undefined;
+    data?: string | undefined;
+    stored?: boolean | undefined;
+    website?: {
+        files: {
+            sha256: string;
+            path: string;
+            media_type: string;
+        }[];
+        entrypoint: string;
+    } | undefined;
+}>;
+export type AttachedFile = z.infer<typeof AttachedFileSchema>;

package/dist/packages/workflow-language/src/result-files.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+// Bound both decoded content and compressed transfer size.
+export const MAX_RESULT_FILES = 20_000;
+export const MAX_RESULT_BYTES = 100_000_000;
+export const MAX_RESULT_TRANSFER_BYTES = 20_000_000;
+const hash = z.string().regex(/^[a-f0-9]{64}$/);
+export const ResultPathSchema = z
+    .string()
+    .min(1)
+    .max(500)
+    .refine((path) => !path.startsWith("/") &&
+    !path.includes("\\") &&
+    !path
+        .split("/")
+        .some((part) => !part || part === "." || part === "..") &&
+    !/[?#%\x00-\x1f]/.test(path), "Use a relative file path without parent directories.");
+export const WebsiteFileSchema = z.strictObject({
+    path: ResultPathSchema,
+    sha256: hash,
+    media_type: z.string().regex(/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/),
+});
+/** A declared file output with format: method-website contains this manifest. */
+export const WebsiteManifestSchema = z
+    .strictObject({
+    schema: z.literal("method-website/1"),
+    title: z.string().min(1).max(160),
+    entrypoint: ResultPathSchema,
+    files: z.array(WebsiteFileSchema).min(1).max(MAX_RESULT_FILES),
+})
+    .superRefine((value, ctx) => {
+    if (new Set(value.files.map((file) => file.path)).size !== value.files.length)
+        ctx.addIssue({
+            code: "custom",
+            message: "Website paths must be unique.",
+        });
+    if (!value.files.some((file) => file.path === value.entrypoint && file.media_type === "text/html"))
+        ctx.addIssue({
+            code: "custom",
+            message: "The start page must be an HTML file in the file list.",
+        });
+});
+export const AttachedFileSchema = z.strictObject({
+    path: z.string(),
+    sha256: z.string(),
+    status: z.enum(["verified", "unavailable"]),
+    observed_at: z.string(),
+    text: z.string().optional(),
+    bytes: z.number().optional(),
+    reason: z.string().optional(),
+    title: z.string().max(160).optional(),
+    media_type: z.string().optional(),
+    data: z.string().max(MAX_RESULT_TRANSFER_BYTES * 4 / 3).optional(),
+    encoding: z.literal("gzip").optional(),
+    stored: z.boolean().optional(),
+    website: z
+        .strictObject({
+        entrypoint: z.string(),
+        files: z
+            .array(z.strictObject({
+            path: z.string(),
+            sha256: hash,
+            media_type: z.string(),
+        }))
+            .max(MAX_RESULT_FILES),
+    })
+        .optional(),
+});

package/dist/packages/workflow-language/src/schema.d.ts

@@ -0,0 +1,207 @@
+import { z } from "zod";
+export type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+export declare const JsonSchema: z.ZodType<Json>;
+export declare const NameSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const ReferenceSchema: z.ZodString;
+export declare const TypeSchema: z.ZodEnum<["text", "number", "boolean", "record", "list", "file"]>;
+export type ValueType = z.infer<typeof TypeSchema>;
+export type Shape = ValueType | {
+    type: ValueType;
+    description?: string | undefined;
+    fields?: Record<string, Shape> | undefined;
+    items?: Shape | undefined;
+    format?: string | undefined;
+};
+export declare const ShapeSchema: z.ZodType<Shape>;
+export declare const DataSchema: z.ZodObject<{
+    type: z.ZodEnum<["text", "number", "boolean", "record", "list", "file"]>;
+    description: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodType<Shape, z.ZodTypeDef, Shape>>>;
+    items: z.ZodOptional<z.ZodType<Shape, z.ZodTypeDef, Shape>>;
+    format: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "number" | "boolean" | "file" | "text" | "record" | "list";
+    description?: string | undefined;
+    fields?: Record<string, Shape> | undefined;
+    items?: Shape | undefined;
+    format?: string | undefined;
+}, {
+    type: "number" | "boolean" | "file" | "text" | "record" | "list";
+    description?: string | undefined;
+    fields?: Record<string, Shape> | undefined;
+    items?: Shape | undefined;
+    format?: string | undefined;
+}>;
+export declare const InputSchema: z.ZodObject<{
+    type: z.ZodEnum<["text", "number", "boolean", "record", "list", "file"]>;
+    description: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodEffects<z.ZodString, string, string>, z.ZodType<Shape, z.ZodTypeDef, Shape>>>;
+    items: z.ZodOptional<z.ZodType<Shape, z.ZodTypeDef, Shape>>;
+    format: z.ZodOptional<z.ZodString>;
+} & {
+    default: z.ZodOptional<z.ZodType<Json, z.ZodTypeDef, Json>>;
+}, "strict", z.ZodTypeAny, {
+    type: "number" | "boolean" | "file" | "text" | "record" | "list";
+    default?: Json | undefined;
+    description?: string | undefined;
+    fields?: Record<string, Shape> | undefined;
+    items?: Shape | undefined;
+    format?: string | undefined;
+}, {
+    type: "number" | "boolean" | "file" | "text" | "record" | "list";
+    default?: Json | undefined;
+    description?: string | undefined;
+    fields?: Record<string, Shape> | undefined;
+    items?: Shape | undefined;
+    format?: string | undefined;
+}>;
+export declare const EnvironmentSchema: z.ZodObject<{
+    type: z.ZodEnum<["browser", "service", "desktop", "files", "tool"]>;
+    description: z.ZodString;
+    role: z.ZodOptional<z.ZodLiteral<"observer">>;
+}, "strict", z.ZodTypeAny, {
+    type: "browser" | "service" | "desktop" | "files" | "tool";
+    description: string;
+    role?: "observer" | undefined;
+}, {
+    type: "browser" | "service" | "desktop" | "files" | "tool";
+    description: string;
+    role?: "observer" | undefined;
+}>;
+export type ExactCheck = {
+    equals: {
+        actual: string;
+        expected: string;
+    };
+} | {
+    count: {
+        value: string;
+        min?: number;
+        max?: number;
+    };
+} | {
+    present: string;
+} | {
+    file: string;
+};
+export type BaseStep = {
+    name?: string;
+    in?: Record<string, string>;
+    ask?: string;
+    out?: string | Record<string, z.infer<typeof DataSchema>>;
+    each?: Record<string, string>;
+    when?: string;
+    after?: string | string[];
+    changes?: string[];
+};
+export type DataDefinition = z.infer<typeof DataSchema>;
+export declare const FileArtifactSchema: z.ZodObject<{
+    path: z.ZodString;
+    sha256: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    sha256: string;
+    path: string;
+}, {
+    sha256: string;
+    path: string;
+}>;
+/** JSON Pointer remains a private editing/JSON utility, never a workflow binding. */
+export declare function pointer(value: Json | undefined, path: string): Json | undefined;
+export type RunExecution = {
+    kind: "run";
+    runtime: string;
+    entrypoint: string;
+    args?: string[];
+};
+export type AgentExecution = {
+    kind: "agent";
+    model: string;
+    prompt: string;
+    tools?: string[];
+    browser?: string;
+};
+/** Exactly one answer form: options (a choice), answer: "yes_no", or levels (2-10 ordered names, lowest first). */
+export type ClassifyExecution = {
+    kind: "classify";
+    question: string;
+    options?: Record<string, string>;
+    answer?: "yes_no";
+    levels?: string[];
+};
+export type Execution = ClassifyExecution | RunExecution | AgentExecution | {
+    kind: "call";
+    model: string;
+    prompt: string;
+};
+export type CurrentCheck = ExactCheck | RunExecution | AgentExecution;
+/** An effect contract: an observer confirms an external change; the action's receipt never does. */
+export type Effect = {
+    intent: string;
+    in?: Record<string, string>;
+    observe: RunExecution;
+    judge: RunExecution;
+    fixtures: string;
+    schedule: {
+        first?: string;
+        then?: string[];
+        horizon: string;
+    };
+    confirm: "positive" | "unrefuted_at_horizon";
+    retry?: "never" | "idempotent";
+    blocking?: boolean;
+};
+export type CurrentStep = BaseStep & {
+    purpose?: string;
+    do?: Execution;
+    check?: CurrentCheck;
+    effects?: Record<string, Effect>;
+    reading?: {
+        inputs?: string;
+        outputs?: string;
+        output_name?: string;
+        condition?: string;
+        check?: string;
+        check_name?: string;
+    };
+    repeat?: {
+        max_iterations: number;
+        until?: string;
+    };
+    limits?: {
+        timeout_ms?: number;
+        max_agent_turns?: number;
+        max_model_requests?: number;
+    };
+};
+export type CurrentWorkflow = {
+    name: string;
+    goal: string;
+    inputs?: Record<string, z.infer<typeof InputSchema>>;
+    environment?: Record<string, z.infer<typeof EnvironmentSchema>>;
+    result: string | Record<string, string>;
+    format: "method/3.1" | "method/3.2" | "method/3.3" | "method/3.4";
+    id?: string;
+    models?: Record<string, string | {
+        model: string;
+        max_output_tokens?: number;
+        reasoning_effort?: string;
+    }>;
+    run_prompt?: string;
+    run_label?: string;
+    files?: string[];
+    state?: Record<string, z.infer<typeof InputSchema>>;
+    steps: Record<string, CurrentStep>;
+};
+export declare const CurrentStepSchema: z.ZodType<CurrentStep, z.ZodTypeDef, CurrentStep>;
+export declare const CurrentCheckSchema: z.ZodType<CurrentCheck, z.ZodTypeDef, CurrentCheck>;
+export declare const CurrentWorkflowSchema: z.ZodType<CurrentWorkflow, z.ZodTypeDef, CurrentWorkflow>;
+export declare const WorkflowSchema: z.ZodType<CurrentWorkflow, z.ZodTypeDef, CurrentWorkflow>;
+export type Workflow = z.infer<typeof WorkflowSchema>;
+export type Step = Workflow["steps"][string];
+export type Check = NonNullable<Step["check"]>;
+export declare function executionText(step: Step): string;
+export declare function executionLabel(step: Step): string;
+export declare function effectiveOutputs(step: Step): Record<string, DataDefinition>;
+export declare function executionCommand(execution: RunExecution): string;

package/dist/packages/workflow-language/src/schema.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+export const JsonSchema = z.lazy(() => z.union([z.null(), z.boolean(), z.number().finite(), z.string(), z.array(JsonSchema), z.record(JsonSchema)]));
+export const NameSchema = z.string().regex(/^[a-z][a-z0-9_]*$/).max(80).refine(name => !["constructor", "prototype", "__proto__"].includes(name), "Reserved name.");
+export const ReferenceSchema = z.string().regex(/^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*|\.[0-9]+)*$/);
+const Text = z.string().trim().min(1).max(16000);
+export const TypeSchema = z.enum(["text", "number", "boolean", "record", "list", "file"]);
+export const ShapeSchema = z.lazy(() => z.union([TypeSchema, z.strictObject({ type: TypeSchema, description: Text.optional(), fields: z.record(NameSchema, ShapeSchema).optional(), items: ShapeSchema.optional(), format: Text.optional() })]));
+export const DataSchema = z.strictObject({ type: TypeSchema, description: Text.optional(), fields: z.record(NameSchema, ShapeSchema).optional(), items: ShapeSchema.optional(), format: Text.optional() });
+export const InputSchema = DataSchema.extend({ default: JsonSchema.optional() });
+export const EnvironmentSchema = z.strictObject({ type: z.enum(["browser", "service", "desktop", "files", "tool"]), description: Text, role: z.literal("observer").optional() });
+export const FileArtifactSchema = z.strictObject({ path: z.string().min(1), sha256: z.string().regex(/^[a-f0-9]{64}$/) });
+/** JSON Pointer remains a private editing/JSON utility, never a workflow binding. */
+export function pointer(value, path) {
+    if (path === "")
+        return value;
+    if (!/^(?:\/(?:[^~]|~[01])*)*$/.test(path))
+        throw Error("Invalid JSON Pointer.");
+    let current = value;
+    for (const segment of path.slice(1).split("/")) {
+        const key = segment.replaceAll("~1", "/").replaceAll("~0", "~");
+        if (!current || typeof current !== "object" || !Object.hasOwn(current, key))
+            return undefined;
+        if (Array.isArray(current) && !/^(0|[1-9][0-9]*)$/.test(key))
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+// Current shape validation comes from the runtime's single JSON Schema.
+import { methodShape, stepShape, checkShape } from "@withmethod/runtime/document-validators.js";
+function currentShape(validate) {
+    return z.any().superRefine((value, context) => {
+        if (!validate(value))
+            for (const error of validate.errors ?? [])
+                context.addIssue({
+                    code: z.ZodIssueCode.custom, message: `${error.instancePath || "/"}: ${error.message}`,
+                });
+    });
+}
+export const CurrentStepSchema = currentShape(stepShape);
+export const CurrentCheckSchema = currentShape(checkShape);
+export const CurrentWorkflowSchema = currentShape(methodShape);
+export const WorkflowSchema = CurrentWorkflowSchema;
+export function executionText(step) {
+    if (!step.do)
+        return step.ask ?? "";
+    return step.do.kind === "run" ? (step.purpose ?? "No script description was recorded.") : step.do.kind === "classify" ? step.do.question : step.do.prompt;
+}
+export function executionLabel(step) {
+    return step.ask ? "Human input" : typeof step.do === "object" ? ({ run: "Script", call: "Model call", agent: "Agent", classify: "Classification" }[step.do.kind]) : "Agent";
+}
+import { effectiveOutputs as runtimeOutputs } from '@withmethod/runtime/semantics.js';
+export function effectiveOutputs(step) { return runtimeOutputs(step); }
+export function executionCommand(execution) {
+    return [execution.runtime, execution.entrypoint, ...(execution.args ?? [])].join(' ');
+}

package/dist/packages/workflow-language/src/validate.d.ts

@@ -0,0 +1,11 @@
+export { parseDocumentValue, shapeErrors, MethodValidationError } from '@withmethod/runtime/document.js';
+export { outputSchema } from '@withmethod/runtime/semantics.js';
+import { type Workflow, type Step, type Shape } from "./schema.js";
+export declare function serializeWorkflow(value: unknown): string;
+export declare function shapeObject(shape: Shape): Exclude<Shape, string>;
+export declare function validateShape(shape: Shape, label: string): void;
+export declare function references(step: Step): string[];
+export declare function producers(workflow: Workflow): Map<string, string>;
+export declare function referenceShape(workflow: Workflow, reference: string): Shape | undefined;
+export declare function stepDependencies(workflow: Workflow, id: string): string[];
+export declare function loadWorkflow(value: unknown): Workflow;