@a5c-ai/babysitter-sdk 0.0.16

package/dist/tasks/kinds/index.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeTask = nodeTask;
+exports.breakpointTask = breakpointTask;
+exports.orchestratorTask = orchestratorTask;
+exports.sleepTask = sleepTask;
+const defineTask_1 = require("../defineTask");
+const DEFAULT_NODE_TIMEOUT_MS = 15 * 60 * 1000;
+const DEFAULT_BREAKPOINT_LABEL = "breakpoint";
+const DEFAULT_ORCHESTRATOR_LABEL = "orchestrator-task";
+const DEFAULT_SLEEP_TASK_ID = "__sdk.sleep";
+const REDACTION_KEYWORDS = ["SECRET", "TOKEN", "PASSWORD", "KEY"];
+function nodeTask(id, options) {
+    if (!options || !options.entry) {
+        throw new Error("nodeTask requires an entry option");
+    }
+    return (0, defineTask_1.defineTask)(id, async (args, ctx) => {
+        const [entry, title, description, helperLabels, helperMetadata, ioOverrides, nodeArgs, envInput, cwd, timeoutOverride,] = await Promise.all([
+            resolveRequiredValue(options.entry, args, ctx, "entry"),
+            resolveOptionalValue(options.title, args, ctx),
+            resolveOptionalValue(options.description, args, ctx),
+            resolveLabelList(options.labels, args, ctx),
+            resolveMetadata(options.metadata, args, ctx),
+            resolveIoHints(options.io, args, ctx),
+            resolveStringArray(options.args, args, ctx),
+            resolveEnv(options.env, args, ctx),
+            resolveOptionalValue(options.cwd, args, ctx),
+            resolveNumber(options.timeoutMs, args, ctx),
+        ]);
+        const io = applyIoOverrides(buildDefaultNodeIo(ctx), ioOverrides);
+        const { env, redacted } = sanitizeEnv(envInput);
+        const metadata = appendRedactedEnvKeys(helperMetadata, redacted);
+        const labels = mergeLabels(ctx, helperLabels);
+        const nodeOptions = buildNodeOptions(entry, nodeArgs, env, cwd, timeoutOverride);
+        return {
+            kind: "node",
+            title,
+            description,
+            labels,
+            io,
+            metadata,
+            node: nodeOptions,
+        };
+    }, { kind: "node" });
+}
+function breakpointTask(id, options = {}) {
+    return (0, defineTask_1.defineTask)(id, async (args, ctx) => {
+        const [title, description, helperLabels, metadata, payload, confirmationRequired] = await Promise.all([
+            resolveOptionalValue(options.title, args, ctx),
+            resolveOptionalValue(options.description, args, ctx),
+            resolveLabelList(options.labels, args, ctx),
+            resolveMetadata(options.metadata, args, ctx),
+            resolveOptionalValue(options.payload, args, ctx),
+            resolveBoolean(options.confirmationRequired, args, ctx),
+        ]);
+        const labels = mergeLabels(ctx, helperLabels, DEFAULT_BREAKPOINT_LABEL);
+        const breakpoint = buildBreakpointOptions(payload ?? args, confirmationRequired);
+        const resolvedTitle = title ?? ctx.label ?? labels?.[0] ?? DEFAULT_BREAKPOINT_LABEL;
+        return {
+            kind: "breakpoint",
+            title: resolvedTitle,
+            description,
+            labels,
+            metadata,
+            breakpoint,
+        };
+    }, { kind: "breakpoint" });
+}
+function orchestratorTask(id, options = {}) {
+    return (0, defineTask_1.defineTask)(id, async (args, ctx) => {
+        const [title, description, helperLabels, metadata, payload, resumeCommand] = await Promise.all([
+            resolveOptionalValue(options.title, args, ctx),
+            resolveOptionalValue(options.description, args, ctx),
+            resolveLabelList(options.labels, args, ctx),
+            resolveMetadata(options.metadata, args, ctx),
+            resolvePayload(options.payload, args, ctx),
+            resolveOptionalValue(options.resumeCommand, args, ctx),
+        ]);
+        const labels = mergeLabels(ctx, helperLabels, DEFAULT_ORCHESTRATOR_LABEL);
+        const orchestrator = buildOrchestratorOptions(payload ?? pickJsonRecord(args), resumeCommand);
+        const mergedMetadata = ensureMetadata(metadata);
+        mergedMetadata.orchestratorTask = true;
+        const resolvedTitle = title ?? ctx.label ?? labels?.[0] ?? DEFAULT_ORCHESTRATOR_LABEL;
+        return {
+            kind: "orchestrator_task",
+            title: resolvedTitle,
+            description,
+            labels,
+            metadata: mergedMetadata,
+            orchestratorTask: orchestrator,
+        };
+    }, { kind: "orchestrator_task" });
+}
+function sleepTask(id = DEFAULT_SLEEP_TASK_ID, options = {}) {
+    return (0, defineTask_1.defineTask)(id, async (args, ctx) => {
+        const [title, description, helperLabels, metadata] = await Promise.all([
+            resolveOptionalValue(options.title, args, ctx),
+            resolveOptionalValue(options.description, args, ctx),
+            resolveLabelList(options.labels, args, ctx),
+            resolveMetadata(options.metadata, args, ctx),
+        ]);
+        const iso = args.iso;
+        const targetEpochMs = args.targetEpochMs;
+        if (typeof iso !== "string" || !iso.length) {
+            throw new Error("sleepTask requires args.iso to be a non-empty ISO string");
+        }
+        if (typeof targetEpochMs !== "number" || !Number.isFinite(targetEpochMs)) {
+            throw new Error("sleepTask requires args.targetEpochMs to be a finite number");
+        }
+        const labels = mergeLabels(ctx, helperLabels, `sleep:${iso}`);
+        const mergedMetadata = ensureMetadata(metadata);
+        mergedMetadata.iso = iso;
+        mergedMetadata.targetEpochMs = targetEpochMs;
+        const resolvedTitle = title ?? `sleep:${iso}`;
+        return {
+            kind: "sleep",
+            title: resolvedTitle,
+            description,
+            labels,
+            metadata: mergedMetadata,
+            sleep: { iso, targetEpochMs },
+        };
+    }, { kind: "sleep" });
+}
+async function resolveOptionalValue(source, args, ctx) {
+    if (source === undefined || source === null)
+        return undefined;
+    const value = isFactory(source) ? await source(args, ctx) : source;
+    return value === null ? undefined : value;
+}
+async function resolveRequiredValue(source, args, ctx, field) {
+    const value = await resolveOptionalValue(source, args, ctx);
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`nodeTask requires a non-empty ${field}`);
+    }
+    return value;
+}
+async function resolveLabelList(source, args, ctx) {
+    const values = await resolveOptionalValue(source, args, ctx);
+    if (!Array.isArray(values)) {
+        return undefined;
+    }
+    return normalizeLabels(values);
+}
+async function resolveMetadata(source, args, ctx) {
+    const value = await resolveOptionalValue(source, args, ctx);
+    if (!isJsonRecord(value)) {
+        return undefined;
+    }
+    return { ...value };
+}
+async function resolveIoHints(source, args, ctx) {
+    const value = await resolveOptionalValue(source, args, ctx);
+    if (!value)
+        return undefined;
+    return { ...value };
+}
+async function resolveStringArray(source, args, ctx) {
+    const values = await resolveOptionalValue(source, args, ctx);
+    if (!Array.isArray(values)) {
+        return undefined;
+    }
+    return values.slice();
+}
+async function resolveEnv(source, args, ctx) {
+    const value = await resolveOptionalValue(source, args, ctx);
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    return { ...value };
+}
+async function resolveNumber(source, args, ctx) {
+    const value = await resolveOptionalValue(source, args, ctx);
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return undefined;
+    }
+    return value;
+}
+async function resolveBoolean(source, args, ctx) {
+    const value = await resolveOptionalValue(source, args, ctx);
+    if (typeof value !== "boolean") {
+        return undefined;
+    }
+    return value;
+}
+async function resolvePayload(source, args, ctx) {
+    const value = await resolveOptionalValue(source, args, ctx);
+    if (!isJsonRecord(value)) {
+        return undefined;
+    }
+    return { ...value };
+}
+function isFactory(value) {
+    return typeof value === "function";
+}
+function normalizeLabels(values) {
+    if (!Array.isArray(values)) {
+        return undefined;
+    }
+    const seen = new Set();
+    const normalized = [];
+    for (const label of values) {
+        if (typeof label !== "string")
+            continue;
+        const trimmed = label.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        normalized.push(trimmed);
+    }
+    return normalized.length ? normalized : undefined;
+}
+function mergeLabels(ctx, helperLabels, fallback) {
+    const combined = [];
+    combined.push(...(normalizeLabels(ctx.labels) ?? []));
+    combined.push(...(helperLabels ?? []));
+    const normalized = normalizeLabels(combined);
+    const fallbackLabel = typeof fallback === "string" ? fallback.trim() : undefined;
+    if ((!ctx.label || !ctx.label.trim()) && (!normalized || normalized.length === 0) && fallbackLabel) {
+        return [fallbackLabel];
+    }
+    return normalized;
+}
+function buildDefaultNodeIo(ctx) {
+    return {
+        inputJsonPath: ctx.toTaskRelativePath("inputs.json"),
+        outputJsonPath: ctx.toTaskRelativePath("result.json"),
+        stdoutPath: ctx.toTaskRelativePath("stdout.log"),
+        stderrPath: ctx.toTaskRelativePath("stderr.log"),
+    };
+}
+function applyIoOverrides(base, override) {
+    if (!override) {
+        return base;
+    }
+    return {
+        ...base,
+        ...override,
+    };
+}
+function sanitizeEnv(input) {
+    if (!input) {
+        return { redacted: [] };
+    }
+    const env = {};
+    const redacted = [];
+    for (const [rawKey, rawValue] of Object.entries(input)) {
+        const key = typeof rawKey === "string" ? rawKey.trim() : "";
+        if (!key)
+            continue;
+        if (rawValue === undefined || rawValue === null) {
+            continue;
+        }
+        const value = typeof rawValue === "string" ? rawValue : String(rawValue);
+        if (shouldRedactEnvKey(key)) {
+            redacted.push(key);
+            continue;
+        }
+        env[key] = value;
+    }
+    redacted.sort((a, b) => a.localeCompare(b));
+    return {
+        env: Object.keys(env).length ? env : undefined,
+        redacted,
+    };
+}
+function shouldRedactEnvKey(key) {
+    const upper = key.toUpperCase();
+    if (upper === "NODE_AUTH_TOKEN") {
+        return true;
+    }
+    return REDACTION_KEYWORDS.some((keyword) => upper.includes(keyword));
+}
+function appendRedactedEnvKeys(metadata, keys) {
+    if (!keys.length) {
+        return metadata;
+    }
+    const result = ensureMetadata(metadata);
+    const existing = Array.isArray(result.redactedEnvKeys) ? result.redactedEnvKeys : [];
+    const merged = Array.from(new Set([...existing, ...keys]));
+    merged.sort((a, b) => a.localeCompare(b));
+    result.redactedEnvKeys = merged;
+    return result;
+}
+function ensureMetadata(metadata) {
+    if (metadata && typeof metadata === "object" && !Array.isArray(metadata)) {
+        return { ...metadata };
+    }
+    return {};
+}
+function buildNodeOptions(entry, args, env, cwd, timeoutOverride) {
+    const nodeOptions = { entry };
+    if (args !== undefined) {
+        nodeOptions.args = args;
+    }
+    if (env) {
+        nodeOptions.env = env;
+    }
+    if (typeof cwd === "string" && cwd.length) {
+        nodeOptions.cwd = cwd;
+    }
+    nodeOptions.timeoutMs = typeof timeoutOverride === "number" ? timeoutOverride : DEFAULT_NODE_TIMEOUT_MS;
+    return nodeOptions;
+}
+function buildBreakpointOptions(payload, confirmationRequired) {
+    const breakpoint = {};
+    if (payload !== undefined) {
+        breakpoint.payload = payload;
+    }
+    if (confirmationRequired !== undefined) {
+        breakpoint.confirmationRequired = confirmationRequired;
+    }
+    return breakpoint;
+}
+function buildOrchestratorOptions(payload, resumeCommand) {
+    const orchestrator = {};
+    if (payload) {
+        orchestrator.payload = payload;
+    }
+    if (resumeCommand) {
+        orchestrator.resumeCommand = resumeCommand;
+    }
+    return orchestrator;
+}
+function pickJsonRecord(value) {
+    if (!isJsonRecord(value)) {
+        return undefined;
+    }
+    return { ...value };
+}
+function isJsonRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/tasks/registry.d.ts

