@wzrdtech/core 0.2.0 → 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./manifest.js";
+export * from "./planner.js";
+export * from "./schema.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./manifest.js";
+export * from "./planner.js";
+export * from "./schema.js";

package/dist/manifest.d.ts

@@ -0,0 +1,12 @@
+export type SkillManifestEntry = {
+    fileCount: number;
+    hash: string;
+    path: string;
+    skill: string;
+};
+export type SkillManifest = {
+    generatedAt: string;
+    skills: SkillManifestEntry[];
+    version: 1;
+};
+export declare function generateSkillManifest(skillsDir: string): Promise<SkillManifest>;

package/dist/manifest.js

@@ -0,0 +1,40 @@
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function generateSkillManifest(skillsDir) {
+    const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const root = path.join(skillsDir, entry.name);
+        const files = await listFiles(root);
+        const hash = createHash("sha256");
+        for (const file of files) {
+            const relative = path.relative(root, file);
+            hash.update(relative);
+            hash.update(await fs.readFile(file));
+        }
+        skills.push({
+            fileCount: files.length,
+            hash: hash.digest("hex"),
+            path: path.relative(process.cwd(), root),
+            skill: entry.name,
+        });
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        skills: skills.sort((left, right) => left.skill.localeCompare(right.skill)),
+        version: 1,
+    };
+}
+async function listFiles(root) {
+    const entries = await fs.readdir(root, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const fullPath = path.join(root, entry.name);
+        if (entry.isDirectory())
+            return listFiles(fullPath);
+        return [fullPath];
+    }));
+    return files.flat().sort();
+}

package/dist/planner.d.ts

@@ -0,0 +1,18 @@
+import type { ZapSpec, ZapStep } from "./schema.js";
+export type PlannedZapStep = ZapStep & {
+    originalId: string;
+    repeatIndex?: number;
+};
+export type ZapPlan = {
+    budgetCapUsd: number;
+    estimateUsd: number;
+    extendCount: number;
+    steps: PlannedZapStep[];
+    zap: string;
+};
+export declare function planZapRun(zap: ZapSpec, extendCount: number): ZapPlan;
+export declare function assertWithinBudget(plan: ZapPlan): void;
+export declare function validateRequiredInputs(zap: ZapSpec, inputs: Record<string, unknown>): void;
+export declare function isLocalStep(step: ZapStep): boolean;
+export declare function quoteStep(step: ZapStep): number;
+export declare function expandRepeatSteps(zap: ZapSpec, extendCount: number): PlannedZapStep[];

package/dist/planner.js

@@ -0,0 +1,61 @@
+const modelRates = {
+    "fal-ai/flux/dev": { perRequest: 0.03 },
+    "fal-ai/kling-video/v2.1/pro/image-to-video": { perSecond: 0.28 },
+    "fal-ai/veo3.1": { perSecond: 0.45 },
+    "gemini-omni-flash-preview": { perSecond: 0.1 },
+    "happyhorse-1.1-i2v": { perSecond: 0.28 },
+    "seedance-2-0-260128": { perSecond: 0.07 },
+    "seedance-2-0-260128-upscale": { perSecond: 0.056 },
+};
+export function planZapRun(zap, extendCount) {
+    const steps = expandRepeatSteps(zap, extendCount);
+    const estimateUsd = steps.reduce((sum, step) => sum + quoteStep(step), 0);
+    return {
+        budgetCapUsd: zap.budget.cap_usd,
+        estimateUsd,
+        extendCount,
+        steps,
+        zap: zap.zap,
+    };
+}
+export function assertWithinBudget(plan) {
+    if (plan.estimateUsd > plan.budgetCapUsd) {
+        throw new Error(`Run quote $${plan.estimateUsd.toFixed(2)} exceeds recipe cap $${plan.budgetCapUsd}.`);
+    }
+}
+export function validateRequiredInputs(zap, inputs) {
+    for (const [name, spec] of Object.entries(zap.inputs)) {
+        if (spec.required && inputs[name] === undefined) {
+            throw new Error(`Missing required input ${name}.`);
+        }
+    }
+}
+export function isLocalStep(step) {
+    return step.kind === "stitch" || step.kind === "keyframes";
+}
+export function quoteStep(step) {
+    if (isLocalStep(step))
+        return 0;
+    const model = step.model ?? "local";
+    const rate = modelRates[model];
+    if (!rate)
+        return 0;
+    if (rate.perRequest !== undefined)
+        return rate.perRequest;
+    return (rate.perSecond ?? 0) * (step.duration_s ?? 1);
+}
+export function expandRepeatSteps(zap, extendCount) {
+    return zap.steps.flatMap((step) => {
+        if (step.kind !== "video.extend")
+            return [{ ...step, originalId: step.id }];
+        const max = step.repeat?.max ?? 64;
+        const min = step.repeat?.min ?? 0;
+        const count = Math.max(min, Math.min(extendCount, max));
+        return Array.from({ length: count }, (_, index) => ({
+            ...step,
+            id: `${step.id}_${index + 1}`,
+            originalId: step.id,
+            repeatIndex: index + 1,
+        }));
+    });
+}

