@rayspec/spec 1.5.0

package/dist/grammar.d.ts

@@ -0,0 +1,569 @@
+import { z } from 'zod';
+/** The supported spec major.minor. Parsed FIRST (two-phase) so an unknown major fails cleanly. */
+export declare const SPEC_VERSION: "1.0";
+/** Minimal deployment metadata. `name` identifies the backend; extend later as needed. */
+export declare const Metadata: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type Metadata = z.infer<typeof Metadata>;
+/**
+ * Deployment-level properties of a backend. These describe HOW the
+ * deployment runs, NOT what any SDK can do — so `async`/off-request execution belongs HERE, on the
+ * spec, gated by "is a durable worker configured?", and is INVISIBLE to the neutral `Backend`
+ * interface and the per-backend `CapabilityDescriptor` (which must NOT be touched: whether a run
+ * executes off-request has no backend asymmetry to absorb — `runAgent` takes the same `ctx`
+ * in-request or off-request).
+ *
+ *  - `durableWorker` — when true, the deployment runs a durable off-request worker (DBOS),
+ *    so a per-request `async:true` run is enqueued onto it (202 + runId) rather than fail-closed-501.
+ *    A lint rule (lint.ts) enforces it: a spec must not be deployed expecting async without it — but
+ *    the LOAD-BEARING gate is the RUNTIME one (the run surface 501s if no executor is wired,
+ *    regardless of this flag), so this is a declaration + a static best-effort check, defense-in-depth.
+ */
+export declare const DeploymentSpec: z.ZodObject<{
+    durableWorker: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type DeploymentSpec = z.infer<typeof DeploymentSpec>;
+/**
+ * The closed set of column types an author may declare. Small + closed so the store generator
+ * can map each to a Drizzle/Postgres type deterministically and the migration gate sees a finite
+ * vocabulary. (Authors declare BUSINESS columns only — the tenancy/GDPR columns `tenant_id`,
+ * `id`, `created_at`, `deleted_at`, `retention_days`, `region` are INJECTED by the generator,
+ * never declared here.)
+ */
+export declare const ColumnType: z.ZodEnum<{
+    boolean: "boolean";
+    text: "text";
+    uuid: "uuid";
+    timestamp: "timestamp";
+    integer: "integer";
+    jsonb: "jsonb";
+}>;
+export type ColumnType = z.infer<typeof ColumnType>;
+/**
+ * A SAFE SQL/TS IDENTIFIER for a store name / column name / FK column-or-reference (TEN-1).
+ * Store/column names are interpolated VERBATIM into generated SQL (`CREATE TABLE "<name>"`)
+ * AND generated TS (`export const <camel> = pgTable('<name>', …)`) — so an unconstrained
+ * `z.string()` is an INJECTION seam (a name like `m" ); DROP …` lands in executable DDL, and the
+ * destructive scan is a closed blocklist that can never catch every form). Fail-closed at the
+ * SOURCE: a safe identifier is `[a-z_][a-z0-9_]*`, length 1..63 (the Postgres identifier limit),
+ * lowercase only (Postgres folds unquoted idents to lowercase; we keep snake_case author names and
+ * camelCase them for TS). `parseSpec` rejects a metacharacter/over-long name as `schema_violation`.
+ * The generators re-assert the SAME shape (defense-in-depth for a code-built spec bypassing parse).
+ */
+export declare const SAFE_IDENTIFIER_RE: RegExp;
+export declare const MAX_IDENTIFIER_LENGTH = 63;
+export declare const SafeIdentifier: z.ZodString;
+/**
+ * Re-assert the safe-identifier shape OUTSIDE Zod (the generators call this on a spec that may have
+ * been built in code, bypassing parseSpec). THROWS — never returns a malformed identifier into
+ * generated SQL/TS. Single source of the rule shared by the grammar refine above + both generators.
+ */
+export declare function assertSafeIdentifier(value: string, what: string): void;
+/** One business column on a store. `nullable`/`unique` default false (the conservative shape). */
+export declare const StoreColumn: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        boolean: "boolean";
+        text: "text";
+        uuid: "uuid";
+        timestamp: "timestamp";
+        integer: "integer";
+        jsonb: "jsonb";
+    }>;
+    nullable: z.ZodDefault<z.ZodBoolean>;
+    unique: z.ZodDefault<z.ZodBoolean>;
+    enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type StoreColumn = z.infer<typeof StoreColumn>;
+/**
+ * A child→parent foreign key (the throwaway has `transcripts` referencing `meetings`). The
+ * generator emits the FK + `ON DELETE` policy; the parent must be another declared store (the
+ * lint pass resolves `references`). This is a PRODUCT-to-PRODUCT FK; FK-to-core (e.g. orgs) is
+ * the injected tenancy column, not declared here.
+ */
+export declare const StoreForeignKey: z.ZodObject<{
+    column: z.ZodString;
+    references: z.ZodString;
+    referencesColumn: z.ZodOptional<z.ZodString>;
+    onDelete: z.ZodDefault<z.ZodEnum<{
+        cascade: "cascade";
+        restrict: "restrict";
+        "set null": "set null";
+    }>>;
+}, z.core.$strict>;
+export type StoreForeignKey = z.infer<typeof StoreForeignKey>;
+/**
+ * A declared product store. Authors declare a name + business columns (+ optional child→parent
+ * FKs). Tenancy is NON-OPTIONAL by construction — there is no opt-out field (a non-tenant store
+ * would be the spec-level analogue of `.unscoped()`, deliberately not expressible in v1.0).
+ */
+export declare const StoreSpec: z.ZodObject<{
+    name: z.ZodString;
+    columns: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            boolean: "boolean";
+            text: "text";
+            uuid: "uuid";
+            timestamp: "timestamp";
+            integer: "integer";
+            jsonb: "jsonb";
+        }>;
+        nullable: z.ZodDefault<z.ZodBoolean>;
+        unique: z.ZodDefault<z.ZodBoolean>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    foreignKeys: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        column: z.ZodString;
+        references: z.ZodString;
+        referencesColumn: z.ZodOptional<z.ZodString>;
+        onDelete: z.ZodDefault<z.ZodEnum<{
+            cascade: "cascade";
+            restrict: "restrict";
+            "set null": "set null";
+        }>>;
+    }, z.core.$strict>>>;
+    softDelete: z.ZodOptional<z.ZodBoolean>;
+    fullTextSearch: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type StoreSpec = z.infer<typeof StoreSpec>;
+/**
+ * What a handler is wired into. A logical id maps to a TS module + export; `kind` declares the
+ * chokepoint it dispatches through (tool → dispatchTool; route → the api chokepoint; trigger →
+ * the triggers seam). The loader resolves the symbol from a path-jailed escape-hatch
+ * root — the grammar layer parses the mapping only.
+ */
+export declare const HandlerKind: z.ZodEnum<{
+    tool: "tool";
+    route: "route";
+    trigger: "trigger";
+}>;
+export type HandlerKind = z.infer<typeof HandlerKind>;
+export declare const HandlerSpec: z.ZodObject<{
+    id: z.ZodString;
+    module: z.ZodString;
+    export: z.ZodString;
+    kind: z.ZodEnum<{
+        tool: "tool";
+        route: "route";
+        trigger: "trigger";
+    }>;
+    readonly: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type HandlerSpec = z.infer<typeof HandlerSpec>;
+/**
+ * A declared agent. WRAPS `core.AgentSpec`:
+ *  - `.omit({ input })` — `input` is the per-request RUNTIME value, never config.
+ *  - `.omit({ tools })` — the neutral inline tool array is replaced by ID references into the
+ *    `tooling[]` section (a config agent wires tools by id; lint resolves them).
+ *  - `.extend(...)` — the wrap-layer fields the engine needs: a logical `id`, a `backend`
+ *    selection, the `tools` id-reference list, and an optional `requireNativeStructuredOutput`
+ *    flag so a capability violation (e.g. native structured output demanded on pi) is expressible
+ *    and checked at config time (lint).
+ *  - `.strict()` — fail-closed unknown-key rejection (applied last; verified to compose).
+ *
+ * Single source of truth: `name`/`instructions`/`model`/`outputSchema`/`maxTurns` come straight
+ * from the neutral type. If the neutral `AgentSpec` churns, this wrap is where the compat decision
+ * (minor vs major spec bump) is made — by design.
+ */
+export declare const AgentSpecConfig: z.ZodObject<{
+    name: z.ZodString;
+    instructions: z.ZodString;
+    model: z.ZodString;
+    outputSchema: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>>;
+    maxTurns: z.ZodDefault<z.ZodNumber>;
+    id: z.ZodString;
+    backend: z.ZodEnum<{
+        openai: "openai";
+        anthropic: "anthropic";
+        pi: "pi";
+        codex: "codex";
+    }>;
+    tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    requireNativeStructuredOutput: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type AgentSpecConfig = z.infer<typeof AgentSpecConfig>;
+/**
+ * A declared tool. WRAPS `core.ToolSpec` (name/description/parameters — the model-facing
+ * declaration) + the wrap-layer fields the resolver needs to build a `NeutralTool`:
+ *  - `id` — logical id referenced from `agents[].tools` and unique within `tooling[]`.
+ *  - `handler` — a logical handler id from the `handlers[]` section (lint-resolved).
+ *  - `idempotent` — REQUIRED, NO DEFAULT. This is the reviewed replay-safety declaration the whole
+ *    `dispatchTool` contract keys off (a `false` tool must never re-fire / return a cached output
+ *    on replay). There is no platform-side verification of this boolean — it must be an explicit,
+ *    reviewed author decision, so we give it no default.
+ *  - `timeoutMs` — bounds the handler (AbortSignal in dispatchTool).
+ *  - `outputSchema` — optional embedded JSON-Schema validating the handler output (Ajv-compiled
+ *    at load by the lint pass). `parameters` (the input schema) is inherited from `ToolSpec`.
+ */
+export declare const ToolSpecConfig: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    id: z.ZodString;
+    handler: z.ZodString;
+    idempotent: z.ZodBoolean;
+    timeoutMs: z.ZodNumber;
+    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type ToolSpecConfig = z.infer<typeof ToolSpecConfig>;
+/** The HTTP method a route handles. */
+export declare const HttpMethod: z.ZodEnum<{
+    GET: "GET";
+    POST: "POST";
+    PUT: "PUT";
+    PATCH: "PATCH";
+    DELETE: "DELETE";
+}>;
+export type HttpMethod = z.infer<typeof HttpMethod>;
+/** A CRUD operation against a materialized store. */
+export declare const StoreOp: z.ZodEnum<{
+    list: "list";
+    get: "get";
+    create: "create";
+    update: "update";
+    delete: "delete";
+}>;
+export type StoreOp = z.infer<typeof StoreOp>;
+/**
+ * A `stream` route's runtime mode — discriminates the init shape the interpreter builds WITHIN the
+ * `kind:'stream'` arm (NOT a union discriminant — the union still discriminates on `kind`):
+ *  - `ingest`   — the binary write half: the interpreter reads the RAW request body.
+ *  - `playback` — the media read half: Range/206 + conditional-GET from a `BlobStore`.
+ *
+ * `mode` is a per-arm field (like a store action's `op`), not a fourth `kind`: an ingest and a
+ * playback route are the SAME kind of action (a raw-Request/Response stream handler) differing only
+ * in runtime behavior, so one `kind` keeps the closed union minimal.
+ */
+export declare const StreamMode: z.ZodEnum<{
+    ingest: "ingest";
+    playback: "playback";
+}>;
+export type StreamMode = z.infer<typeof StreamMode>;
+/**
+ * A route action — a discriminated union over its `kind`:
+ *  - `store`   — CRUD over a materialized store via TenantDb.
+ *  - `agent`   — invoke a declared agent over the SSE/JSON run surface.
+ *  - `handler` — a declared route-handler id.
+ *  - `stream`  — a raw binary ingest / Range-206 playback handler; `mode`
+ *               discriminates ingest vs playback WITHIN this arm (the union still keys on `kind`).
+ *
+ * The discriminant `kind` is an explicit field (not inferred from which payload is set) so the union
+ * is unambiguous and fail-closed. The `stream` arm's `handler` resolves against a declared
+ * `route`-kind handler — the SAME chokepoint a `kind:'handler'` route uses (a stream handler is a
+ * route handler that receives a raw `Request` instead of parsed JSON; the raw-vs-JSON init shape is
+ * a RUNTIME concern, not a grammar-kind concern — so no new `HandlerKind` is introduced).
+ */
+export declare const RouteAction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"store">;
+    store: z.ZodString;
+    op: z.ZodEnum<{
+        list: "list";
+        get: "get";
+        create: "create";
+        update: "update";
+        delete: "delete";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"agent">;
+    agent: z.ZodString;
+    persistTo: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"handler">;
+    handler: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"stream">;
+    handler: z.ZodString;
+    mode: z.ZodEnum<{
+        ingest: "ingest";
+        playback: "playback";
+    }>;
+}, z.core.$strict>], "kind">;
+export type RouteAction = z.infer<typeof RouteAction>;
+/** A declared HTTP route mounted on the existing auth chain. */
+export declare const ApiRouteSpec: z.ZodObject<{
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+    }>;
+    path: z.ZodString;
+    action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"store">;
+        store: z.ZodString;
+        op: z.ZodEnum<{
+            list: "list";
+            get: "get";
+            create: "create";
+            update: "update";
+            delete: "delete";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"agent">;
+        agent: z.ZodString;
+        persistTo: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"handler">;
+        handler: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"stream">;
+        handler: z.ZodString;
+        mode: z.ZodEnum<{
+            ingest: "ingest";
+            playback: "playback";
+        }>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type ApiRouteSpec = z.infer<typeof ApiRouteSpec>;
+/**
+ * A trigger action — what fires when the trigger runs. A trigger fires an agent or a declared
+ * trigger-handler (lint-resolved). Parse/register only (the durable worker is a deployment
+ * property); a cron/async fire is fail-closed-rejected at runtime (not in this grammar).
+ */
+export declare const TriggerAction: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"agent">;
+    agent: z.ZodString;
+    persistTo: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"handler">;
+    handler: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type TriggerAction = z.infer<typeof TriggerAction>;
+/**
+ * A declared trigger. `kind` selects the descriptor:
+ *  - `cron`    — requires `schedule` (a cron expression; not evaluated at the grammar level).
+ *  - `webhook` — an inbound webhook (path interpreted later).
+ *  - `event`   — requires `event` (a logical event name).
+ *  - `manual`  — fired by an explicit call.
+ *
+ * `schedule`/`event` are optional at the GRAMMAR level (different kinds need different fields);
+ * the lint pass enforces the kind→field requirement (cron needs schedule, event needs event) so a
+ * malformed trigger fails fail-closed rather than parsing into a half-specified descriptor.
+ */
+export declare const TriggerKind: z.ZodEnum<{
+    cron: "cron";
+    webhook: "webhook";
+    event: "event";
+    manual: "manual";
+}>;
+export type TriggerKind = z.infer<typeof TriggerKind>;
+export declare const TriggerSpec: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        cron: "cron";
+        webhook: "webhook";
+        event: "event";
+        manual: "manual";
+    }>;
+    schedule: z.ZodOptional<z.ZodString>;
+    event: z.ZodOptional<z.ZodString>;
+    catchUp: z.ZodOptional<z.ZodBoolean>;
+    action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"agent">;
+        agent: z.ZodString;
+        persistTo: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"handler">;
+        handler: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export type TriggerSpec = z.infer<typeof TriggerSpec>;
+export declare const ExactVersionPin: z.ZodString;
+/**
+ * A reference to an extension pack to load. The pack carries ALL product code (its
+ * own stores/handlers/tooling/route fragments + capability impls); core validates ONLY this
+ * reference shape, never the pack's contents. `config` is an OPEN passthrough record whose CONTENTS
+ * are validated by the PACK's own Zod at load time, NEVER by core — but the ExtensionRef
+ * wrapper itself is `.strict()`, so an unknown key ON THE REF is fail-closed-rejected.
+ *
+ *  - `id`      — a logical id for the pack (unique within `extensions[]`; lint-resolvable later).
+ *  - `module`  — the pack module/directory reference (resolved + path-jailed by `loadExtensions`).
+ *  - `version` — an EXACT version pin (no range — see `ExactVersionPin`).
+ *  - `config`  — optional opaque pack-validated config (passthrough; core does not inspect it).
+ */
+export declare const ExtensionRef: z.ZodObject<{
+    id: z.ZodString;
+    module: z.ZodString;
+    version: z.ZodString;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type ExtensionRef = z.infer<typeof ExtensionRef>;
+/**
+ * One static frontend mount served alongside the backend's API. A backend may declare a list of
+ * these so a spec can ship its own web UI (built assets) next to the routes it exposes.
+ *
+ *  - `route` — the URL prefix the mount is served under (e.g. `/` or `/app`); must start with `/`.
+ *  - `dir`   — the directory of built static assets, relative to the spec file.
+ *  - `spa`   — when true, an unmatched path under `route` falls back to `index.html` (the
+ *              History-API single-page-app fallback); default false (plain static file serving).
+ *
+ * `.strict()` — fail-closed unknown-key rejection, consistent with every other grammar level.
+ */
+export declare const FrontendSpec: z.ZodObject<{
+    route: z.ZodString;
+    dir: z.ZodString;
+    spa: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type FrontendSpec = z.infer<typeof FrontendSpec>;
+/**
+ * The full RaySpec config document. `version` is `z.literal('1.0')` — but the parser checks it
+ * FIRST (two-phase, see `parse.ts`) so an unsupported major yields a clean `unsupported_version`
+ * SpecError instead of a wall of strict-shape errors. `.strict()` at the top level rejects any
+ * unknown top-level section.
+ *
+ * Every section defaults to `[]` so a minimal spec (just `version` + `metadata`) is valid.
+ */
+export declare const RaySpec: z.ZodObject<{
+    version: z.ZodLiteral<"1.0">;
+    metadata: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    stores: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        columns: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                boolean: "boolean";
+                text: "text";
+                uuid: "uuid";
+                timestamp: "timestamp";
+                integer: "integer";
+                jsonb: "jsonb";
+            }>;
+            nullable: z.ZodDefault<z.ZodBoolean>;
+            unique: z.ZodDefault<z.ZodBoolean>;
+            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        foreignKeys: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            references: z.ZodString;
+            referencesColumn: z.ZodOptional<z.ZodString>;
+            onDelete: z.ZodDefault<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "set null": "set null";
+            }>>;
+        }, z.core.$strict>>>;
+        softDelete: z.ZodOptional<z.ZodBoolean>;
+        fullTextSearch: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    api: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>;
+        path: z.ZodString;
+        action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"store">;
+            store: z.ZodString;
+            op: z.ZodEnum<{
+                list: "list";
+                get: "get";
+                create: "create";
+                update: "update";
+                delete: "delete";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"agent">;
+            agent: z.ZodString;
+            persistTo: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"handler">;
+            handler: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"stream">;
+            handler: z.ZodString;
+            mode: z.ZodEnum<{
+                ingest: "ingest";
+                playback: "playback";
+            }>;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>>;
+    agents: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        instructions: z.ZodString;
+        model: z.ZodString;
+        outputSchema: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>>;
+        maxTurns: z.ZodDefault<z.ZodNumber>;
+        id: z.ZodString;
+        backend: z.ZodEnum<{
+            openai: "openai";
+            anthropic: "anthropic";
+            pi: "pi";
+            codex: "codex";
+        }>;
+        tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        requireNativeStructuredOutput: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    tooling: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        id: z.ZodString;
+        handler: z.ZodString;
+        idempotent: z.ZodBoolean;
+        timeoutMs: z.ZodNumber;
+        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    triggers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            cron: "cron";
+            webhook: "webhook";
+            event: "event";
+            manual: "manual";
+        }>;
+        schedule: z.ZodOptional<z.ZodString>;
+        event: z.ZodOptional<z.ZodString>;
+        catchUp: z.ZodOptional<z.ZodBoolean>;
+        action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"agent">;
+            agent: z.ZodString;
+            persistTo: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"handler">;
+            handler: z.ZodString;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>>>;
+    handlers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        module: z.ZodString;
+        export: z.ZodString;
+        kind: z.ZodEnum<{
+            tool: "tool";
+            route: "route";
+            trigger: "trigger";
+        }>;
+        readonly: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+    extensions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        module: z.ZodString;
+        version: z.ZodString;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    deployment: z.ZodOptional<z.ZodObject<{
+        durableWorker: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    frontend: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        route: z.ZodString;
+        dir: z.ZodString;
+        spa: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type RaySpec = z.infer<typeof RaySpec>;
+//# sourceMappingURL=grammar.d.ts.map

package/dist/grammar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar.d.ts","sourceRoot":"","sources":["../src/grammar.ts"],"names":[],"mappings":"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"}