wizards 0.2.19 → 0.2.21

package/node_modules/@engenty-wizards/shared/dist/definition.d.ts

@@ -117,6 +117,7 @@ export declare const fieldSchema: z.ZodObject<{
     max: z.ZodOptional<z.ZodNumber>;
     camera: z.ZodOptional<z.ZodBoolean>;
     video: z.ZodOptional<z.ZodBoolean>;
+    listen: z.ZodOptional<z.ZodBoolean>;
     scan: z.ZodOptional<z.ZodBoolean>;
     connection: z.ZodOptional<z.ZodString>;
     list: z.ZodOptional<z.ZodString>;
@@ -201,6 +202,7 @@ export declare const pageStepSchema: z.ZodObject<{
         max: z.ZodOptional<z.ZodNumber>;
         camera: z.ZodOptional<z.ZodBoolean>;
         video: z.ZodOptional<z.ZodBoolean>;
+        listen: z.ZodOptional<z.ZodBoolean>;
         scan: z.ZodOptional<z.ZodBoolean>;
         connection: z.ZodOptional<z.ZodString>;
         list: z.ZodOptional<z.ZodString>;
@@ -385,6 +387,60 @@ export declare const widgetStepSchema: z.ZodObject<{
         goto: z.ZodString;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
+/** Formats a film step makes; the composition is drawn for this frame. */
+export declare const FILM_FORMATS: readonly ["16:9", "9:16", "1:1"];
+export type FilmFormat = (typeof FILM_FORMATS)[number];
+export declare const FILM_SIZES: Record<FilmFormat, {
+    width: number;
+    height: number;
+}>;
+/**
+ * A film the AI client installed on this machine makes in a folder of its own: it writes the
+ * composition as code (HTML, CSS, JS) with the skills it is given, looks at its frames and fixes
+ * them; the runtime renders the MP4. It runs on the person's subscription, never on credits.
+ */
+export declare const filmStepSchema: z.ZodObject<{
+    type: z.ZodLiteral<"film">;
+    brief: z.ZodString;
+    skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    kit: z.ZodOptional<z.ZodString>;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    format: z.ZodDefault<z.ZodEnum<{
+        "1:1": "1:1";
+        "16:9": "16:9";
+        "9:16": "9:16";
+    }>>;
+    seconds: z.ZodOptional<z.ZodNumber>;
+    model: z.ZodOptional<z.ZodEnum<{
+        classifier: "classifier";
+        standard: "standard";
+        high: "high";
+        highest: "highest";
+    }>>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        medium: "medium";
+        high: "high";
+        low: "low";
+    }>>;
+    working: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                in: "in";
+                equals: "equals";
+                notEquals: "notEquals";
+                notEmpty: "notEmpty";
+                empty: "empty";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>;
+        goto: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 export declare const reviewStepSchema: z.ZodObject<{
     type: z.ZodLiteral<"review">;
     show: z.ZodArray<z.ZodString>;
@@ -514,6 +570,7 @@ export declare const stepSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         max: z.ZodOptional<z.ZodNumber>;
         camera: z.ZodOptional<z.ZodBoolean>;
         video: z.ZodOptional<z.ZodBoolean>;
+        listen: z.ZodOptional<z.ZodBoolean>;
         scan: z.ZodOptional<z.ZodBoolean>;
         connection: z.ZodOptional<z.ZodString>;
         list: z.ZodOptional<z.ZodString>;
@@ -694,6 +751,47 @@ export declare const stepSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }, z.core.$strip>;
         goto: z.ZodString;
     }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"film">;
+    brief: z.ZodString;
+    skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    kit: z.ZodOptional<z.ZodString>;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    format: z.ZodDefault<z.ZodEnum<{
+        "1:1": "1:1";
+        "16:9": "16:9";
+        "9:16": "9:16";
+    }>>;
+    seconds: z.ZodOptional<z.ZodNumber>;
+    model: z.ZodOptional<z.ZodEnum<{
+        classifier: "classifier";
+        standard: "standard";
+        high: "high";
+        highest: "highest";
+    }>>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        medium: "medium";
+        high: "high";
+        low: "low";
+    }>>;
+    working: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        when: z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                in: "in";
+                equals: "equals";
+                notEquals: "notEquals";
+                notEmpty: "notEmpty";
+                empty: "empty";
+            }>;
+            value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+        }, z.core.$strip>;
+        goto: z.ZodString;
+    }, z.core.$strip>>>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"review">;
     show: z.ZodArray<z.ZodString>;