package/dist/schema.d.ts

@@ -0,0 +1,292 @@
+import { z } from "zod";
+export declare class ZapSchemaError extends Error {
+    readonly code = "SCHEMA_INVALID";
+    readonly retryable = false;
+}
+export declare const zapInputSchema: z.ZodObject<{
+    hint: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        textarea: "textarea";
+        image: "image";
+        video: "video";
+        select: "select";
+    }>;
+}, z.core.$strip>;
+export declare const zapStepKindSchema: z.ZodEnum<{
+    "image.gen": "image.gen";
+    "image.edit": "image.edit";
+    "video.gen": "video.gen";
+    "video.extend": "video.extend";
+    "video.edit": "video.edit";
+    "video.upscale": "video.upscale";
+    "audio.tts": "audio.tts";
+    "audio.music": "audio.music";
+    "audio.sfx": "audio.sfx";
+    keyframes: "keyframes";
+    stitch: "stitch";
+}>;
+export declare const zapProviderSchema: z.ZodEnum<{
+    gmi: "gmi";
+    fal: "fal";
+    prodia: "prodia";
+    runware: "runware";
+}>;
+export type ZapProvider = z.infer<typeof zapProviderSchema>;
+export declare const zapStitchSchema: z.ZodDefault<z.ZodObject<{
+    engine: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        local: "local";
+        hyperframes: "hyperframes";
+    }>>;
+    fps: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodDefault<z.ZodEnum<{
+        mp4: "mp4";
+        webm: "webm";
+    }>>;
+    quality: z.ZodDefault<z.ZodEnum<{
+        draft: "draft";
+        standard: "standard";
+        high: "high";
+    }>>;
+}, z.core.$strip>>;
+export declare const zapStepSchema: z.ZodObject<{
+    audio: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    candidates: z.ZodOptional<z.ZodNumber>;
+    duration_s: z.ZodOptional<z.ZodNumber>;
+    extend: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            chain: "chain";
+            anchored: "anchored";
+        }>>;
+    }, z.core.$strip>>;
+    first_frame: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    id: z.ZodString;
+    inputs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    judge: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    keyframes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    kind: z.ZodEnum<{
+        "image.gen": "image.gen";
+        "image.edit": "image.edit";
+        "video.gen": "video.gen";
+        "video.extend": "video.extend";
+        "video.edit": "video.edit";
+        "video.upscale": "video.upscale";
+        "audio.tts": "audio.tts";
+        "audio.music": "audio.music";
+        "audio.sfx": "audio.sfx";
+        keyframes: "keyframes";
+        stitch: "stitch";
+    }>;
+    model: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodEnum<{
+        gmi: "gmi";
+        fal: "fal";
+        prodia: "prodia";
+        runware: "runware";
+    }>>;
+    reference_images: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    repeat: z.ZodOptional<z.ZodObject<{
+        default: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        min: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    retry: z.ZodOptional<z.ZodObject<{
+        backoff_s: z.ZodDefault<z.ZodNumber>;
+        fallback_model: z.ZodOptional<z.ZodString>;
+        fallback_provider: z.ZodOptional<z.ZodEnum<{
+            gmi: "gmi";
+            fal: "fal";
+            prodia: "prodia";
+            runware: "runware";
+        }>>;
+        max: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    rlhf: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"optional">, z.ZodBoolean]>>;
+    shared: z.ZodOptional<z.ZodBoolean>;
+    stitch: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+        engine: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            local: "local";
+            hyperframes: "hyperframes";
+        }>>;
+        fps: z.ZodOptional<z.ZodNumber>;
+        format: z.ZodDefault<z.ZodEnum<{
+            mp4: "mp4";
+            webm: "webm";
+        }>>;
+        quality: z.ZodDefault<z.ZodEnum<{
+            draft: "draft";
+            standard: "standard";
+            high: "high";
+        }>>;
+    }, z.core.$strip>>>;
+    tier: z.ZodOptional<z.ZodEnum<{
+        draft: "draft";
+        final: "final";
+    }>>;
+}, z.core.$strip>;
+export declare const zapPublishSchema: z.ZodOptional<z.ZodObject<{
+    embed: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        allowOrigins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        height: z.ZodDefault<z.ZodNumber>;
+        theme: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            dark: "dark";
+            light: "light";
+        }>>;
+        width: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    slug: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    visibility: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+        public: "public";
+        unlisted: "unlisted";
+        private: "private";
+    }>>>;
+}, z.core.$strip>>;
+export declare const zapSpecSchema: z.ZodObject<{
+    budget: z.ZodObject<{
+        cap_usd: z.ZodNumber;
+        estimate_usd: z.ZodNumber;
+    }, z.core.$strip>;
+    defaults: z.ZodDefault<z.ZodObject<{
+        aspect: z.ZodOptional<z.ZodString>;
+        models: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        provider: z.ZodDefault<z.ZodEnum<{
+            gmi: "gmi";
+            fal: "fal";
+            prodia: "prodia";
+            runware: "runware";
+        }>>;
+    }, z.core.$strip>>;
+    description: z.ZodString;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        hint: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            textarea: "textarea";
+            image: "image";
+            video: "video";
+            select: "select";
+        }>;
+    }, z.core.$strip>>>;
+    output: z.ZodDefault<z.ZodString>;
+    publish: z.ZodOptional<z.ZodObject<{
+        embed: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            allowOrigins: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            height: z.ZodDefault<z.ZodNumber>;
+            theme: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                dark: "dark";
+                light: "light";
+            }>>;
+            width: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        slug: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        visibility: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+            public: "public";
+            unlisted: "unlisted";
+            private: "private";
+        }>>>;
+    }, z.core.$strip>>;
+    steps: z.ZodArray<z.ZodObject<{
+        audio: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        candidates: z.ZodOptional<z.ZodNumber>;
+        duration_s: z.ZodOptional<z.ZodNumber>;
+        extend: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                chain: "chain";
+                anchored: "anchored";
+            }>>;
+        }, z.core.$strip>>;
+        first_frame: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        id: z.ZodString;
+        inputs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        judge: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        keyframes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        kind: z.ZodEnum<{
+            "image.gen": "image.gen";
+            "image.edit": "image.edit";
+            "video.gen": "video.gen";
+            "video.extend": "video.extend";
+            "video.edit": "video.edit";
+            "video.upscale": "video.upscale";
+            "audio.tts": "audio.tts";
+            "audio.music": "audio.music";
+            "audio.sfx": "audio.sfx";
+            keyframes: "keyframes";
+            stitch: "stitch";
+        }>;
+        model: z.ZodOptional<z.ZodString>;
+        prompt: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodEnum<{
+            gmi: "gmi";
+            fal: "fal";
+            prodia: "prodia";
+            runware: "runware";
+        }>>;
+        reference_images: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        repeat: z.ZodOptional<z.ZodObject<{
+            default: z.ZodOptional<z.ZodNumber>;
+            max: z.ZodOptional<z.ZodNumber>;
+            min: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        retry: z.ZodOptional<z.ZodObject<{
+            backoff_s: z.ZodDefault<z.ZodNumber>;
+            fallback_model: z.ZodOptional<z.ZodString>;
+            fallback_provider: z.ZodOptional<z.ZodEnum<{
+                gmi: "gmi";
+                fal: "fal";
+                prodia: "prodia";
+                runware: "runware";
+            }>>;
+            max: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        rlhf: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"optional">, z.ZodBoolean]>>;
+        shared: z.ZodOptional<z.ZodBoolean>;
+        stitch: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+            engine: z.ZodDefault<z.ZodEnum<{
+                auto: "auto";
+                local: "local";
+                hyperframes: "hyperframes";
+            }>>;
+            fps: z.ZodOptional<z.ZodNumber>;
+            format: z.ZodDefault<z.ZodEnum<{
+                mp4: "mp4";
+                webm: "webm";
+            }>>;
+            quality: z.ZodDefault<z.ZodEnum<{
+                draft: "draft";
+                standard: "standard";
+                high: "high";
+            }>>;
+        }, z.core.$strip>>>;
+        tier: z.ZodOptional<z.ZodEnum<{
+            draft: "draft";
+            final: "final";
+        }>>;
+    }, z.core.$strip>>;
+    version: z.ZodLiteral<2>;
+    zap: z.ZodString;
+}, z.core.$strip>;
+export type ZapInput = z.infer<typeof zapInputSchema>;
+export type ZapStep = z.infer<typeof zapStepSchema>;
+export type ZapStepKind = z.infer<typeof zapStepKindSchema>;
+export type ZapSpec = z.infer<typeof zapSpecSchema>;
+export type PublicZapSpec = ZapSpec & {
+    title: string;
+};
+export declare function parseZapMarkdown(markdown: string): ZapSpec;
+export declare function validateZapPromptTemplates(spec: ZapSpec, promptContents: Record<string, string>): void;
+export declare function publicZapSpec(spec: ZapSpec): PublicZapSpec;

