@gobing-ai/ts-ai-decision 0.5.13

package/README.md

@@ -0,0 +1,142 @@
+# @gobing-ai/ts-ai-decision
+
+Declarative YAML **decision catalogs** over the `DecisionMaker` surface of
+`@gobing-ai/ts-ai-runner`, served through a fallback-guaranteed **`DecisionHub`** (ADR-033). A
+catalog declares named, static decision points whose shape follows TypeSafe AI's Jev question
+spec (`type` / `instructions` / `criteria`), with a required `fallback` so every decision always
+has a concrete answer.
+
+The package owns three layers: the strict catalog schema and loader (JSON Schema + zod,
+`${params.*}` template validation/rendering, load-time consistency checks), the
+`DecisionMakerRegistry` (makers picked by name), and the `DecisionHub` (one Jev question per
+`decide`, declared fallback on every backend outcome).
+
+## Catalog format
+
+```yaml
+# decisions/support.yaml
+$schema: "@gobing-ai/ts-ai-decision/schemas/decision-catalog.schema.json"
+version: 1
+decisions:
+  category:
+    type: choice
+    instructions: "Classify this ${params.channel} ticket: ${params.instructions}"
+    parameters:
+      channel: { type: enum, values: [email, chat], default: email }
+    criteria:
+      bug_report: Something is broken or producing errors
+      billing: Charges, invoices, refunds, subscriptions
+    fallback: billing
+```
+
+```ts
+import { buildState, loadDecisionCatalog, renderQuestion, resolveDecisionInput } from '@gobing-ai/ts-ai-decision';
+
+const catalog = await loadDecisionCatalog('decisions/support.yaml');
+const decision = catalog.decisions.category;
+
+const params = resolveDecisionInput(decision, { instructions: ticketText, channel: 'chat' });
+const question = renderQuestion(decision, params); // rendered Jev question
+const state = buildState(decision, params);        // declared params, minus instructions/nulls
+```
+
+Loading is YAML-only (`.yaml` / `.yml`) and reuses ts-runtime's `parseStructuredConfig`, so the
+`$schema` header is honoured when present and no YAML dependency is added here. Inconsistent
+catalogs (fallback outside the answer vocabulary, `${...}` refs to undeclared params or other
+namespaces, a declared reserved `instructions` parameter, mismatched defaults) throw
+`DecisionCatalogError { source, decisionId?, field? }`; input-contract violations throw
+`DecisionInputError { decisionId, param }`.
+
+The reserved `instructions` parameter carries caller text to the model: every decision
+implicitly has one (type `string`, default `""`), it cannot be declared under `parameters`, and
+an authored `instructions` template embeds it with `${params.instructions}` beside other
+parameters. Every string leaf of `instructions` and of the criteria descriptions is substituted
+once per `decide`; criteria labels, `fallback`, `maker` and `model` are never templated, so the
+answer vocabulary stays static. `${env.*}` and any other namespace are rejected at load.
+
+## DecisionHub
+
+`DecisionHub` loads catalogs and serves `decide(id, input)` with a guaranteed concrete answer —
+see `examples/decisions.yaml` for a complete catalog:
+
+```ts
+import { DecisionHub } from '@gobing-ai/ts-ai-decision';
+
+const hub = new DecisionHub();                 // registry with the built-ins, defaultMaker 'typesafe'
+await hub.loadFile('decisions/support.yaml');  // or hub.load(loadedCatalog)
+
+hub.list();                                    // [{ id, type, description, source }] — pure discovery
+hub.describe('category');                      // parameters (incl. instructions), criteria, fallback,
+                                               // effective minConfidence, maker and model
+const r = await hub.decide('category', { instructions: ticketText, channel: 'chat' });
+// { id, type, value, confidence, source, reason, maker, durationMs }
+const r2 = await hub.decide('category', { instructions: ticketText }, { maker: 'fm-local' });
+```
+
+`load` is all-or-nothing per catalog: a duplicate decision id across catalogs, or a `maker`
+name (decision or `defaults.maker`) that is not registered, throws `DecisionCatalogError` and
+registers nothing from the offending catalog. `list` and `describe` never construct a maker or
+driver.
+
+### The fallback contract
+
+`decide` never rejects for backend outcomes — only caller mistakes throw (`UnknownDecisionError`
+for an unknown id, `DecisionInputError` for input breaking the parameter contract,
+`UnknownDecisionMakerError` for an unregistered per-call maker; the constructor throws for an
+unregistered `defaultMaker`). Every throw happens before any backend call.
+
+Exactly one Jev question keyed by the decision id goes through a single
+`maker.ask({ state, questions, model })`; `model` resolves decision → catalog default → omitted.
+Backend outcomes map to the declared fallback with `source: 'default'`:
+
+| Outcome | `reason` |
+|---------|----------|
+| Maker construction failed (factory throw, missing config) | `no-backend` |
+| `DecisionTimeoutError` | `timeout` |
+| Any other backend failure or an invalid answer | `error` |
+| Confidence below the effective floor (`decision → defaults → 0.7`) | `low-confidence` |
+| A confident answer | `accepted` (`source: 'model'`) |
+
+Values: choice returns a string label, score the (possibly fractional) expected score, and noul
+`p >= 0.5` with `probability` and confidence `max(p, 1 - p)`. Every result names the selected
+`maker`.
+
+## Maker registry
+
+`DecisionMakerRegistry` maps plain names to `DecisionMaker`s — the three built-ins (`typesafe`,
+`fm-local`, `laya-local`) pre-registered lazily, plus anything consumers register (ADR-033):
+
+```ts
+import { createDecisionMaker } from '@gobing-ai/ts-ai-runner';
+import { DecisionMakerRegistry } from '@gobing-ai/ts-ai-decision';
+
+const registry = new DecisionMakerRegistry(); // pass `builtins: false` to start empty
+registry.register('scripted-judge', () => createDecisionMaker({ driver: myDriver }));
+
+registry.has('fm-local');                          // true — nothing was constructed yet
+const maker = await registry.resolve('fm-local');  // factory runs here, once, and is memoised
+registry.names();                                  // ['typesafe', 'fm-local', 'laya-local', 'scripted-judge']
+```
+
+Registering builds nothing; the first `resolve` runs a factory and memoises the maker, and a
+factory that throws is not memoised, so a later `resolve` retries. Invalid or duplicate names
+throw `DecisionRegistryError`; unknown names throw `UnknownDecisionMakerError { name }`; factory
+errors propagate unchanged. Pass `builtins: { makerOptions, driverOptions }` to tune the built-ins
+(env/keys/timeouts, or executor/client injection for the local drivers).
+
+The hub picks a maker purely by name — no new driver code per routing:
+per-call `options.maker` → the decision's `maker` → the catalog's `defaults.maker` → the hub's
+`defaultMaker` (default `typesafe`). Catalog names are checked at `load`; a misspelled per-call
+name fails loudly instead of falling back. `createDecisionHub` composes the whole thing in one
+call and never returns a partially built hub:
+
+```ts
+import { createDecisionHub } from '@gobing-ai/ts-ai-decision';
+
+const hub = await createDecisionHub({
+    catalogs: ['decisions/support.yaml'],
+    makers: { 'scripted-judge': () => createDecisionMaker({ driver: myDriver }) },
+});
+```
+
+See `docs/design/ai-decision-catalog.md` for the full field reference.

