@try-works/dsh-model-as-tool 0.1.2 → 0.3.6

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/stt-transcribe.js

@@ -0,0 +1,112 @@
+/**
+ * `stt.transcribe` — the canonical transcription contract (TOOL-01).
+ *
+ * This contract is model-free on purpose. Any conforming implementation binds to
+ * it, so a caller addresses `stt_transcribe` once and the host decides which
+ * model runs (BASE-02). Adding a second transcription model must not add a
+ * second tool.
+ *
+ * The semantics block is the part a schema cannot express and the part the spec
+ * insists on (DECL-01, TOOL-01): whether this transcribes or translates, what
+ * the timestamps mean, and what an empty result means.
+ *
+ * @module @try-works/tool-mode-contracts/contracts/stt-transcribe
+ */
+import { withMeta } from "../meta.js";
+/** Accepted audio container/codec combinations for the bounded decoder. */
+export const STT_ADMITTED_FORMATS = ['wav-pcm16'];
+/** The `stt.transcribe` contract at version 1.0.0. */
+export const sttTranscribe = {
+    contract: 'stt.transcribe',
+    version: '1.0.0',
+    toolName: 'stt_transcribe',
+    description: 'Transcribe a local audio recording into text with optional word timestamps. '
+        + 'Runs on device by default; the caller selects no model. Accepts 16 kHz mono PCM16 WAV '
+        + 'directly, and other encodings only through a tested decoder. Reports partial coverage '
+        + 'rather than presenting an incomplete clip as fully transcribed.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['audio'],
+        properties: {
+            audio: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['path'],
+                properties: {
+                    path: { type: 'string', minLength: 1, description: 'Absolute path to the recording.' },
+                    sampleRateHz: {
+                        type: 'integer',
+                        minimum: 8000,
+                        maximum: 48000,
+                        description: 'Declared sample rate; inspected against the file header, not trusted.',
+                    },
+                    channels: { type: 'integer', minimum: 1, maximum: 2 },
+                },
+            },
+            language: {
+                type: 'string',
+                minLength: 2,
+                description: 'Requested language as a BCP-47/ISO 639 code. An unsupported request is an error, never a silent fallback.',
+            },
+            timestamps: {
+                type: 'string',
+                enum: ['none', 'word'],
+                default: 'none',
+                description: 'Word timestamps when requested; an implementation that cannot supply them must error rather than omit them.',
+            },
+        },
+    },
+    outputSchema: withMeta({
+        text: { type: 'string' },
+        coverage: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['complete', 'transcribedSeconds'],
+            properties: {
+                complete: { type: 'boolean' },
+                transcribedSeconds: { type: 'number', minimum: 0 },
+                totalSeconds: { type: ['number', 'null'], minimum: 0 },
+                reason: { type: ['string', 'null'] },
+            },
+        },
+        words: {
+            type: ['array', 'null'],
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['text', 'start', 'end'],
+                properties: {
+                    text: { type: 'string' },
+                    start: { type: 'number', minimum: 0, description: 'Seconds from the start of the audio.' },
+                    end: { type: 'number', minimum: 0 },
+                },
+            },
+        },
+        language: { type: ['string', 'null'], description: 'The language actually recognized, when the implementation reports it.' },
+    }, ['text', 'coverage']),
+    semantics: {
+        operation: 'transcription',
+        translation: false,
+        timestampUnit: 'seconds',
+        timestampReference: 'start-of-audio',
+        emptyResultMeaning: 'valid-empty-transcript',
+        partialResultMeaning: 'coverage.complete is false; the transcript is incomplete, not wrong',
+        languageMismatch: 'error',
+        unsupportedTimestampRequest: 'error',
+    },
+    limits: {
+        maxAudioSeconds: 3600,
+        maxAudioBytes: 512 * 1024 * 1024,
+        admittedSampleRateHz: 16000,
+        admittedChannels: 1,
+    },
+    unsupported: [
+        'Encoding without a tested decoder: only wav-pcm16 is admitted directly; assume nothing from the file extension.',
+        'Translation: this contract transcribes, it does not translate.',
+        'Diarization or speaker attribution: separate capability.',
+        'Timestamps when the selected implementation cannot produce them: reported as an error.',
+        'Live/streaming audio: the input is a completed local file.',
+    ],
+};
+//# sourceMappingURL=stt-transcribe.js.map

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/text-embed.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `text.embed` — the legacy MiniLM text-embedding contract (TOOL-04, BASE-12).
+ *
+ * Model-free: any conforming implementation binds to it. This is the 384-
+ * dimensional MiniLM space, PRESERVED separately from the EmbeddingGemma 2
+ * 768-dimensional space — the two must never be mixed, and a stored 384-d
+ * index must never be quietly fed 768-wide vectors.
+ *
+ * @module @try-works/tool-mode-contracts/contracts/text-embed
+ */
+import type { ToolContract } from '../registry.ts';
+/** The `text.embed` contract at version 1.0.0. */
+export declare const textEmbed: ToolContract;
+//# sourceMappingURL=text-embed.d.ts.map

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/text-embed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-embed.d.ts","sourceRoot":"","sources":["../../src/contracts/text-embed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD,kDAAkD;AAClD,eAAO,MAAM,SAAS,EAAE,YA0DvB,CAAA"}

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/text-embed.js