@@ -0,0 +1,53 @@
+import { JsonRecord } from "../storage/types";
+export type TaskStatus = "pending" | "resolved_ok" | "resolved_error";
+export interface RegisteredTaskDefinition {
+    id: string;
+    kind?: string;
+    labels: string[];
+    description?: string;
+    source?: string;
+}
+export interface RegistryEffectRecord {
+    effectId: string;
+    taskId: string;
+    invocationKey: string;
+    kind: string;
+    label?: string;
+    labels?: string[];
+    status: TaskStatus;
+    taskDefRef: string;
+    inputsRef?: string;
+    resultRef?: string;
+    stdoutRef?: string;
+    stderrRef?: string;
+    metadata?: JsonRecord;
+    stepId?: string;
+    requestedAt?: string;
+    resolvedAt?: string;
+}
+export interface PendingFilter {
+    kind?: string | string[];
+    labels?: string | string[];
+}
+export declare class DuplicateTaskIdError extends Error {
+    constructor(taskId: string);
+}
+export declare class TaskRegistry {
+    private definitions;
+    private effects;
+    registerDefinition(record: RegisteredTaskDefinition): RegisteredTaskDefinition;
+    recordDefinitionMetadata(taskId: string, metadata: Partial<Omit<RegisteredTaskDefinition, "id">>): void;
+    recordEffect(record: RegistryEffectRecord): RegistryEffectRecord;
+    resolveEffect(effectId: string, update: Partial<RegistryEffectRecord>): RegistryEffectRecord | undefined;
+    get(effectId: string): RegistryEffectRecord | undefined;
+    listPending(filter?: PendingFilter): RegistryEffectRecord[];
+    listDefinitions(): RegisteredTaskDefinition[];
+    hasTask(taskId: string): boolean;
+    clear(): void;
+    private matchesKind;
+    private matchesLabel;
+    private extractMetadataLabels;
+}
+export declare const globalTaskRegistry: TaskRegistry;
+export declare function resetGlobalTaskRegistry(): void;
+//# sourceMappingURL=registry.d.ts.map