package/dist/catalog.d.ts

@@ -0,0 +1,16 @@
+import type { FileSystem } from '@gobing-ai/ts-runtime';
+import type { DecisionCatalog } from './types';
+/**
+ * Options for {@link loadDecisionCatalog} and {@link parseDecisionCatalog}.
+ */
+export interface CatalogLoadOptions {
+    /** Honour the top-level `$schema` when present. Default true. */
+    validateSchema?: boolean;
+    /** ts-runtime FileSystem used to read the catalog; defaults to `createNodeFileSystem()`. */
+    fileSystem?: Pick<FileSystem, 'readFile'>;
+}
+/** Load and parse a YAML catalog file, returning typed decision definitions. */
+export declare function loadDecisionCatalog(path: string, options?: CatalogLoadOptions): Promise<DecisionCatalog>;
+/** Parse a catalog string (YAML) into typed decision definitions. The source must end in .yaml/.yml. */
+export declare function parseDecisionCatalog(content: string, source: string, options?: CatalogLoadOptions): Promise<DecisionCatalog>;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAKxD,OAAO,KAAK,EAER,eAAe,EAMlB,MAAM,SAAS,CAAC;AAYjB;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B,iEAAiE;IACjE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,4FAA4F;IAC5F,UAAU,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;CAC7C;AAaD,gFAAgF;AAChF,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,eAAe,CAAC,CAalH;AAED,wGAAwG;AACxG,wBAAsB,oBAAoB,CACtC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,kBAAuB,GACjC,OAAO,CAAC,eAAe,CAAC,CA+B1B"}

