@horizon36596/zenith-mcp 0.1.1

package/dist/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../src/result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEzE,uGAAuG;AACvG,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,cAAc,CAExD;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CAG1D;AAED,6GAA6G;AAC7G,wBAAgB,OAAO,CAAC,IAAI,SAAS,OAAO,EAAE,EAC5C,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,cAAc,CAAC,GAAG,cAAc,GACnE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,cAAc,CAAC,CAQ5C"}

package/dist/result.js

@@ -0,0 +1,27 @@
+/** Every tool returns structured JSON text, pretty-printed so a human reading a transcript can too. */
+export function jsonResult(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+/**
+ * Turns a thrown error into an MCP tool error result instead of letting it crash the server. The
+ * known error types this project throws (`ProjectError`, core's `EditError` and
+ * `NotImplementedError`, schema's `SchemaError`) all carry a message written for whoever is
+ * holding the file; anything else is reported by its message too, since a stack trace is not
+ * useful to an agent reading a tool result.
+ */
+export function errorResult(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { content: [{ type: "text", text: message }], isError: true };
+}
+/** Wraps a tool handler so anything it throws becomes a tool error result instead of crashing the server. */
+export function guarded(handler) {
+    return async (...args) => {
+        try {
+            return await handler(...args);
+        }
+        catch (error) {
+            return errorResult(error);
+        }
+    };
+}
+//# sourceMappingURL=result.js.map

package/dist/result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.js","sourceRoot":"","sources":["../src/result.ts"],"names":[],"mappings":"AAEA,uGAAuG;AACvG,MAAM,UAAU,UAAU,CAAC,IAAa;IACtC,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC;AAC9E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,KAAc;IACxC,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACvE,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;AACvE,CAAC;AAED,6GAA6G;AAC7G,MAAM,UAAU,OAAO,CACrB,OAAoE;IAEpE,OAAO,KAAK,EAAE,GAAG,IAAU,EAAE,EAAE;QAC7B,IAAI,CAAC;YACH,OAAO,MAAM,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;QAChC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,WAAW,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC,CAAC;AACJ,CAAC"}

package/dist/schemas.d.ts

@@ -0,0 +1,576 @@
+import { z } from "zod";
+/**
+ * JSON Schema input shapes for the `zenith.edit.*` tools, mirroring `packages/schema/src/auto.ts`
+ * structurally so an MCP client can see exactly what a step, segment or marker looks like.
+ *
+ * These are written by hand against `zod` (the MCP SDK's peer version) rather than imported from
+ * `@horizon36596/zenith-schema` (which pins `zod` 3): the two packages can carry different major versions of
+ * `zod` side by side, but their schema objects are not interchangeable. The edit primitives in
+ * `@horizon36596/zenith-core` are the actual source of truth — every `zenith.edit.*` call still round-trips
+ * through `parseAuto` inside `finish()` (`packages/core/src/edit/finish.ts`), so a shape that
+ * slips past this file is still caught there with a precise `EditError`. `steps` inside a
+ * `parallel` or `branch` step are typed loosely (`z.unknown()`) rather than recursively for the
+ * same reason: the recursion is finitely enforced downstream, not lost.
+ */
+export declare const poseInputSchema: z.ZodObject<{
+    xIn: z.ZodNumber;
+    yIn: z.ZodNumber;
+    headingRad: z.ZodOptional<z.ZodNumber>;
+    provenance: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const poseRefSchema: z.ZodObject<{
+    ref: z.ZodString;
+}, z.core.$strip>;
+export declare const poseSourceSchema: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+    ref: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    xIn: z.ZodNumber;
+    yIn: z.ZodNumber;
+    headingRad: z.ZodOptional<z.ZodNumber>;
+    provenance: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+export declare const lineSegmentSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"line">;
+    from: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    to: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
+export declare const bezierSegmentSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"bezier">;
+    from: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    control: z.ZodArray<z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    to: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
+export declare const segmentSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"line">;
+    from: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    to: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"bezier">;
+    from: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    control: z.ZodArray<z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    to: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>], "kind">;
+export declare const headingRangeSchema: z.ZodObject<{
+    startT: z.ZodNumber;
+    endT: z.ZodNumber;
+    heading: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"tangent">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"tangentReversed">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"constant">;
+        headingRad: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"linear">;
+        fromRad: z.ZodNumber;
+        toRad: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"facePoint">;
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        offsetRad: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>], "mode">;
+}, z.core.$strip>;
+export declare const headingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"tangent">;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"tangentReversed">;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"constant">;
+    headingRad: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"linear">;
+    fromRad: z.ZodNumber;
+    toRad: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"facePoint">;
+    xIn: z.ZodNumber;
+    yIn: z.ZodNumber;
+    offsetRad: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"piecewise">;
+    ranges: z.ZodArray<z.ZodObject<{
+        startT: z.ZodNumber;
+        endT: z.ZodNumber;
+        heading: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            mode: z.ZodLiteral<"tangent">;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodLiteral<"tangentReversed">;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodLiteral<"constant">;
+            headingRad: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodLiteral<"linear">;
+            fromRad: z.ZodNumber;
+            toRad: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodLiteral<"facePoint">;
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            offsetRad: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>], "mode">;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "mode">;
+export declare const commandArgsSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+export declare const commandCallSchema: z.ZodObject<{
+    name: z.ZodString;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+}, z.core.$strip>;
+export declare const markerAtSchema: z.ZodUnion<readonly [z.ZodObject<{
+    t: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    distanceIn: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    distanceFromEndIn: z.ZodNumber;
+}, z.core.$strip>]>;
+export declare const markerSchema: z.ZodObject<{
+    at: z.ZodUnion<readonly [z.ZodObject<{
+        t: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        distanceIn: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        distanceFromEndIn: z.ZodNumber;
+    }, z.core.$strip>]>;
+    command: z.ZodObject<{
+        name: z.ZodString;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const expectSchema: z.ZodObject<{
+    collectFrom: z.ZodOptional<z.ZodString>;
+    count: z.ZodOptional<z.ZodNumber>;
+    launchesInto: z.ZodOptional<z.ZodString>;
+    tip: z.ZodOptional<z.ZodEnum<{
+        own: "own";
+        opponent: "opponent";
+    }>>;
+}, z.core.$strip>;
+export declare const pathStepInputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"path">;
+    timeoutS: z.ZodOptional<z.ZodNumber>;
+    segments: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"line">;
+        from: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+        to: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"bezier">;
+        from: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+        control: z.ZodArray<z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        to: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>], "kind">>;
+    heading: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"tangent">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"tangentReversed">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"constant">;
+        headingRad: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"linear">;
+        fromRad: z.ZodNumber;
+        toRad: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"facePoint">;
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        offsetRad: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"piecewise">;
+        ranges: z.ZodArray<z.ZodObject<{
+            startT: z.ZodNumber;
+            endT: z.ZodNumber;
+            heading: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"tangent">;
+            }, z.core.$strip>, z.ZodObject<{
+                mode: z.ZodLiteral<"tangentReversed">;
+            }, z.core.$strip>, z.ZodObject<{
+                mode: z.ZodLiteral<"constant">;
+                headingRad: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                mode: z.ZodLiteral<"linear">;
+                fromRad: z.ZodNumber;
+                toRad: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                mode: z.ZodLiteral<"facePoint">;
+                xIn: z.ZodNumber;
+                yIn: z.ZodNumber;
+                offsetRad: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>], "mode">;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "mode">>;
+    speedFraction: z.ZodOptional<z.ZodNumber>;
+    markers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        at: z.ZodUnion<readonly [z.ZodObject<{
+            t: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            distanceIn: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            distanceFromEndIn: z.ZodNumber;
+        }, z.core.$strip>]>;
+        command: z.ZodObject<{
+            name: z.ZodString;
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    endCondition: z.ZodOptional<z.ZodObject<{
+        condition: z.ZodString;
+    }, z.core.$strip>>;
+    expect: z.ZodOptional<z.ZodObject<{
+        collectFrom: z.ZodOptional<z.ZodString>;
+        count: z.ZodOptional<z.ZodNumber>;
+        launchesInto: z.ZodOptional<z.ZodString>;
+        tip: z.ZodOptional<z.ZodEnum<{
+            own: "own";
+            opponent: "opponent";
+        }>>;
+    }, z.core.$strip>>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const commandStepInputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"command">;
+    name: z.ZodString;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    timeoutS: z.ZodOptional<z.ZodNumber>;
+    expect: z.ZodOptional<z.ZodObject<{
+        collectFrom: z.ZodOptional<z.ZodString>;
+        count: z.ZodOptional<z.ZodNumber>;
+        launchesInto: z.ZodOptional<z.ZodString>;
+        tip: z.ZodOptional<z.ZodEnum<{
+            own: "own";
+            opponent: "opponent";
+        }>>;
+    }, z.core.$strip>>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const waitStepInputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"wait">;
+    seconds: z.ZodOptional<z.ZodNumber>;
+    until: z.ZodOptional<z.ZodString>;
+    timeoutS: z.ZodOptional<z.ZodNumber>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const sequenceStepInputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"sequence">;
+    steps: z.ZodArray<z.ZodUnknown>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const parallelStepInputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"parallel">;
+    mode: z.ZodEnum<{
+        all: "all";
+        race: "race";
+        deadline: "deadline";
+    }>;
+    deadline: z.ZodOptional<z.ZodString>;
+    steps: z.ZodArray<z.ZodUnknown>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const branchStepInputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"branch">;
+    condition: z.ZodString;
+    then: z.ZodArray<z.ZodUnknown>;
+    else: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const stepInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"path">;
+    timeoutS: z.ZodOptional<z.ZodNumber>;
+    segments: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"line">;
+        from: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+        to: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"bezier">;
+        from: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+        control: z.ZodArray<z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        to: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+            ref: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            xIn: z.ZodNumber;
+            yIn: z.ZodNumber;
+            headingRad: z.ZodOptional<z.ZodNumber>;
+            provenance: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>], "kind">>;
+    heading: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"tangent">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"tangentReversed">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"constant">;
+        headingRad: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"linear">;
+        fromRad: z.ZodNumber;
+        toRad: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"facePoint">;
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        offsetRad: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"piecewise">;
+        ranges: z.ZodArray<z.ZodObject<{
+            startT: z.ZodNumber;
+            endT: z.ZodNumber;
+            heading: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"tangent">;
+            }, z.core.$strip>, z.ZodObject<{
+                mode: z.ZodLiteral<"tangentReversed">;
+            }, z.core.$strip>, z.ZodObject<{
+                mode: z.ZodLiteral<"constant">;
+                headingRad: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                mode: z.ZodLiteral<"linear">;
+                fromRad: z.ZodNumber;
+                toRad: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                mode: z.ZodLiteral<"facePoint">;
+                xIn: z.ZodNumber;
+                yIn: z.ZodNumber;
+                offsetRad: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>], "mode">;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "mode">>;
+    speedFraction: z.ZodOptional<z.ZodNumber>;
+    markers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        at: z.ZodUnion<readonly [z.ZodObject<{
+            t: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            distanceIn: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            distanceFromEndIn: z.ZodNumber;
+        }, z.core.$strip>]>;
+        command: z.ZodObject<{
+            name: z.ZodString;
+            args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    endCondition: z.ZodOptional<z.ZodObject<{
+        condition: z.ZodString;
+    }, z.core.$strip>>;
+    expect: z.ZodOptional<z.ZodObject<{
+        collectFrom: z.ZodOptional<z.ZodString>;
+        count: z.ZodOptional<z.ZodNumber>;
+        launchesInto: z.ZodOptional<z.ZodString>;
+        tip: z.ZodOptional<z.ZodEnum<{
+            own: "own";
+            opponent: "opponent";
+        }>>;
+    }, z.core.$strip>>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"command">;
+    name: z.ZodString;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+    timeoutS: z.ZodOptional<z.ZodNumber>;
+    expect: z.ZodOptional<z.ZodObject<{
+        collectFrom: z.ZodOptional<z.ZodString>;
+        count: z.ZodOptional<z.ZodNumber>;
+        launchesInto: z.ZodOptional<z.ZodString>;
+        tip: z.ZodOptional<z.ZodEnum<{
+            own: "own";
+            opponent: "opponent";
+        }>>;
+    }, z.core.$strip>>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"wait">;
+    seconds: z.ZodOptional<z.ZodNumber>;
+    until: z.ZodOptional<z.ZodString>;
+    timeoutS: z.ZodOptional<z.ZodNumber>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"sequence">;
+    steps: z.ZodArray<z.ZodUnknown>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"parallel">;
+    mode: z.ZodEnum<{
+        all: "all";
+        race: "race";
+        deadline: "deadline";
+    }>;
+    deadline: z.ZodOptional<z.ZodString>;
+    steps: z.ZodArray<z.ZodUnknown>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"branch">;
+    condition: z.ZodString;
+    then: z.ZodArray<z.ZodUnknown>;
+    else: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    notes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "kind">;
+export declare const intoGroupSchema: z.ZodObject<{
+    into: z.ZodString;
+    index: z.ZodOptional<z.ZodNumber>;
+    arm: z.ZodOptional<z.ZodEnum<{
+        then: "then";
+        else: "else";
+    }>>;
+}, z.core.$strip>;
+export declare const poseTargetSchema: z.ZodObject<{
+    segmentIndex: z.ZodNumber;
+    pointKind: z.ZodEnum<{
+        to: "to";
+        from: "from";
+        control: "control";
+    }>;
+    controlIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const startInputSchema: z.ZodObject<{
+    pose: z.ZodUnion<readonly [z.ZodLiteral<"current">, z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        xIn: z.ZodNumber;
+        yIn: z.ZodNumber;
+        headingRad: z.ZodOptional<z.ZodNumber>;
+        provenance: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    holds: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const autoMetaSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    authors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export declare const autoRefField: z.ZodString;
+export declare const projectField: z.ZodOptional<z.ZodString>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,eAAe;;;;;iBAUzB,CAAC;AAEJ,eAAO,MAAM,aAAa;;iBAEsB,CAAC;AAEjD,eAAO,MAAM,gBAAgB;;;;;;;mBAI1B,CAAC;AAEJ,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;iBAI5B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;iBAK9B,CAAC;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAE+B,CAAC;AAe1D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;iBAM0F,CAAC;AAE1H,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAW8F,CAAC;AAEzH,eAAO,MAAM,iBAAiB,yFAEuD,CAAC;AAEtF,eAAO,MAAM,iBAAiB;;;iBAG5B,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;mBAM2D,CAAC;AAEvF,eAAO,MAAM,YAAY;;;;;;;;;;;;iBAA+D,CAAC;AAEzF,eAAO,MAAM,YAAY;;;;;;;;iBAKvB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAW9B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;iBAQjC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;iBAO9B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;iBAOlC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;;;;;;iBAOlC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;iBAOhC,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BASwG,CAAC;AAErI,eAAO,MAAM,eAAe;;;;;;;iBAWuE,CAAC;AAEpG,eAAO,MAAM,gBAAgB;;;;;;;;iBAI3B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;iBAG3B,CAAC;AAMH,eAAO,MAAM,cAAc;;;;iBAIzB,CAAC;AAEH,eAAO,MAAM,YAAY,aAKtB,CAAC;AAEJ,eAAO,MAAM,YAAY,4BAGuF,CAAC"}