package/dist/tasks/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/tasks/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,aAAa,GAAG,gBAAgB,CAAC;AAEtE,MAAM,WAAW,wBAAwB;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,UAAU,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC5B;AAED,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,MAAM,EAAE,MAAM;CAI3B;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,WAAW,CAA+C;IAClE,OAAO,CAAC,OAAO,CAA2C;IAE1D,kBAAkB,CAAC,MAAM,EAAE,wBAAwB,GAAG,wBAAwB;IAe9E,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,wBAAwB,EAAE,IAAI,CAAC,CAAC,GAAG,IAAI;IAmBvG,YAAY,CAAC,MAAM,EAAE,oBAAoB,GAAG,oBAAoB;IAchE,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,oBAAoB,GAAG,SAAS;IAcxG,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS;IAIvD,WAAW,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,oBAAoB,EAAE;IAO3D,eAAe,IAAI,wBAAwB,EAAE;IAI7C,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIhC,KAAK,IAAI,IAAI;IAKb,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,YAAY;IAcpB,OAAO,CAAC,qBAAqB;CAO9B;AAED,eAAO,MAAM,kBAAkB,cAAqB,CAAC;AAErD,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C"}

package/dist/tasks/registry.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalTaskRegistry = exports.TaskRegistry = exports.DuplicateTaskIdError = void 0;
+exports.resetGlobalTaskRegistry = resetGlobalTaskRegistry;
+class DuplicateTaskIdError extends Error {
+    constructor(taskId) {
+        super(`Task id "${taskId}" is already registered`);
+        this.name = "DuplicateTaskIdError";
+    }
+}
+exports.DuplicateTaskIdError = DuplicateTaskIdError;
+class TaskRegistry {
+    definitions = new Map();
+    effects = new Map();
+    registerDefinition(record) {
+        if (this.definitions.has(record.id)) {
+            throw new DuplicateTaskIdError(record.id);
+        }
+        const normalized = {
+            id: record.id,
+            kind: record.kind,
+            labels: normalizeLabels(record.labels),
+            description: record.description,
+            source: record.source,
+        };
+        this.definitions.set(record.id, normalized);
+        return normalized;
+    }
+    recordDefinitionMetadata(taskId, metadata) {
+        const current = this.definitions.get(taskId);
+        if (!current) {
+            this.definitions.set(taskId, {
+                id: taskId,
+                labels: normalizeLabels(metadata.labels ?? []),
+                kind: metadata.kind,
+                description: metadata.description,
+                source: metadata.source,
+            });
+            return;
+        }
+        this.definitions.set(taskId, {
+            ...current,
+            ...metadata,
+            labels: normalizeLabels(metadata.labels ?? current.labels),
+        });
+    }
+    recordEffect(record) {
+        const normalizedLabels = normalizeLabels(record.labels ?? []);
+        const normalized = {
+            ...record,
+            label: normalizeLabelValue(record.label),
+            labels: normalizedLabels.length ? normalizedLabels : undefined,
+            kind: record.kind,
+            status: record.status,
+            inputsRef: record.inputsRef,
+        };
+        this.effects.set(record.effectId, normalized);
+        return normalized;
+    }
+    resolveEffect(effectId, update) {
+        const current = this.effects.get(effectId);
+        if (!current)
+            return undefined;
+        const next = {
+            ...current,
+            ...update,
+        };
+        if (update.status) {
+            next.status = update.status;
+        }
+        this.effects.set(effectId, next);
+        return next;
+    }
+    get(effectId) {
+        return this.effects.get(effectId);
+    }
+    listPending(filter) {
+        const pending = Array.from(this.effects.values()).filter((record) => record.status === "pending");
+        return pending
+            .filter((record) => this.matchesKind(record, filter?.kind) && this.matchesLabel(record, filter?.labels))
+            .sort((a, b) => a.effectId.localeCompare(b.effectId));
+    }
+    listDefinitions() {
+        return Array.from(this.definitions.values()).sort((a, b) => a.id.localeCompare(b.id));
+    }
+    hasTask(taskId) {
+        return this.definitions.has(taskId);
+    }
+    clear() {
+        this.definitions.clear();
+        this.effects.clear();
+    }
+    matchesKind(record, kinds) {
+        if (!kinds)
+            return true;
+        const asArray = Array.isArray(kinds) ? kinds : [kinds];
+        if (!asArray.length)
+            return true;
+        return asArray.some((kind) => kind === record.kind);
+    }
+    matchesLabel(record, labels) {
+        if (!labels)
+            return true;
+        const values = Array.isArray(labels) ? labels : [labels];
+        if (!values.length)
+            return true;
+        const metadataLabels = this.extractMetadataLabels(record.metadata);
+        const definitionLabels = this.definitions.get(record.taskId)?.labels ?? [];
+        const labelSet = new Set([record.label, ...(record.labels ?? []), ...metadataLabels, ...definitionLabels].filter((label) => typeof label === "string" && Boolean(label)));
+        return values.some((value) => labelSet.has(value));
+    }
+    extractMetadataLabels(metadata) {
+        if (!metadata)
+            return [];
+        const labels = metadata.labels;
+        return Array.isArray(labels)
+            ? labels.filter((label) => typeof label === "string" && Boolean(label))
+            : [];
+    }
+}
+exports.TaskRegistry = TaskRegistry;
+exports.globalTaskRegistry = new TaskRegistry();
+function resetGlobalTaskRegistry() {
+    exports.globalTaskRegistry.clear();
+}
+function normalizeLabels(labels) {
+    const seen = new Set();
+    const result = [];
+    for (const label of labels) {
+        if (typeof label !== "string")
+            continue;
+        const trimmed = label.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        result.push(trimmed);
+    }
+    return result;
+}
+function normalizeLabelValue(label) {
+    if (typeof label !== "string")
+        return undefined;
+    const trimmed = label.trim();
+    return trimmed.length ? trimmed : undefined;
+}