package/dist/schema.js

@@ -0,0 +1,194 @@
+import { parseDocument } from "yaml";
+import { z } from "zod";
+export class ZapSchemaError extends Error {
+    code = "SCHEMA_INVALID";
+    retryable = false;
+}
+export const zapInputSchema = z.object({
+    hint: z.string().optional(),
+    label: z.string().optional(),
+    options: z.array(z.string()).optional(),
+    required: z.boolean().default(false),
+    type: z.enum(["string", "textarea", "image", "video", "select", "number"]),
+});
+export const zapStepKindSchema = z.enum([
+    "image.gen",
+    "image.edit",
+    "video.gen",
+    "video.extend",
+    "video.edit",
+    "video.upscale",
+    "audio.tts",
+    "audio.music",
+    "audio.sfx",
+    "keyframes",
+    "stitch",
+]);
+export const zapProviderSchema = z.enum(["gmi", "fal", "prodia", "runware"]);
+export const zapStitchSchema = z.object({
+    engine: z.enum(["auto", "local", "hyperframes"]).default("auto"),
+    fps: z.number().int().min(1).max(120).optional(),
+    format: z.enum(["mp4", "webm"]).default("mp4"),
+    quality: z.enum(["draft", "standard", "high"]).default("standard"),
+}).default({ engine: "auto", format: "mp4", quality: "standard" });
+export const zapStepSchema = z.object({
+    audio: z.record(z.string(), z.unknown()).optional(),
+    candidates: z.number().int().min(1).max(16).optional(),
+    duration_s: z.number().positive().optional(),
+    extend: z.object({ mode: z.enum(["chain", "anchored"]).default("chain") }).optional(),
+    first_frame: z.record(z.string(), z.unknown()).optional(),
+    id: z.string().min(1),
+    inputs: z.array(z.string()).optional(),
+    judge: z.record(z.string(), z.unknown()).optional(),
+    keyframes: z.record(z.string(), z.unknown()).optional(),
+    kind: zapStepKindSchema,
+    model: z.string().optional(),
+    prompt: z.string().optional(),
+    provider: zapProviderSchema.optional(),
+    reference_images: z.array(z.string()).optional(),
+    repeat: z.object({
+        default: z.number().int().min(0).optional(),
+        max: z.number().int().min(0).max(64).optional(),
+        min: z.number().int().min(0).optional(),
+    }).optional(),
+    retry: z.object({
+        backoff_s: z.number().min(0).max(300).default(0),
+        fallback_model: z.string().optional(),
+        fallback_provider: zapProviderSchema.optional(),
+        max: z.number().int().min(0).max(8).default(0),
+    }).optional(),
+    rlhf: z.union([z.literal("optional"), z.boolean()]).optional(),
+    shared: z.boolean().optional(),
+    stitch: zapStitchSchema.optional(),
+    tier: z.enum(["draft", "final"]).optional(),
+});
+export const zapPublishSchema = z.object({
+    embed: z.object({
+        allowOrigins: z.array(z.string()).default(["*"]),
+        enabled: z.boolean().default(true),
+        height: z.number().int().min(240).max(2160).default(720),
+        theme: z.enum(["auto", "dark", "light"]).default("auto"),
+        width: z.number().int().min(240).max(3840).default(1280),
+    }).optional(),
+    slug: z.string().regex(/^[a-z0-9][a-z0-9-]{1,62}[a-z0-9]$/).optional(),
+    visibility: z.enum(["public", "unlisted", "private"]).default("public"),
+}).partial().optional();
+export const zapSpecSchema = z.object({
+    budget: z.object({
+        cap_usd: z.number().positive(),
+        estimate_usd: z.number().nonnegative(),
+    }),
+    defaults: z.object({
+        aspect: z.string().optional(),
+        models: z.record(z.string(), z.string()).default(() => ({})),
+        provider: zapProviderSchema.default("gmi"),
+    }).default(() => ({ models: {}, provider: "gmi" })),
+    description: z.string(),
+    inputs: z.record(z.string(), zapInputSchema).default({}),
+    output: z.string().default("Zap.mp4"),
+    publish: zapPublishSchema,
+    steps: z.array(zapStepSchema).min(1),
+    version: z.literal(2),
+    zap: z.string().regex(/^[a-z0-9][a-z0-9-]{1,62}[a-z0-9]$/),
+});
+export function parseZapMarkdown(markdown) {
+    const frontmatter = extractFrontmatter(markdown);
+    const parsed = parseDocument(frontmatter).toJS();
+    const spec = zapSpecSchema.parse(parsed);
+    validateSpec(spec);
+    return spec;
+}
+export function validateZapPromptTemplates(spec, promptContents) {
+    for (const step of spec.steps) {
+        const promptRef = step.prompt;
+        if (!promptRef || !isPromptFile(promptRef))
+            continue;
+        const content = promptContents[promptRef];
+        if (content === undefined) {
+            throw new ZapSchemaError(`Step ${step.id} references missing prompt file ${promptRef}.`);
+        }
+        validateTemplateVariables(spec, step.id, content);
+    }
+}
+export function publicZapSpec(spec) {
+    return { ...spec, title: titleize(spec.zap) };
+}
+function extractFrontmatter(markdown) {
+    const match = markdown.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) {
+        throw new Error("Zap recipe is missing YAML frontmatter.");
+    }
+    return match[1];
+}
+function validateSpec(spec) {
+    validateDuplicateStepIds(spec);
+    validateStepRefs(spec);
+    validateVideoDurations(spec);
+    validateInlineVariables(spec);
+}
+function validateInlineVariables(spec) {
+    for (const step of spec.steps) {
+        const promptRef = step.prompt ?? "";
+        if (!isPromptFile(promptRef))
+            validateTemplateVariables(spec, step.id, promptRef);
+    }
+}
+function validateDuplicateStepIds(spec) {
+    const seen = new Set();
+    for (const step of spec.steps) {
+        if (seen.has(step.id))
+            throw new Error(`Duplicate step id ${step.id}.`);
+        seen.add(step.id);
+    }
+}
+function validateStepRefs(spec) {
+    const declaredInputs = new Set(Object.keys(spec.inputs));
+    const priorSteps = new Set();
+    for (const step of spec.steps) {
+        for (const ref of [...(step.inputs ?? []), ...(step.reference_images ?? [])]) {
+            validateRef({ declaredInputs, priorSteps, ref, stepId: step.id });
+        }
+        priorSteps.add(step.id);
+    }
+}
+function validateRef({ declaredInputs, priorSteps, ref, stepId, }) {
+    if (ref.startsWith("user.")) {
+        const inputName = ref.slice("user.".length);
+        if (declaredInputs.has(inputName))
+            return;
+        throw new ZapSchemaError(`Step ${stepId} references undeclared input ${ref}.`);
+    }
+    if (ref.endsWith(".*")) {
+        const prefix = ref.slice(0, -2);
+        if (priorSteps.has(prefix))
+            return;
+        throw new ZapSchemaError(`Step ${stepId} references unknown repeated step ${ref}.`);
+    }
+    if (priorSteps.has(ref) || declaredInputs.has(ref))
+        return;
+    throw new ZapSchemaError(`Step ${stepId} references unknown input or step ${ref}.`);
+}
+function validateVideoDurations(spec) {
+    for (const step of spec.steps) {
+        if (step.kind.startsWith("video.") && step.duration_s === undefined) {
+            throw new ZapSchemaError(`Video step ${step.id} is missing duration_s.`);
+        }
+    }
+}
+function validateTemplateVariables(spec, stepId, template) {
+    const declared = new Set(Object.keys(spec.inputs));
+    for (const variable of template.matchAll(/\{([A-Z0-9_]+)\}/g)) {
+        if (!declared.has(variable[1])) {
+            throw new ZapSchemaError(`Step ${stepId} references undeclared input {${variable[1]}}.`);
+        }
+    }
+}
+function isPromptFile(prompt) {
+    return prompt.endsWith(".md") || prompt.startsWith("prompts/");
+}
+function titleize(slug) {
+    return slug
+        .split("-")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}

package/package.json

@@ -1,13 +1,22 @@
 {
   "name": "@wzrdtech/core",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "private": false,
   "description": "Core Zap recipe schema, planning, and registry utilities.",
   "license": "MIT",
   "type": "module",
+  "types": "./dist/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node ../../scripts/rewrite-dts-imports.mjs dist",
+    "prepack": "npm run build"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/gratitude5dee/Zap.git",
@@ -18,10 +27,22 @@
   },
   "homepage": "https://zap.wzrd.tech",
   "exports": {
-    ".": "./src/index.ts",
-    "./manifest": "./src/manifest.ts",
-    "./planner": "./src/planner.ts",
-    "./schema": "./src/schema.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./manifest": {
+      "types": "./dist/manifest.d.ts",
+      "import": "./dist/manifest.js"
+    },
+    "./planner": {
+      "types": "./dist/planner.d.ts",
+      "import": "./dist/planner.js"
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js"
+    }
   },
   "dependencies": {
     "yaml": "^2.8.1",