@@ -0,0 +1,63 @@
+/**
+ * `text.embed` — the legacy MiniLM text-embedding contract (TOOL-04, BASE-12).
+ *
+ * Model-free: any conforming implementation binds to it. This is the 384-
+ * dimensional MiniLM space, PRESERVED separately from the EmbeddingGemma 2
+ * 768-dimensional space — the two must never be mixed, and a stored 384-d
+ * index must never be quietly fed 768-wide vectors.
+ *
+ * @module @try-works/tool-mode-contracts/contracts/text-embed
+ */
+import { withMeta } from "../meta.js";
+/** The `text.embed` contract at version 1.0.0. */
+export const textEmbed = {
+    contract: 'text.embed',
+    version: '1.0.0',
+    toolName: 'text_embed',
+    description: 'Embed a batch of texts into the legacy 384-dimensional MiniLM embedding space (mean pooling, '
+        + 'L2-normalized, input order preserved). This is a compatibility space: stored 384-d vectors and '
+        + 'indexes remain pinned to it, and switching to another model requires explicit re-embedding. '
+        + 'All values are finite; an empty or overlong batch is refused, never silently truncated.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['texts'],
+        properties: {
+            texts: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 32,
+                items: { type: 'string', minLength: 1, maxLength: 32768 },
+                description: 'The texts in the caller\'s order; that order is the embedding order (TOOL-04).',
+            },
+        },
+    },
+    outputSchema: withMeta({
+        embeddings: {
+            type: 'array',
+            items: {
+                type: 'array',
+                items: { type: 'number' },
+                description: 'One 384-dimensional L2-normalized vector per input text, in input order.',
+            },
+        },
+        dimensions: { const: 384 },
+        normalized: { const: true },
+    }, ['embeddings', 'dimensions', 'normalized']),
+    semantics: {
+        scoreKind: 'none',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: {
+        maxTexts: 32,
+        maxInputCharacters: 32768,
+        dimensions: 384,
+    },
+    unsupported: [
+        'Mixing 384-dimensional and 768-dimensional vectors in one index.',
+        'Silently truncating an overlong batch.',
+    ],
+};
+//# sourceMappingURL=text-embed.js.map

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/text-rerank.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `text.rerank` — the cross-encoder reranking contract (TOOL-05).
+ *
+ * Model-free: any conforming implementation binds to it. The scores are
+ * RANKING LOGITS from a cross-encoder — not embedding cosines, and the two
+ * score kinds are never interchangeable (the semantic_rank tool's
+ * cosine_similarity is a different quantity).
+ *
+ * @module @try-works/tool-mode-contracts/contracts/text-rerank
+ */
+import type { ToolContract } from '../registry.ts';
+/** The `text.rerank` contract at version 1.0.0. */
+export declare const textRerank: ToolContract;
+//# sourceMappingURL=text-rerank.d.ts.map

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/text-rerank.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-rerank.d.ts","sourceRoot":"","sources":["../../src/contracts/text-rerank.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD,mDAAmD;AACnD,eAAO,MAAM,UAAU,EAAE,YAuExB,CAAA"}

