@rayspec/spec 1.5.0

package/dist/product-lint.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Product-YAML semantic validation + the fail-closed no-code guardrails.
+ *
+ * Two exported passes, both returning the FULL list of violations (never the first):
+ *
+ *  1. `scanProductGuardrails(raw)` — the NO-CODE-IN-YAML enforcement,
+ *     run on the RAW parsed object BEFORE the strict Zod parse so each ban produces a SPECIFIC,
+ *     EXPLAINING error (the draft's validation-error table) instead of a generic strict unknown-key.
+ *     It is SECTION-AWARE:
+ *       • GLOBAL (whole doc EXCEPT `contracts`): hard code/handler/SQL/shell keys + inline-code string
+ *         VALUES + provider-native WIRE-BLOB keys are banned everywhere (`no_code_in_yaml` /
+ *         `provider_native_leak`). `contracts` is EXCLUDED because there a `code`/`function` KEY is a
+ *         legitimate DATA property name, not a handler reference — contracts are vetted by the
+ *         vocabulary check in `lintProductSpec` instead.
+ *       • WORKFLOWS + EXTRACTORS subtrees ONLY: provider/model POLICY keys, provider NAMES, and prompt keys
+ *         are ALSO banned — this is the EXECUTABLE graph, which must stay provider-neutral so it compiles
+ *         through `@rayspec/product-yaml-workflow-bridge`. The key sets/regexes MIRROR that bridge's
+ *         neutrality walk exactly, so a spec that validates here feeds the bridge unchanged, AND provider
+ *         POLICY stays legal where the draft allows it (`capabilities[].provider_policy`,
+ *         `deployment_overrides`).
+ *
+ *  2. `lintProductSpec(spec)` — cross-reference resolution, duplicate-id rejection, capability-status
+ *     discipline, and the CLOSED contract vocabulary — over an already-shape-valid `ProductSpec`.
+ *
+ * NOTHING is ever silently dropped or decoratively validated (the fail-open lesson: reject loudly,
+ * never silently drop). Every mis-specified element is rejected with a closed `SpecError` code.
+ */
+import { type SpecError } from './errors.js';
+import type { ProductSpec } from './product-grammar.js';
+/**
+ * HARD code/handler keys — banned EVERYWHERE (except inside `contracts`, where a property may
+ * legitimately be named this). A key here means product-owned code/handlers/SQL/shell are being
+ * smuggled into product meaning; implementation belongs in Tier A/B.
+ */
+export declare const GLOBAL_CODE_KEYS: ReadonlySet<string>;
+/**
+ * Provider-native WIRE-BLOB keys — banned EVERYWHERE (a raw provider request/response payload is never
+ * a Product-YAML contract). DISTINCT from provider POLICY keys (`default_provider`/`default_model`/…),
+ * which are ALLOWED on a capability / in `deployment_overrides` and only banned inside workflows/extractors.
+ */
+export declare const GLOBAL_PROVIDER_BLOB_KEYS: ReadonlySet<string>;
+/**
+ * Provider/model POLICY keys — banned INSIDE `workflows`/`extractors` (the executable graph). These mirror
+ * `@rayspec/product-yaml-workflow-bridge`'s `providerNativeKeys` so the two neutrality boundaries are
+ * identical. Legal OUTSIDE the graph (capability provider_policy / deployment_overrides).
+ */
+export declare const GRAPH_PROVIDER_POLICY_KEYS: ReadonlySet<string>;
+/** Prompt keys — banned inside the graph (prompt text is a Tier-B agent-execution concern, not YAML). */
+export declare const GRAPH_PROMPT_KEYS: ReadonlySet<string>;
+/**
+ * The no-code-in-YAML guardrail scan over the RAW parsed doc. Returns SPECIFIC, explaining errors
+ * (`no_code_in_yaml` / `provider_native_leak`). Section-aware (see the module docstring).
+ */
+export declare function scanProductGuardrails(raw: unknown): SpecError[];
+/**
+ * The store checks — section-level (names, columns, keys) + step-level (target resolution, column
+ * contracts, the conflict-key law, per-type field discipline). ONE shared implementation consumed by
+ * BOTH `lintProductSpec` (doc/parse time) and `composeProductDeploy` (mount time, defense-in-depth for
+ * a code-built spec that bypassed the parser) — never two drifting copies. Returns the FULL list.
+ *
+ * `capabilityStoreNames` (OPTIONAL — CW-1): the CAPABILITY-OWNED store names of the composing
+ * runtime (e.g. the audio mount's stores). A declared store shadowing one is rejected fail-closed
+ * (capability stores are owned by their Tier-B runtime). PARSE-TIME callers pass NOTHING —
+ * @rayspec/spec cannot import runtime store names, so the doc-level lint covers COLLECTION
+ * collisions only (the documented cut); COMPOSE passes the real wired set and covers BOTH (so a
+ * code-built spec that bypassed the parser is caught at compose, BEFORE derive/rollout).
+ */
+export declare function checkProductStores(spec: ProductSpec, capabilityStoreNames?: ReadonlySet<string>): SpecError[];
+/**
+ * The full semantic pass over an already-shape-valid `ProductSpec`. Resolves every cross-reference,
+ * rejects duplicates, enforces the capability-status discipline, and vets the contract vocabulary.
+ */
+export declare function lintProductSpec(spec: ProductSpec): SpecError[];
+//# sourceMappingURL=product-lint.d.ts.map

package/dist/product-lint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"product-lint.d.ts","sourceRoot":"","sources":["../src/product-lint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,aAAa,CAAC;AAOxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAUxD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAkB/C,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,EAAE,WAAW,CAAC,MAAM,CASxD,CAAC;AASH;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,MAAM,CAYzD,CAAC;AAEH,yGAAyG;AACzG,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAKhD,CAAC;AAmEH;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,EAAE,CAyH/D;AAkMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,WAAW,EACjB,oBAAoB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GACzC,SAAS,EAAE,CAoRb;AAgCD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,EAAE,CAiZ9D"}