@@ -766,6 +864,7 @@ export type AgentStep = z.infer<typeof agentStepSchema>;
 export declare function isDecisionStep(step: AgentStep): boolean;
 export type GenerateStep = z.infer<typeof generateStepSchema>;
 export type WidgetStep = z.infer<typeof widgetStepSchema>;
+export type FilmStep = z.infer<typeof filmStepSchema>;
 export type ReviewStep = z.infer<typeof reviewStepSchema>;
 export type ResultStep = z.infer<typeof resultStepSchema>;
 export type StepType = Step["type"];
@@ -1129,6 +1228,7 @@ export declare const wizardSchema: z.ZodObject<{
             max: z.ZodOptional<z.ZodNumber>;
             camera: z.ZodOptional<z.ZodBoolean>;
             video: z.ZodOptional<z.ZodBoolean>;
+            listen: z.ZodOptional<z.ZodBoolean>;
             scan: z.ZodOptional<z.ZodBoolean>;
             connection: z.ZodOptional<z.ZodString>;
             list: z.ZodOptional<z.ZodString>;
@@ -1309,6 +1409,47 @@ export declare const wizardSchema: z.ZodObject<{
             }, z.core.$strip>;
             goto: z.ZodString;
         }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"film">;
+        brief: z.ZodString;
+        skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        kit: z.ZodOptional<z.ZodString>;
+        inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        format: z.ZodDefault<z.ZodEnum<{
+            "1:1": "1:1";
+            "16:9": "16:9";
+            "9:16": "9:16";
+        }>>;
+        seconds: z.ZodOptional<z.ZodNumber>;
+        model: z.ZodOptional<z.ZodEnum<{
+            classifier: "classifier";
+            standard: "standard";
+            high: "high";
+            highest: "highest";
+        }>>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            medium: "medium";
+            high: "high";
+            low: "low";
+        }>>;
+        working: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        next: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    in: "in";
+                    equals: "equals";
+                    notEquals: "notEquals";
+                    notEmpty: "notEmpty";
+                    empty: "empty";
+                }>;
+                value: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+            }, z.core.$strip>;
+            goto: z.ZodString;
+        }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"review">;
         show: z.ZodArray<z.ZodString>;
@@ -1373,6 +1514,11 @@ export declare const wizardSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type WizardDefinition = z.infer<typeof wizardSchema>;
 export declare const INTERACTIVE: ReadonlySet<StepType>;
+/**
+ * A wizard with a film step runs only where an AI client is installed and signed in, on the
+ * person's own subscription: one film takes a client many minutes and many tokens.
+ */
+export declare function needsInstalledClient(def: WizardDefinition): boolean;
 export declare function isInteractive(step: Step): boolean;
 /** Which formats each producing step can be downloaded in. */
 export declare function formatsFor(step: Step): Format[];

package/node_modules/@engenty-wizards/shared/dist/definition.js