package/node_modules/@try-works/tool-mode-contracts/lib/contracts/text-rerank.js

@@ -0,0 +1,76 @@
+/**
+ * `text.rerank` — the cross-encoder reranking contract (TOOL-05).
+ *
+ * Model-free: any conforming implementation binds to it. The scores are
+ * RANKING LOGITS from a cross-encoder — not embedding cosines, and the two
+ * score kinds are never interchangeable (the semantic_rank tool's
+ * cosine_similarity is a different quantity).
+ *
+ * @module @try-works/tool-mode-contracts/contracts/text-rerank
+ */
+import { withMeta } from "../meta.js";
+/** The `text.rerank` contract at version 1.0.0. */
+export const textRerank = {
+    contract: 'text.rerank',
+    version: '1.0.0',
+    toolName: 'text_rerank',
+    description: 'Score query/document pairs with a cross-encoder and return the caller\'s own ids in descending '
+        + 'ranking-logit order with exact ties broken by input order. The scores are cross-encoder '
+        + 'logits (scoreKind "ranking_logit"), NOT embedding cosines: the two are not interchangeable. '
+        + 'A positive top_k within the candidate count is required when supplied.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['query', 'documents'],
+        properties: {
+            query: { type: 'string', minLength: 1, maxLength: 32768 },
+            documents: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 256,
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['id', 'text'],
+                    properties: {
+                        id: { type: 'string', minLength: 1, maxLength: 128 },
+                        text: { type: 'string', minLength: 1, maxLength: 32768 },
+                    },
+                },
+                description: 'The documents in the caller\'s order; that order breaks exact score ties (TOOL-05).',
+            },
+            top_k: { type: 'integer', minimum: 1, maximum: 256 },
+        },
+    },
+    outputSchema: withMeta({
+        results: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['id', 'score'],
+                properties: {
+                    id: { type: 'string' },
+                    score: { type: 'number' },
+                },
+            },
+        },
+        scoreKind: { const: 'ranking_logit' },
+    }, ['results', 'scoreKind']),
+    semantics: {
+        scoreKind: 'ranking-logit',
+        calibrated: false,
+        emptyInputMeaning: 'binding-error',
+        appliesTo: 'written-text-only',
+    },
+    limits: {
+        maxDocuments: 256,
+        maxInputCharacters: 32768,
+        maxTopK: 256,
+    },
+    unsupported: [
+        'Treating ranking logits as embedding cosines.',
+        'Negative or zero top_k when supplied.',
+    ],
+};
+//# sourceMappingURL=text-rerank.js.map