package/dist/tasks/serializer.d.ts

@@ -0,0 +1,60 @@
+import { JsonRecord, StoredTaskResult } from "../storage/types";
+import { TaskDef, TaskSerializerContext } from "./types";
+import type { SerializedEffectError } from "../runtime/types";
+export declare const TASK_SCHEMA_VERSION = "2026.01.tasks-v1";
+export declare const RESULT_SCHEMA_VERSION = "2026.01.results-v1";
+export interface SerializeTaskDefinitionOptions extends TaskSerializerContext {
+    task: TaskDef;
+    inputs?: unknown;
+}
+export interface SerializeTaskResultOptions extends TaskSerializerContext {
+    payload: TaskResultPayload;
+}
+export interface TaskResultPayload {
+    status: "ok" | "error";
+    result?: unknown;
+    error?: SerializedErrorPayload;
+    stdout?: string;
+    stderr?: string;
+    stdoutRef?: string;
+    stderrRef?: string;
+    startedAt?: string;
+    finishedAt?: string;
+    metadata?: JsonRecord;
+}
+export type SerializedErrorPayload = SerializedEffectError | JsonRecord | undefined;
+export interface SerializeTaskDefinitionResult {
+    taskRef: string;
+    inputsRef?: string;
+    serialized: SerializedTaskDefinition;
+}
+export interface SerializeTaskResultOutput {
+    resultRef: string;
+    stdoutRef?: string;
+    stderrRef?: string;
+    serialized: StoredTaskResult;
+}
+export interface SerializedTaskDefinition extends JsonRecord {
+    schemaVersion: string;
+    effectId: string;
+    taskId: string;
+    invocationKey: string;
+    stepId?: string;
+    kind: string;
+    title?: string;
+    description?: string;
+    labels?: string[];
+    inputs?: unknown;
+    inputsRef?: string;
+    io?: JsonRecord;
+    node?: JsonRecord;
+    breakpoint?: JsonRecord;
+    orchestratorTask?: JsonRecord;
+    sleep?: JsonRecord;
+    metadata?: JsonRecord;
+}
+export declare function serializeAndWriteTaskDefinition(options: SerializeTaskDefinitionOptions): Promise<SerializeTaskDefinitionResult>;
+export declare function serializeTaskDefinition(options: SerializeTaskDefinitionOptions): Promise<SerializedTaskDefinition>;
+export declare function serializeAndWriteTaskResult(options: SerializeTaskResultOptions): Promise<SerializeTaskResultOutput>;
+export declare function serializeTaskResult(options: SerializeTaskResultOptions): Promise<StoredTaskResult>;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/tasks/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../src/tasks/serializer.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEhE,OAAO,EAAE,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAEzD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAE9D,eAAO,MAAM,mBAAmB,qBAAqB,CAAC;AACtD,eAAO,MAAM,qBAAqB,uBAAuB,CAAC;AAI1D,MAAM,WAAW,8BAA+B,SAAQ,qBAAqB;IAC3E,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,0BAA2B,SAAQ,qBAAqB;IACvE,OAAO,EAAE,iBAAiB,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,IAAI,GAAG,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,sBAAsB,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,UAAU,CAAC;CACvB;AAED,MAAM,MAAM,sBAAsB,GAAG,qBAAqB,GAAG,UAAU,GAAG,SAAS,CAAC;AAEpF,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,wBAAwB,CAAC;CACtC;AAED,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,gBAAgB,CAAC;CAC9B;AAED,MAAM,WAAW,wBAAyB,SAAQ,UAAU;IAC1D,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,EAAE,CAAC,EAAE,UAAU,CAAC;IAChB,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,gBAAgB,CAAC,EAAE,UAAU,CAAC;IAC9B,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,QAAQ,CAAC,EAAE,UAAU,CAAC;CACvB;AAED,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,8BAA8B,GACtC,OAAO,CAAC,6BAA6B,CAAC,CAQxC;AAED,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,8BAA8B,GACtC,OAAO,CAAC,wBAAwB,CAAC,CAgCnC;AAED,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,yBAAyB,CAAC,CAepC;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,gBAAgB,CAAC,CAgC3B"}