@@ -141,6 +141,11 @@ export const fieldSchema = z.object({
     camera: z.boolean().optional(),
     /** file: the camera also records short video clips. */
     video: z.boolean().optional(),
+    /**
+     * file: a recording (video or audio) is listened to before the next step runs — what is said,
+     * piece by piece between pauses, with exact times. Read as {{field.speech}}.
+     */
+    listen: z.boolean().optional(),
     /** text: also fill it by scanning a QR code or barcode with the camera. */
     scan: z.boolean().optional(),
     /** connection: id of the wizard connection the person connects here. */
@@ -274,6 +279,46 @@ export const widgetStepSchema = z.object({
     video: z.boolean().optional(),
     working: z.string().optional(),
 });
+/** Formats a film step makes; the composition is drawn for this frame. */
+export const FILM_FORMATS = ["16:9", "9:16", "1:1"];
+export const FILM_SIZES = {
+    "16:9": { width: 1920, height: 1080 },
+    "9:16": { width: 1080, height: 1920 },
+    "1:1": { width: 1080, height: 1080 },
+};
+/**
+ * A film the AI client installed on this machine makes in a folder of its own: it writes the
+ * composition as code (HTML, CSS, JS) with the skills it is given, looks at its frames and fixes
+ * them; the runtime renders the MP4. It runs on the person's subscription, never on credits.
+ */
+export const filmStepSchema = z.object({
+    ...stepBase,
+    type: z.literal("film"),
+    /** What the film is: story, look, what to use. A template. */
+    brief: z.string().min(1),
+    /**
+     * Skill packages the client reads: platform packages ("hyperframes") or a folder of the
+     * workspace with a SKILL.md ("skills/<name>").
+     */
+    skills: z.array(z.string().min(1)).max(12).default(["hyperframes"]),
+    /**
+     * A style kit in the workspace — a showreel made once with its rules, helpers and stills, as
+     * a .zip — unpacked as `showcase/`: the bar every film of this wizard is made to.
+     */
+    kit: z.string().optional(),
+    /**
+     * What the film is made from: name → a field id or "steps.<id>". Files (uploads, voice lines,
+     * pictures) are copied into `input/<name>/`, text is written to `input/<name>.md`.
+     */
+    inputs: z.record(z.string(), z.string()).default({}),
+    format: z.enum(FILM_FORMATS).default("16:9"),
+    /** About how long the film runs, in seconds. */
+    seconds: z.number().int().min(3).max(600).optional(),
+    /** The kind of model; default `standard` — the kit carries the craft. */
+    model: z.enum(TEXT_CLASSES).optional(),
+    effort: z.enum(EFFORTS).optional(),
+    working: z.string().optional(),
+});
 export const reviewStepSchema = z.object({
     ...stepBase,
     type: z.literal("review"),
@@ -298,6 +343,7 @@ export const stepSchema = z.discriminatedUnion("type", [
     agentStepSchema,
     generateStepSchema,
     widgetStepSchema,
+    filmStepSchema,
     reviewStepSchema,
     resultStepSchema,
 ]);
@@ -366,6 +412,13 @@ export const wizardSchema = z.object({
     steps: z.array(stepSchema).min(1),
 });
 export const INTERACTIVE = new Set(["page", "review", "result"]);
+/**
+ * A wizard with a film step runs only where an AI client is installed and signed in, on the
+ * person's own subscription: one film takes a client many minutes and many tokens.
+ */
+export function needsInstalledClient(def) {
+    return def.steps.some((s) => s.type === "film");
+}
 export function isInteractive(step) {
     return INTERACTIVE.has(step.type);
 }
@@ -385,6 +438,9 @@ export function formatsFor(step) {
                 return ["html", "pdf", "png"];
         }
     }
+    if (step.type === "film") {
+        return ["mp4"];
+    }
     if (step.type === "widget") {
         return step.video ? ["mp4", "png"] : ["html", "png", "pdf", "mp4", "json"];
     }
@@ -524,6 +580,12 @@ export function validateWizard(def, files) {
                         message: `Field "${field.id}": "scan" fills a text field; kind is "${field.kind}".`,
                     });
                 }
+                if (field.listen && field.kind !== "file") {
+                    issues.push({
+                        stepId: step.id,
+                        message: `Field "${field.id}": "listen" belongs to a file field; kind is "${field.kind}".`,
+                    });
+                }
                 if (field.video && field.kind !== "file") {
                     issues.push({
                         stepId: step.id,
@@ -601,6 +663,7 @@ export function validateWizard(def, files) {
                 break;
             case "generate":
                 checkTemplate(step, step.prompt);
+                checkTemplate(step, step.options?.style ?? "");
                 if (step.referenceImage &&
                     !seenFields.has(step.referenceImage) &&
                     !seenSteps.has(step.referenceImage)) {
@@ -648,6 +711,44 @@ export function validateWizard(def, files) {
                     });
                 }
                 break;
+            case "film":
+                checkTemplate(step, step.brief);
+                for (const [name, ref] of Object.entries(step.inputs)) {
+                    if (!/^[a-z][a-z0-9-]{0,40}$/.test(name)) {
+                        issues.push({
+                            stepId: step.id,
+                            message: `Film input "${name}" is not a folder name (lowercase letters, digits, -).`,
+                        });
+                    }
+                    const r = dataRef(ref);
+                    if (r.startsWith("steps.")) {
+                        checkTemplate(step, `{{${r}}}`);
+                    }
+                    else if (!seenFields.has(r)) {
+                        issues.push({
+                            stepId: step.id,
+                            message: `Film input "${name}": "${ref}" is not an earlier field or "steps.<id>".`,
+                        });
+                    }
+                }
+                if (step.kit && !step.kit.endsWith(".zip")) {
+                    issues.push({ stepId: step.id, message: `Film kit "${step.kit}" is a .zip.` });
+                }
+                else if (files && step.kit && !files.includes(step.kit)) {
+                    issues.push({
+                        stepId: step.id,
+                        message: `Film kit "${step.kit}" is not in the workspace.`,
+                    });
+                }
+                for (const skill of step.skills) {
+                    if (skill.startsWith("skills/") && files && !files.includes(`${skill}/SKILL.md`)) {
+                        issues.push({
+                            stepId: step.id,
+                            message: `Skill "${skill}" has no SKILL.md in the workspace.`,
+                        });
+                    }
+                }
+                break;
             case "review":
                 for (const ref of step.show) {
                     const list = listRef(ref);

package/node_modules/@engenty-wizards/shared/dist/marketplace-entry.js

@@ -53,6 +53,9 @@ function resultKind(definition, from) {
     if (step?.type === "widget") {
         return step.video ? "video" : "dashboard";
     }
+    if (step?.type === "film") {
+        return "video";
+    }
     return step?.type === "agent" && step.output.format === "json" ? "table" : "text";
 }
 export function resultsOf(definition) {

package/node_modules/@engenty-wizards/shared/dist/marketplace.d.ts

@@ -174,6 +174,11 @@ export declare const CAPABILITIES: {
         de: string;
         en: string;
     };
+    /** A film the installed client makes: only on a computer with Claude Code, on its subscription. */
+    film: {
+        de: string;
+        en: string;
+    };
 };
 export type Capability = keyof typeof CAPABILITIES;
 export declare const COST_TIERS: {
@@ -194,7 +199,7 @@ export type CostTier = keyof typeof COST_TIERS;
 export declare const ITEM_FORMAT_IDS: ("text" | "image" | "audio" | "video" | "document" | "dashboard" | "table")[];
 export declare const INDUSTRY_IDS: ("any" | "trades" | "gastronomy" | "hospitality" | "realEstate" | "retail" | "health" | "professional" | "agency" | "events" | "publicSector")[];
 export declare const USE_CASE_IDS: ("marketing" | "sales" | "accounting" | "service" | "research" | "hr" | "operations" | "website" | "visuals" | "inquiries" | "advice")[];
-export declare const CAPABILITY_IDS: ("text" | "code" | "image" | "browser" | "video" | "speech" | "web" | "documents" | "listening" | "connectors")[];
+export declare const CAPABILITY_IDS: ("text" | "code" | "image" | "browser" | "video" | "speech" | "film" | "web" | "documents" | "listening" | "connectors")[];
 /** The formats a run hands over, read from what the result step offers. */
 export declare function formatsOf(def: WizardDefinition): ItemFormat[];
 /** The capabilities a definition needs, read from its steps. */

package/node_modules/@engenty-wizards/shared/dist/marketplace.js

@@ -52,6 +52,11 @@ export const CAPABILITIES = {
     listening: { de: "Sprachnotizen verstehen", en: "Understands voice notes" },
     code: { de: "Code ausführen", en: "Runs code" },
     connectors: { de: "Verbundene Konten & Systeme", en: "Connected accounts & systems" },
+    /** A film the installed client makes: only on a computer with Claude Code, on its subscription. */
+    film: {
+        de: "Filme mit Claude Code (auf deinem Abo)",
+        en: "Films with Claude Code (on your subscription)",
+    },
 };
 export const COST_TIERS = {
     low: { de: "günstig", en: "low cost" },
@@ -150,6 +155,9 @@ export function capabilitiesOf(def) {
                 found.add("text");
             }
         }
+        else if (step.type === "film") {
+            found.add("film");
+        }
     }
     if (def.connections?.length) {
         found.add("connectors");
@@ -195,6 +203,10 @@ export function effortOf(def) {
         else if (step.type === "widget" && step.video) {
             seconds += 60;
         }
+        else if (step.type === "film") {
+            // A client writing a film from a style kit: ten minutes to half an hour (2026-10 tests).
+            seconds += 25 * 60;
+        }
     }
     return { fields, required, reviews, minutes: Math.max(1, Math.round(seconds / 60)) };
 }

package/node_modules/@engenty-wizards/shared/dist/run.d.ts

@@ -34,6 +34,12 @@ export interface RunState {
     notes: Record<string, string>;
     /** Steps that make several results: the entries (from 0) to make again; the others stay. */
     redo?: Record<string, number[]>;
+    /** File fields with `listen`: what is said in the recording, piece by piece with its times. */
+    heard?: Record<string, {
+        start: number;
+        end: number;
+        text: string;
+    }[]>;
 }
 interface AskBase {
     id: string;
@@ -249,6 +255,30 @@ export declare const RUN_NOTES: {
         readonly de: "Legt {count} Dateien ab";
         readonly en: "Filing {count} files";
     };
+    readonly filmSetup: {
+        readonly de: "Richtet den Arbeitsordner für den Film ein";
+        readonly en: "Setting up the folder for the film";
+    };
+    readonly filmClient: {
+        readonly de: "{client} arbeitet am Film – das dauert meist 10–40 Minuten.";
+        readonly en: "{client} is working on the film – this usually takes 10–40 minutes.";
+    };
+    readonly filmTask: {
+        readonly de: "Am Film: {task}";
+        readonly en: "On the film: {task}";
+    };
+    readonly filmLooks: {
+        readonly de: "Sieht sich Bilder des Films an";
+        readonly en: "Looking at frames of the film";
+    };
+    readonly filmFix: {
+        readonly de: "Der Film ließ sich nicht rendern – Claude Code bessert nach";
+        readonly en: "The film did not render – Claude Code is fixing it";
+    };
+    readonly filmResume: {
+        readonly de: "Macht dort weiter, wo der Film stehen geblieben ist";
+        readonly en: "Picking the film up where it stopped";
+    };
 };
 export type RunNoteCode = keyof typeof RUN_NOTES;
 /** A line of `RUN_NOTES` with what goes into its gaps. */

package/node_modules/@engenty-wizards/shared/dist/run.js

@@ -66,6 +66,24 @@ export const RUN_NOTES = {
     },
     remembers: { de: "Merkt sich {title}", en: "Remembering {title}" },
     files: { de: "Legt {count} Dateien ab", en: "Filing {count} files" },
+    filmSetup: {
+        de: "Richtet den Arbeitsordner für den Film ein",
+        en: "Setting up the folder for the film",
+    },
+    filmClient: {
+        de: "{client} arbeitet am Film – das dauert meist 10–40 Minuten.",
+        en: "{client} is working on the film – this usually takes 10–40 minutes.",
+    },
+    filmTask: { de: "Am Film: {task}", en: "On the film: {task}" },
+    filmLooks: { de: "Sieht sich Bilder des Films an", en: "Looking at frames of the film" },
+    filmFix: {
+        de: "Der Film ließ sich nicht rendern – Claude Code bessert nach",
+        en: "The film did not render – Claude Code is fixing it",
+    },
+    filmResume: {
+        de: "Macht dort weiter, wo der Film stehen geblieben ist",
+        en: "Picking the film up where it stopped",
+    },
 };
 /** A note in a language, its gaps filled. */
 export function noteText(note, lang) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wizards",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "description": "Make a wish. Get your wizard. It guides you step by step. Let AI do the work. Runs on your machine, on the AI subscription you already have.",
   "license": "FSL-1.1-MIT",
   "homepage": "https://engenty.ai",