package/node_modules/@try-works/tool-mode-contracts/lib/dsh.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Projection of a contract into DSH's parameter DSL (DECL-01).
+ *
+ * DECL-01 requires that DSH registration, MCP projection and Code Mode types all
+ * come from one source. The contract's JSON Schema is that source; this module is
+ * the DSH-specific projection of it.
+ *
+ * It replaces the old registrar behaviour that inferred the required input from
+ * parameter ORDER (BASE-04). Requiredness now comes from the schema's `required`
+ * array, so a contract cannot silently change meaning when a property is
+ * reordered.
+ *
+ * @module @try-works/tool-mode-contracts/dsh
+ */
+import type { ToolContract } from './registry.ts';
+/** One DSH parameter property: a JSON-Schema subset plus `required`. */
+type DshProperty = Record<string, unknown> & {
+    required?: true;
+};
+/** The implicit-open-object parameter map DSH expects. */
+export type DshParameters = Record<string, DshProperty>;
+/** The result of projecting a contract into DSH's narrower DSL. */
+export interface DshProjection {
+    /** What the model-facing parameter schema advertises. */
+    readonly parameters: DshParameters;
+    /**
+     * Contract keywords the parameter schema cannot advertise, in `path.keyword`
+     * form. They remain enforced at runtime against the full contract schema.
+     */
+    readonly runtimeEnforced: readonly string[];
+}
+/** Raised when a contract uses a schema shape the DSH DSL cannot express. */
+export declare class ProjectionError extends Error {
+    readonly name = "ProjectionError";
+    readonly unsupported: readonly string[];
+    constructor(contract: string, unsupported: readonly string[]);
+}
+/**
+ * Project a contract's input schema into DSH parameters.
+ *
+ * DSH's DSL is narrower than JSON Schema — it has no `minLength`, `minimum` or
+ * `pattern` at any nesting level — so the projection is deliberately lossy in what
+ * it ADVERTISES while remaining complete in what it ENFORCES. BASE-04 forbids
+ * silently discarding a constraint, so every keyword left out is returned in
+ * {@link DshProjection.runtimeEnforced} and is checked by `assertValidInput`
+ * against the untouched contract.
+ * @param contract - the contract to project.
+ * @returns the parameter map plus the keywords enforced only at runtime.
+ */
+export declare function projectToDsh(contract: ToolContract): DshProjection;
+/**
+ * Project a contract's input schema into DSH parameters.
+ * @param contract - the contract to project.
+ * @returns the parameter map.
+ * @throws ProjectionError when the schema is internally inconsistent.
+ */
+export declare function toDshParameters(contract: ToolContract): DshParameters;
+/**
+ * Cross-field constraints the DSH parameter DSL cannot express (BASE-04).
+ *
+ * Each returns a violation message, or undefined when the arguments are
+ * acceptable. They run after schema validation, so each may assume its fields
+ * are present and correctly typed.
+ */
+export type CrossFieldRule = (args: Record<string, unknown>) => string | undefined;
+/** The cross-field rules that apply to a given contract. */
+export declare function crossFieldRules(contract: ToolContract): CrossFieldRule[];
+/**
+ * Project an arbitrary JSON Schema into the subset DSH can advertise (DECL-02).
+ *
+ * Written for the OUTPUT schema, which needs the same treatment the input schema
+ * already gets. Using the contract's raw output schema would crash registration on the
+ * first keyword the DSL cannot express — the failure that produced `runtimeEnforced` in
+ * the first place — and using an unconstrained `{type: "object", additionalProperties:
+ * true}` instead, which is what this replaced, publishes a tool whose result shape is
+ * declared to be anything at all.
+ * @param schema - the schema to project.
+ * @returns the projected schema plus the keywords left to runtime enforcement.
+ */
+export declare function projectSchemaToDsh(schema: Readonly<Record<string, unknown>>): DshProjection;
+export {};
+//# sourceMappingURL=dsh.d.ts.map

package/node_modules/@try-works/tool-mode-contracts/lib/dsh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsh.d.ts","sourceRoot":"","sources":["../src/dsh.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAEjD,wEAAwE;AACxE,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,IAAI,CAAA;CAAE,CAAA;AAEhE,0DAA0D;AAC1D,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;AAEvD,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B,yDAAyD;IACzD,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAA;IAClC;;;OAGG;IACH,QAAQ,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,CAAA;CAC5C;AAED,6EAA6E;AAC7E,qBAAa,eAAgB,SAAQ,KAAK;IACxC,SAAkB,IAAI,qBAAoB;IAC1C,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAA;gBAC3B,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,MAAM,EAAE;CAO7D;AAuHD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,YAAY,GAAG,aAAa,CAuBlE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,aAAa,CAErE;AAED;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,GAAG,SAAS,CAAA;AAElF,4DAA4D;AAC5D,wBAAgB,eAAe,CAAC,QAAQ,EAAE,YAAY,GAAG,cAAc,EAAE,CAqCxE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,aAAa,CAiB3F"}

package/node_modules/@try-works/tool-mode-contracts/lib/dsh.js