package/dist/catalog.js

@@ -0,0 +1,253 @@
+import { createNodeFileSystem, parseStructuredConfig } from '@gobing-ai/ts-runtime';
+import { DecisionCatalogError } from './errors.js';
+import { DEFAULT_INSTRUCTIONS_TEMPLATE, INSTRUCTIONS_PARAM, implicitInstructionsParam } from './params.js';
+import { DecisionCatalogSchema } from './schema.js';
+/**
+ * Catalog loading (task 0089 R5/R6): a thin layer over ts-runtime's
+ * `parseStructuredConfig` (YAML parse + `$schema` validation), then the zod
+ * schema, then the cross-field checks. Validation is all-or-nothing per
+ * catalog — a catalog that fails any check produces no definitions.
+ */
+/** Same template regex as `ts-dual-workflow-engine`'s variable resolver. */
+const TEMPLATE_REF = /\$\{([^}]+)\}/g;
+const YAML_SOURCE_PATTERN = /\.(yaml|yml)$/;
+function assertYamlSource(source) {
+    if (!YAML_SOURCE_PATTERN.test(source)) {
+        throw new DecisionCatalogError(`Decision catalogs are YAML only; source "${source}" does not end in .yaml or .yml`, source);
+    }
+}
+/** Load and parse a YAML catalog file, returning typed decision definitions. */
+export async function loadDecisionCatalog(path, options = {}) {
+    assertYamlSource(path);
+    const fileSystem = options.fileSystem ?? createNodeFileSystem();
+    let content;
+    try {
+        content = await fileSystem.readFile(path);
+    }
+    catch (error) {
+        throw new DecisionCatalogError(`Cannot read decision catalog "${path}": ${error instanceof Error ? error.message : String(error)}`, path);
+    }
+    return parseDecisionCatalog(content, path, options);
+}
+/** Parse a catalog string (YAML) into typed decision definitions. The source must end in .yaml/.yml. */
+export async function parseDecisionCatalog(content, source, options = {}) {
+    assertYamlSource(source);
+    let raw;
+    try {
+        raw = await parseStructuredConfig(content, source, {
+            validateSchema: options.validateSchema ?? true,
+            fileSystem: options.fileSystem,
+        });
+    }
+    catch (error) {
+        // YAML syntax (including duplicate keys) and $schema failures are load failures:
+        // wrap so callers always see DecisionCatalogError naming the source.
+        throw new DecisionCatalogError(`Decision catalog "${source}" failed to parse or validate: ` +
+            `${error instanceof Error ? error.message : String(error)}`, source);
+    }
+    const parsed = DecisionCatalogSchema.safeParse(raw);
+    if (!parsed.success) {
+        const issue = parsed.error.issues[0];
+        const fieldPath = issue?.path.map(String).join('.') ?? '';
+        const decisionId = fieldPath.startsWith('decisions.') ? fieldPath.split('.')[1] : undefined;
+        throw new DecisionCatalogError(`Invalid decision catalog "${source}"${fieldPath ? ` at ${fieldPath}` : ''}: ${issue?.message ?? 'schema mismatch'}`, source, decisionId, fieldPath || undefined);
+    }
+    return buildCatalog(parsed.data, source);
+}
+function buildCatalog(parsed, source) {
+    const decisions = {};
+    for (const [id, raw] of Object.entries(parsed.decisions)) {
+        decisions[id] = checkDecision(id, raw, source);
+    }
+    const defaults = parsed.defaults ?? {};
+    return { source, defaults, decisions };
+}
+function catalogError(source, decisionId, field, message) {
+    return new DecisionCatalogError(`Decision "${decisionId}" in "${source}": ${message}`, source, decisionId, field);
+}
+function normalizeParam(name, rawParam) {
+    if (typeof rawParam === 'string')
+        return { name, type: rawParam, required: true };
+    const hasDefault = 'default' in rawParam;
+    return {
+        name,
+        type: rawParam.type,
+        required: !hasDefault,
+        ...(hasDefault ? { default: rawParam.default } : {}),
+        ...(rawParam.values !== undefined ? { values: rawParam.values } : {}),
+        ...(rawParam.description !== undefined ? { description: rawParam.description } : {}),
+    };
+}
+function checkParam(id, param, source) {
+    if (param.type === 'enum') {
+        if (param.values === undefined || param.values.length < 1) {
+            throw catalogError(source, id, `parameters.${param.name}.values`, 'enum parameter requires at least one value');
+        }
+    }
+    else if (param.values !== undefined) {
+        throw catalogError(source, id, `parameters.${param.name}.values`, `only enum parameters may declare values; parameter type is "${param.type}"`);
+    }
+    if (!param.required && !defaultMatches(param)) {
+        throw catalogError(source, id, `parameters.${param.name}.default`, `default ${JSON.stringify(param.default ?? null)} does not match declared type "${param.type}"` +
+            (param.values ? ` with values [${param.values.join(', ')}]` : ''));
+    }
+}
+function defaultMatches(param) {
+    const value = param.default;
+    switch (param.type) {
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number' && Number.isFinite(value);
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'enum':
+            return typeof value === 'string' && param.values?.includes(value) === true;
+        case 'json':
+            return true; // any JSON value, including null
+    }
+}
+function normalizeCriteria(id, raw, source) {
+    const criteria = raw.criteria;
+    if (raw.type === 'choice') {
+        if (criteria === undefined || Array.isArray(criteria) || typeof criteria !== 'object' || criteria === null) {
+            throw catalogError(source, id, 'criteria', 'choice decision requires a criteria label map');
+        }
+        const labels = criteria;
+        if (Object.keys(labels).length < 2) {
+            throw catalogError(source, id, 'criteria', 'choice criteria requires at least two labels');
+        }
+        return { kind: 'choice', labels };
+    }
+    if (raw.type === 'score') {
+        if (criteria === undefined) {
+            throw catalogError(source, id, 'criteria', 'score decision requires a criteria rubric list');
+        }
+        if (!Array.isArray(criteria)) {
+            throw catalogError(source, id, 'criteria', 'score criteria must be a list of level descriptions');
+        }
+        if (criteria.length < 2) {
+            throw catalogError(source, id, 'criteria', 'score criteria requires at least two levels');
+        }
+        return { kind: 'score', levels: criteria };
+    }
+    // noul: optional { true?, false? } (R4). The zod union may have matched the open
+    // record branch, so unknown outcome keys are rejected here.
+    if (criteria === undefined)
+        return { kind: 'noul' };
+    if (Array.isArray(criteria) || typeof criteria !== 'object' || criteria === null) {
+        throw catalogError(source, id, 'criteria', 'noul criteria must be an object with "true"/"false" keys');
+    }
+    for (const key of Object.keys(criteria)) {
+        if (key !== 'true' && key !== 'false') {
+            throw catalogError(source, id, 'criteria', `noul criteria accepts only the keys "true" and "false"; got "${key}"`);
+        }
+    }
+    const outcomes = criteria;
+    return {
+        kind: 'noul',
+        ...(outcomes.true !== undefined || outcomes.false !== undefined
+            ? {
+                outcomes: {
+                    ...(outcomes.true !== undefined ? { true: outcomes.true } : {}),
+                    ...(outcomes.false !== undefined ? { false: outcomes.false } : {}),
+                },
+            }
+            : {}),
+    };
+}
+function checkFallback(id, type, criteria, fallback, source) {
+    if (type === 'choice') {
+        // Own-property check: prototype keys like "constructor" must not pass as labels.
+        if (criteria.kind !== 'choice' || typeof fallback !== 'string' || !Object.hasOwn(criteria.labels, fallback)) {
+            const labels = criteria.kind === 'choice' ? Object.keys(criteria.labels).join(', ') : '';
+            throw catalogError(source, id, 'fallback', `fallback ${JSON.stringify(fallback)} is not a declared criteria label (${labels})`);
+        }
+        return;
+    }
+    if (type === 'score') {
+        const levelCount = criteria.kind === 'score' ? criteria.levels.length : 0;
+        if (criteria.kind !== 'score' ||
+            typeof fallback !== 'number' ||
+            !Number.isInteger(fallback) ||
+            fallback < 0 ||
+            fallback >= levelCount) {
+            throw catalogError(source, id, 'fallback', `fallback ${JSON.stringify(fallback)} is not an integer level in [0, ${levelCount - 1}]`);
+        }
+        return;
+    }
+    if (typeof fallback !== 'boolean') {
+        throw catalogError(source, id, 'fallback', `noul fallback must be a boolean; got ${JSON.stringify(fallback)}`);
+    }
+}
+/** Collect every `${...}` reference inside string leaves of a JSON value (recursing objects/arrays). */
+function collectTemplateRefs(value, into) {
+    if (typeof value === 'string') {
+        for (const match of value.matchAll(TEMPLATE_REF))
+            into.add(match[1] ?? '');
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectTemplateRefs(item, into);
+        return;
+    }
+    if (value !== null && typeof value === 'object') {
+        for (const entry of Object.values(value))
+            collectTemplateRefs(entry, into);
+    }
+}
+function checkTemplateRefs(id, field, entry, declared, source) {
+    const refs = new Set();
+    collectTemplateRefs(entry, refs);
+    for (const ref of refs) {
+        if (!ref.startsWith('params.')) {
+            throw catalogError(source, id, field, `template ref "\${${ref}}" uses namespace "${ref.split('.')[0] ?? ''}"; only "params" is allowed`);
+        }
+        const name = ref.slice('params.'.length);
+        if (!declared.has(name)) {
+            throw catalogError(source, id, field, `template ref "\${${ref}}" names an undeclared parameter`);
+        }
+    }
+}
+function checkDecision(id, raw, source) {
+    const parameters = {};
+    const rawParams = raw.parameters ?? {};
+    if (INSTRUCTIONS_PARAM in rawParams) {
+        throw catalogError(source, id, 'parameters.instructions', 'the "instructions" parameter is reserved and implicit (string, default ""); it cannot be declared');
+    }
+    for (const [name, rawParam] of Object.entries(rawParams)) {
+        const param = normalizeParam(name, rawParam);
+        checkParam(id, param, source);
+        parameters[name] = param;
+    }
+    parameters[INSTRUCTIONS_PARAM] = implicitInstructionsParam();
+    const criteria = normalizeCriteria(id, raw, source);
+    checkFallback(id, raw.type, criteria, raw.fallback, source);
+    const instructions = raw.instructions ?? DEFAULT_INSTRUCTIONS_TEMPLATE;
+    const declared = new Set(Object.keys(parameters));
+    checkTemplateRefs(id, 'instructions', instructions, declared, source);
+    const criteriaEntries = criteria.kind === 'choice'
+        ? Object.values(criteria.labels)
+        : criteria.kind === 'score'
+            ? [...criteria.levels]
+            : criteria.outcomes
+                ? [criteria.outcomes.true, criteria.outcomes.false].filter((e) => e !== undefined)
+                : [];
+    for (const entry of criteriaEntries) {
+        checkTemplateRefs(id, 'criteria', entry, declared, source);
+    }
+    return {
+        id,
+        source,
+        type: raw.type,
+        ...(raw.description !== undefined ? { description: raw.description } : {}),
+        instructions,
+        parameters,
+        criteria,
+        fallback: raw.fallback,
+        ...(raw.minConfidence !== undefined ? { minConfidence: raw.minConfidence } : {}),
+        ...(raw.maker !== undefined ? { maker: raw.maker } : {}),
+        ...(raw.model !== undefined ? { model: raw.model } : {}),
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,47 @@
+/**
+ * DecisionCatalogError — task 0089 — load-time failure for a decision catalog.
+ * Names the source and, when known, the decision id and field, so an
+ * inconsistent catalog points straight at the offending key.
+ */
+export declare class DecisionCatalogError extends Error {
+    readonly source: string;
+    readonly decisionId?: string | undefined;
+    readonly field?: string | undefined;
+    constructor(message: string, source: string, decisionId?: string | undefined, field?: string | undefined);
+}
+/**
+ * DecisionRegistryError — task 0091 — invalid DecisionMakerRegistry use: a name
+ * that fails `^[a-z][a-z0-9-]*$` or a duplicate registration.
+ */
+export declare class DecisionRegistryError extends Error {
+    constructor(message: string);
+}
+/**
+ * UnknownDecisionMakerError — task 0091 — resolve of a name that is not
+ * registered. The `name` property carries the unknown maker name; the class is
+ * identified via `instanceof`, because assigning `this.name` would clobber it.
+ */
+export declare class UnknownDecisionMakerError extends Error {
+    readonly name: string;
+    constructor(message: string, name: string);
+}
+/**
+ * UnknownDecisionError — task 0090 — decide/describe of a decision id that no
+ * loaded catalog declares. A caller mistake: it throws instead of falling
+ * back, before any backend call. The `decisionId` property carries the id; the
+ * class is identified via `instanceof`, like UnknownDecisionMakerError.
+ */
+export declare class UnknownDecisionError extends Error {
+    readonly decisionId: string;
+    constructor(message: string, decisionId: string);
+}
+/**
+ * DecisionInputError — task 0089 R7 — violation of one decision's parameter
+ * contract: unknown key, missing required parameter, or type mismatch.
+ */
+export declare class DecisionInputError extends Error {
+    readonly decisionId: string;
+    readonly param: string;
+    constructor(message: string, decisionId: string, param: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAGvC,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM;gBAHvB,OAAO,EAAE,MAAM,EACN,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,MAAM,YAAA,EACnB,KAAK,CAAC,EAAE,MAAM,YAAA;CAK9B;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI9B;AAED;;;;GAIG;AACH,qBAAa,yBAA0B,SAAQ,KAAK;aAG1B,IAAI,EAAE,MAAM;gBAD9B,OAAO,EAAE,MAAM,EACG,IAAI,EAAE,MAAM;CAIrC;AAED;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAGvC,QAAQ,CAAC,UAAU,EAAE,MAAM;gBAD3B,OAAO,EAAE,MAAM,EACN,UAAU,EAAE,MAAM;CAKlC;AAED;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAGrC,QAAQ,CAAC,UAAU,EAAE,MAAM;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM;gBAFtB,OAAO,EAAE,MAAM,EACN,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM;CAK7B"}

package/dist/errors.js

@@ -0,0 +1,67 @@
+/**
+ * DecisionCatalogError — task 0089 — load-time failure for a decision catalog.
+ * Names the source and, when known, the decision id and field, so an
+ * inconsistent catalog points straight at the offending key.
+ */
+export class DecisionCatalogError extends Error {
+    source;
+    decisionId;
+    field;
+    constructor(message, source, decisionId, field) {
+        super(message);
+        this.source = source;
+        this.decisionId = decisionId;
+        this.field = field;
+        this.name = 'DecisionCatalogError';
+    }
+}
+/**
+ * DecisionRegistryError — task 0091 — invalid DecisionMakerRegistry use: a name
+ * that fails `^[a-z][a-z0-9-]*$` or a duplicate registration.
+ */
+export class DecisionRegistryError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DecisionRegistryError';
+    }
+}
+/**
+ * UnknownDecisionMakerError — task 0091 — resolve of a name that is not
+ * registered. The `name` property carries the unknown maker name; the class is
+ * identified via `instanceof`, because assigning `this.name` would clobber it.
+ */
+export class UnknownDecisionMakerError extends Error {
+    name;
+    constructor(message, name) {
+        super(message);
+        this.name = name;
+    }
+}
+/**
+ * UnknownDecisionError — task 0090 — decide/describe of a decision id that no
+ * loaded catalog declares. A caller mistake: it throws instead of falling
+ * back, before any backend call. The `decisionId` property carries the id; the
+ * class is identified via `instanceof`, like UnknownDecisionMakerError.
+ */
+export class UnknownDecisionError extends Error {
+    decisionId;
+    constructor(message, decisionId) {
+        super(message);
+        this.decisionId = decisionId;
+        this.name = 'UnknownDecisionError';
+    }
+}
+/**
+ * DecisionInputError — task 0089 R7 — violation of one decision's parameter
+ * contract: unknown key, missing required parameter, or type mismatch.
+ */
+export class DecisionInputError extends Error {
+    decisionId;
+    param;
+    constructor(message, decisionId, param) {
+        super(message);
+        this.decisionId = decisionId;
+        this.param = param;
+        this.name = 'DecisionInputError';
+    }
+}