@@ -0,0 +1,274 @@
+/**
+ * Projection of a contract into DSH's parameter DSL (DECL-01).
+ *
+ * DECL-01 requires that DSH registration, MCP projection and Code Mode types all
+ * come from one source. The contract's JSON Schema is that source; this module is
+ * the DSH-specific projection of it.
+ *
+ * It replaces the old registrar behaviour that inferred the required input from
+ * parameter ORDER (BASE-04). Requiredness now comes from the schema's `required`
+ * array, so a contract cannot silently change meaning when a property is
+ * reordered.
+ *
+ * @module @try-works/tool-mode-contracts/dsh
+ */
+/** Raised when a contract uses a schema shape the DSH DSL cannot express. */
+export class ProjectionError extends Error {
+    name = 'ProjectionError';
+    unsupported;
+    constructor(contract, unsupported) {
+        super(`${contract} cannot be projected into the DSH parameter DSL: ${unsupported.join('; ')}. `
+            + 'Weakening the schema silently is not permitted (BASE-04), so the contract must be reshaped.');
+        this.unsupported = unsupported;
+    }
+}
+/**
+ * JSON-Schema keywords the DSH value-schema DSL can carry.
+ *
+ * Anything outside this set is not DISCARDED: it stays in the contract and is
+ * enforced at runtime by {@link assertValidInput}, which validates arguments
+ * against the full contract schema before the implementation runs. This module
+ * only decides what the model-facing parameter schema advertises.
+ */
+const DSH_SUPPORTED = new Set([
+    'type', 'enum', 'const', 'description', 'default', 'examples',
+    'items', 'properties', 'additionalProperties', 'required',
+]);
+/**
+ * Project one JSON-Schema node into the subset DSH can carry.
+ *
+ * Recursive because DSH validates nested object properties too, so a constraint
+ * on `audio.path` reaches the same DSL limit as one on a top-level property.
+ * @param node - the schema node to project.
+ * @param path - dotted path for reporting what was left out.
+ * @param runtimeEnforced - accumulates `path.keyword` entries.
+ * @returns the projected node.
+ */
+function projectNode(node, path, runtimeEnforced) {
+    const out = {};
+    /**
+     * Requiredness is expressed PER PROPERTY, at every nesting level.
+     *
+     * DSH's value schema DSL does not admit a `required` array anywhere — it rejected
+     * `schema.required` at the root and `items.required` inside an array — so the list is
+     * folded into `required: true` on each named property, which the DSL does understand.
+     * Doing it here rather than at the root is what makes it work at depth: an output
+     * schema's array items have required fields of their own.
+     */
+    const requiredNames = new Set(node.required ?? []);
+    for (const [keyword, value] of Object.entries(node)) {
+        if (!DSH_SUPPORTED.has(keyword)) {
+            runtimeEnforced.push(`${path}.${keyword}`);
+            continue;
+        }
+        // Handled through `properties` above; the DSL has no array form.
+        if (keyword === 'required')
+            continue;
+        if (keyword === 'properties' && typeof value === 'object' && value !== null) {
+            const nested = {};
+            for (const [name, child] of Object.entries(value)) {
+                const projected = typeof child === 'object' && child !== null
+                    ? projectNode(child, `${path}.${name}`, runtimeEnforced)
+                    : child;
+                nested[name] = requiredNames.has(name) && typeof projected === 'object' && projected !== null
+                    ? { ...projected, required: true }
+                    : projected;
+            }
+            out[keyword] = nested;
+        }
+        else if (keyword === 'items' && typeof value === 'object' && value !== null) {
+            out[keyword] = projectNode(value, `${path}[]`, runtimeEnforced);
+        }
+        else if (keyword === 'type' && Array.isArray(value)) {
+            /**
+             * A union `type` array is advertised as `type: 'json'` (unconstrained), NOT
+             * narrowed to one member.
+             *
+             * An earlier version advertised the concrete non-null member, which made the
+             * advertised schema STRICTER than the contract: `{ type: ['string','null'] }`
+             * was projected to `type: 'string'`, and the registry VALIDATES success values
+             * against the advertised schema, so a legitimate null result was rejected.
+             * Dropping the type entirely also fails: the DSL requires every property to
+             * have a type or oneOf. `type: 'json'` is the loosest the DSL accepts, it is
+             * strictly looser than any union, and the runtime contract check still enforces
+             * the union itself.
+             */
+            runtimeEnforced.push(`${path}.type(union -> json)`);
+            out.type = 'json';
+        }
+        else {
+            out[keyword] = value;
+        }
+    }
+    /**
+     * Post-pass the DSL rejects but projectNode would otherwise emit:
+     *
+     * - `type: 'json'` cannot carry `items`/`enum`/`const` siblings, so a union-typed
+     *   array whose element schema (or scalar constraints) survived the pass is
+     *   stripped HERE, with the keyword recorded rather than silently lost.
+     * - A NON-SCALAR `enum` is dropped everywhere: the DSL requires "a non-empty array
+     *   of scalar values", and the confidence contract (DECL-04) enumerates OBJECT
+     *   members to distinguish vendor-reported from calibrated from unavailable.
+     *   Membership is still enforced at runtime against the untouched contract.
+     * - An annotation-only node (every keyword dropped to runtimeEnforced) has no
+     *   `type`/`oneOf`, which the DSL rejects; advertising `type: 'json'` keeps it
+     *   strictly looser than the original instead of crashing registration.
+     */
+    if (out.type === undefined && out.oneOf === undefined) {
+        runtimeEnforced.push(`${path}.type(annotation-only -> json)`);
+        out.type = 'json';
+    }
+    if (out.type === 'json') {
+        for (const sibling of ['items', 'enum', 'const']) {
+            if (sibling in out) {
+                runtimeEnforced.push(`${path}.${sibling}`);
+                delete out[sibling];
+            }
+        }
+    }
+    if (out.type !== 'json' && Array.isArray(out.enum) && !out.enum.every(member => isScalar(member))) {
+        runtimeEnforced.push(`${path}.enum`);
+        delete out.enum;
+    }
+    return out;
+}
+/** A scalar the DSL's `enum` admits. */
+function isScalar(member) {
+    return typeof member === 'string' || typeof member === 'number' || typeof member === 'boolean';
+}
+/**
+ * Project a contract's input schema into DSH parameters.
+ *
+ * DSH's DSL is narrower than JSON Schema — it has no `minLength`, `minimum` or
+ * `pattern` at any nesting level — so the projection is deliberately lossy in what
+ * it ADVERTISES while remaining complete in what it ENFORCES. BASE-04 forbids
+ * silently discarding a constraint, so every keyword left out is returned in
+ * {@link DshProjection.runtimeEnforced} and is checked by `assertValidInput`
+ * against the untouched contract.
+ * @param contract - the contract to project.
+ * @returns the parameter map plus the keywords enforced only at runtime.
+ */
+export function projectToDsh(contract) {
+    const schema = contract.inputSchema;
+    const properties = schema.properties ?? {};
+    const required = new Set(schema.required ?? []);
+    const runtimeEnforced = [];
+    const out = {};
+    for (const [name, property] of Object.entries(properties)) {
+        const projected = projectNode(property, name, runtimeEnforced);
+        if (required.has(name))
+            projected.required = true;
+        out[name] = projected;
+    }
+    // A required property that is not declared cannot be satisfied by any caller.
+    const undeclared = [...required].filter(name => !(name in properties));
+    if (undeclared.length > 0) {
+        throw new ProjectionError(contract.contract, undeclared.map(name => `required property "${name}" is not declared`));
+    }
+    return { parameters: out, runtimeEnforced };
+}
+/**
+ * Project a contract's input schema into DSH parameters.
+ * @param contract - the contract to project.
+ * @returns the parameter map.
+ * @throws ProjectionError when the schema is internally inconsistent.
+ */
+export function toDshParameters(contract) {
+    return projectToDsh(contract).parameters;
+}
+/** The cross-field rules that apply to a given contract. */
+export function crossFieldRules(contract) {
+    switch (contract.contract) {
+        case 'stt.transcribe':
+            return [
+                (args) => {
+                    const timestamps = args.timestamps;
+                    if (timestamps === 'word' && args.language === undefined) {
+                        // Not a hard error, but a caller asking for word timing without
+                        // declaring a language gets worse results on code-switched audio.
+                        return undefined;
+                    }
+                    return undefined;
+                },
+                (args) => {
+                    const audio = args.audio;
+                    if (audio?.channels !== undefined && audio.channels !== 1) {
+                        return 'audio.channels must be 1: the admitted input is 16 kHz mono';
+                    }
+                    if (audio?.sampleRateHz !== undefined && audio.sampleRateHz !== 16000) {
+                        return 'audio.sampleRateHz must be 16000: resampling is not part of this contract';
+                    }
+                    return undefined;
+                },
+            ];
+        case 'text.language_detect':
+            return [
+                (args) => {
+                    const text = args.text;
+                    if (typeof text === 'string' && text.trim().length === 0) {
+                        return 'text must contain at least one non-whitespace character';
+                    }
+                    return undefined;
+                },
+            ];
+        default:
+            return [];
+    }
+}
+/**
+ * Project an arbitrary JSON Schema into the subset DSH can advertise (DECL-02).
+ *
+ * Written for the OUTPUT schema, which needs the same treatment the input schema
+ * already gets. Using the contract's raw output schema would crash registration on the
+ * first keyword the DSL cannot express — the failure that produced `runtimeEnforced` in
+ * the first place — and using an unconstrained `{type: "object", additionalProperties:
+ * true}` instead, which is what this replaced, publishes a tool whose result shape is
+ * declared to be anything at all.
+ * @param schema - the schema to project.
+ * @returns the projected schema plus the keywords left to runtime enforcement.
+ */
+export function projectSchemaToDsh(schema) {
+    const runtimeEnforced = [];
+    const projected = projectNode(schema, '', runtimeEnforced);
+    /**
+     * Nested array `items` are RETAINED, not stripped.
+     *
+     * An earlier version stripped every `items` at depth, on evidence that the registry
+     * rejected `schema.properties.words.items`. That evidence is stale against the pinned
+     * `dsh-tools@0.2.0-rc.2`, which compiles nested array items (probed: a `words` schema
+     * with a full item schema registers and validates). Stripping by key name was also a
+     * stricter-than-contract bug in waiting: a payload field legitimately NAMED `items`
+     * would lose its advertisement. Union-typed arrays (`type: ['array','null']`) become
+     * `type: 'json'` in projectNode, which already removes the `items` sibling with the
+     * keyword recorded, so nothing here needs to strip it again.
+     */
+    const parameters = stripItems(projected.properties ?? {}, '', runtimeEnforced);
+    return { parameters: parameters, runtimeEnforced };
+}
+/**
+ * Deep-clone a projected schema while preserving ARRAYS as arrays (DECL-02).
+ *
+ * The post-pass in projectNode removed every keyword the DSL rejects, so this
+ * function no longer edits keywords — it exists so no recursion turns a scalar
+ * `enum` array like ['host','device'] into a record {0:'host',1:'device'}, which
+ * is an invalid schema the registry rejects.
+ * @param node - the projected node.
+ * @param path - the path, for diagnostics.
+ * @param runtimeEnforced - collected keyword paths (unused; kept for the signature).
+ * @returns the node, arrays intact.
+ */
+function stripItems(node, path, runtimeEnforced) {
+    void path;
+    void runtimeEnforced;
+    if (typeof node !== 'object' || node === null)
+        return node;
+    if (Array.isArray(node)) {
+        return node.map((child, index) => stripItems(child, `${path}[${index}]`, runtimeEnforced));
+    }
+    const out = {};
+    for (const [key, value] of Object.entries(node)) {
+        out[key] = stripItems(value, `${path}.${key}`, runtimeEnforced);
+    }
+    return out;
+}
+//# sourceMappingURL=dsh.js.map