@skaile/forge-settings 1.4.0 → 2.0.1

package/dist/runtime/model/selector.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Small shared pieces of registry model resolution: the provider a selector
+ * names and the credential-store options a resolution carries.
+ */
+import type { CredentialStoreOptions } from "../server/credential-store.js";
+/**
+ * The provider id a `<providerId>/<modelId>` selector names: the segment before
+ * the first `/`. `undefined` for an `@role` selector or a bare model id.
+ */
+export declare function selectorProviderId(selector: string): string | undefined;
+/** The policy and local store a credential resolution uses. */
+export type CredentialAccessOptions = Pick<CredentialStoreOptions, "policy" | "path" | "key">;
+/** `env` plus whichever of `policy`, `path` and `key` are set, without `undefined` keys. */
+export declare function credentialStoreOptions(env: Record<string, string | undefined>, { policy, path, key }: CredentialAccessOptions): CredentialStoreOptions & {
+    env: Record<string, string | undefined>;
+};

package/dist/runtime/model/selector.js

@@ -0,0 +1,12 @@
+export function selectorProviderId(selector) {
+  const slash = selector.indexOf("/");
+  return !selector.startsWith("@") && slash > 0 ? selector.slice(0, slash) : void 0;
+}
+export function credentialStoreOptions(env, { policy, path, key }) {
+  return {
+    env,
+    ...policy ? { policy } : {},
+    ...path ? { path } : {},
+    ...key ? { key } : {}
+  };
+}

package/dist/runtime/server/credential-store.d.ts

@@ -24,6 +24,10 @@
  *
  * Blob format: `enc:<base64(iv[16] + tag[16] + ciphertext)>`.
  *
+ * Store path: no implicit home. The caller passes `path` or sets
+ * `FORGE_CREDENTIAL_STORE` in the environment it hands over; see
+ * {@link credentialStorePath}.
+ *
  * Key format: `FORGE_CREDENTIAL_KEY` must be a 64-char hex string (32 bytes).
  */
 import type { AIProviderEntry, AIProviderRegistryView } from "../shared/provider-registry.js";
@@ -72,7 +76,7 @@ export declare function decryptCredential(ciphertext: string, hexKey: string, re
 export interface CredentialStoreOptions {
     /** 64-char hex key; defaults to `FORGE_CREDENTIAL_KEY` of the environment. */
     key?: string;
-    /** Store file; defaults to `FORGE_CREDENTIAL_STORE` or `<skaile home>/forge-credentials.json`. */
+    /** Store file; defaults to the environment's `FORGE_CREDENTIAL_STORE`. Required for keyring operations. */
     path?: string;
     /**
      * Environment `env:` references (and the key and store path variables) read
@@ -87,11 +91,19 @@ export interface CredentialStoreOptions {
      */
     policy?: CredentialPolicy;
 }
+/** What a keyring operation throws when neither a path nor `FORGE_CREDENTIAL_STORE` names the store. */
+export declare const CREDENTIAL_STORE_PATH_REQUIRED: "FORGE_CREDENTIAL_STORE or credential store path is required";
 /**
- * Path of the local keyring file.
+ * Path of the local keyring file: `options.path`, else the selected
+ * environment's `FORGE_CREDENTIAL_STORE`.
+ *
+ * There is no implicit home: the host decides where its secrets live. A
+ * Workspaces host passes `<skaile home>/forge-credentials.json` (see
+ * `@skaile/forge-settings/workspaces`). Only keyring operations ask for the
+ * path, so env-only and keyless providers need none.
  *
- * Lives beside the user's `settings.json` so it follows `$SKAILE_HOME`, and is
- * overridable per app with `FORGE_CREDENTIAL_STORE`.
+ * @throws Error `FORGE_CREDENTIAL_STORE or credential store path is required`
+ *   when neither is given.
  */
 export declare function credentialStorePath(options?: CredentialStoreOptions): string;
 /**

package/dist/runtime/server/credential-store.js

@@ -1,14 +1,12 @@
 import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { globalSettingsPath } from "@skaile/workspaces/sdk/core";
+import { dirname } from "node:path";
 import { isEntryEnabled, parseCredentialRef, registryEntries } from "../shared/provider-registry.js";
 import {
   credentialRefRefusal,
   entryPolicyRefusal
 } from "./credential-policy.js";
 export const CREDENTIAL_PREFIX = "enc:";
-const STORE_FILENAME = "forge-credentials.json";
 const ALGORITHM = "aes-256-gcm";
 const IV_LENGTH = 16;
 const TAG_LENGTH = 16;
@@ -85,11 +83,12 @@ export function decryptCredential(ciphertext, hexKey, ref) {
 function envOf(options) {
   return options.env ?? (options.policy ? {} : process.env);
 }
+export const CREDENTIAL_STORE_PATH_REQUIRED = "FORGE_CREDENTIAL_STORE or credential store path is required";
 export function credentialStorePath(options = {}) {
   if (options.path) return options.path;
   const fromEnv = envOf(options).FORGE_CREDENTIAL_STORE;
   if (fromEnv) return fromEnv;
-  return join(dirname(globalSettingsPath()), STORE_FILENAME);
+  throw new Error(CREDENTIAL_STORE_PATH_REQUIRED);
 }
 function requireKey(options) {
   const key = options.key ?? envOf(options).FORGE_CREDENTIAL_KEY;

package/dist/runtime/server/env-layers.d.ts

@@ -13,8 +13,8 @@
  * browser-safe `utils/env-vars.ts` and is re-exported here, so client and
  * server refuse the same names from one source.
  */
-import type { AIProviderRegistryView } from "../shared/provider-registry.js";
 import { type EnvLayerId, type EnvSettingsDocument, type EnvSettingsUpdate } from "../shared/env-vars.js";
+import type { AIProviderRegistryView } from "../shared/provider-registry.js";
 export * from "../shared/env-vars.js";
 /**
  * Parse `.env` text: blank and `#` lines skipped, optional `export ` prefix,

package/dist/runtime/server/env-layers.js

@@ -1,12 +1,12 @@
 import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { AI_PROVIDER_PRESETS } from "@skaile/workspaces/sdk/bridge";
-import { isPlainObject } from "../shared/guards.js";
-import { parseCredentialRef, registryEntries } from "../shared/provider-registry.js";
+import { AI_PROVIDER_PRESETS } from "@skaile/provider-registry/catalog";
 import {
   ENV_LAYER_ORDER,
   validateEnvVarName
 } from "../shared/env-vars.js";
+import { isPlainObject } from "../shared/guards.js";
+import { parseCredentialRef, registryEntries } from "../shared/provider-registry.js";
 export * from "../shared/env-vars.js";
 const ASSIGNMENT = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_.-]*)\s*=(.*)$/;
 const NEEDS_QUOTES = /[\s#"'=\\]/;

package/dist/runtime/server/index.d.ts

@@ -1,9 +1,11 @@
 /**
- * `@skaile/forge-settings/server` — provider and settings operations for a
- * host server: the registry vocabulary and layer editing, the credential
- * store, env layers, harness settings, model discovery.
+ * `@skaile/forge-settings/server` — provider operations for a host server: the
+ * registry vocabulary and layer editing, the credential store, env layers,
+ * model discovery and voice-entry selection.
  *
- * Imports no Vue, no editor, no AI SDK and no agent session code. Storage,
+ * Imports no Vue, no editor, no AI SDK, no agent session code and no Skaile
+ * Workspaces: the Workspaces settings document, harness settings and project
+ * registry loading live in `@skaile/forge-settings/workspaces`. Storage,
  * authentication and workspace permissions stay with the host.
  */
 export * from "../shared/data-zone.js";
@@ -12,15 +14,12 @@ export * from "../shared/harnesses.js";
 export * from "../shared/model-roles.js";
 export * from "../shared/provider-accounts.js";
 export * from "../shared/provider-registry.js";
-export type { DomainConfig, SkaileSettings } from "../shared/settings-types.js";
 export * from "./credential-policy.js";
 export * from "./credential-store.js";
 export * from "./env.js";
 export * from "./env-layers.js";
-export * from "./harness-settings.js";
 export * from "./provider-discovery.js";
 export * from "./provider-layers.js";
 export * from "./provider-service.js";
-export * from "./provider-settings.js";
 export * from "./provider-write.js";
-export * from "./settings-defaults.js";
+export * from "./voice-provider.js";

package/dist/runtime/server/index.js

@@ -8,10 +8,8 @@ export * from "./credential-policy.js";
 export * from "./credential-store.js";
 export * from "./env.js";
 export * from "./env-layers.js";
-export * from "./harness-settings.js";
 export * from "./provider-discovery.js";
 export * from "./provider-layers.js";
 export * from "./provider-service.js";
-export * from "./provider-settings.js";
 export * from "./provider-write.js";
-export * from "./settings-defaults.js";
+export * from "./voice-provider.js";

package/dist/runtime/server/provider-discovery.d.ts

@@ -5,11 +5,12 @@
  * `model_map`; this module asks the provider's REST API. The two are different
  * facts and the result says which one it is:
  *
- * - `live` — the provider answered; `models` is its list.
- * - `static` — the live request failed or the entry has no key, and `models` is
- *   the offline catalog of its preset. It is a fallback, never a live answer.
- * - `unsupported` — the entry has no catalog preset, so there is nothing to ask;
- *   a host lets the admin type a model id.
+ * - `live` — the provider answered; `models` is its list (possibly empty).
+ * - `static` — the live request failed or the entry speaks no models list, and
+ *   `models` is the offline catalog of the entry's own preset. It is a
+ *   labelled fallback, never a live answer and never an inference destination.
+ * - `unsupported` — the entry speaks no models list and has no catalog; a host
+ *   lets the admin type a model id.
  * - `error` — nothing usable. The message is scrubbed.
  *
  * The error text is built here, never forwarded: a remote response body is
@@ -55,9 +56,12 @@ export interface DiscoverProviderModelsOptions {
     policy?: CredentialPolicy;
     /** Extra strings to remove from error text, besides the secrets this call resolves. */
     redact?: readonly string[];
-    /** Local encrypted store for `keyring:` references. */
-    key?: string;
+    /** Local encrypted store for `keyring:` references; else `FORGE_CREDENTIAL_STORE` of `env`. */
     path?: string;
+    /** 64-char hex key of the local store; else `FORGE_CREDENTIAL_KEY` of `env`. */
+    key?: string;
+    /** Cancels a live request; the result is then an `error` / `static` one. */
+    signal?: AbortSignal;
 }
 /**
  * Remove every occurrence of each secret (verbatim, URL-encoded and
@@ -67,7 +71,23 @@ export declare function scrubSecrets(text: string, secrets: readonly (string | u
 /**
  * Ask one registry entry's provider for its models.
  *
+ * Two ways to ask, both with the credential resolved here under the policy:
+ *
+ * - A catalog-preset entry with a resolved key and no `discovery` block of its
+ *   own uses the preset's list parser (`fetchProviderModels`), which filters
+ *   the vendor's list the way that vendor needs.
+ * - Every other entry — a custom endpoint, a keyless local server, an entry
+ *   that declares `discovery` — asks its own `base_url` with its own headers
+ *   and credential carrier (`fetchEntryModels`), exactly as inference would.
+ *   No preset and no secret are required: `credential.kind: none` queries
+ *   without `Authorization`.
+ *
+ * A successful empty list is `live` and empty. Only a preset entry has a
+ * `static` fallback: its own catalog, labelled as such, never another
+ * provider and never an inference destination.
+ *
  * Never throws for a provider-side failure: that is the `error` / `static`
- * result. A host maps `error` to its own status.
+ * result. A host maps `error` to its own status. A refused or unresolvable
+ * credential sends no request at all.
  */
 export declare function discoverProviderModels(providerId: string, registry: AIProviderRegistryView, options: DiscoverProviderModelsOptions): Promise<ModelDiscoveryResult>;

package/dist/runtime/server/provider-discovery.js

@@ -1,5 +1,10 @@
-import { resolveEntryBaseUrl } from "@skaile/workspaces/core";
-import { fetchProviderModels, getStaticModels } from "@skaile/workspaces/sdk/bridge";
+import { resolveEntryBaseUrl } from "@skaile/provider-registry";
+import { entrySurface, getStaticModels } from "@skaile/provider-registry/catalog";
+import {
+  fetchEntryModels,
+  fetchProviderModels
+} from "@skaile/provider-registry/discovery";
+import { credentialStoreOptions } from "../model/selector.js";
 import { isEntryEnabled, registryEntries } from "../shared/provider-registry.js";
 import { entryPolicyRefusal } from "./credential-policy.js";
 import { resolveEntryCredential } from "./credential-store.js";
@@ -18,6 +23,32 @@ export function scrubSecrets(text, secrets) {
   }
   return out.length > MAX_ERROR_LENGTH ? `${out.slice(0, MAX_ERROR_LENGTH)}\u2026` : out;
 }
+function entryListing(entry) {
+  const type = entry.discovery?.type;
+  if (type === "none") return { ok: false, reason: "this entry declares no model discovery" };
+  if (type === "openai-models-list" || type === "anthropic-models-list") return { ok: true };
+  if (type !== void 0) return { ok: false, reason: `discovery type '${type}' is not supported` };
+  const surface = entrySurface(entry);
+  if (surface === "openai-completions" || surface === "openai-responses" || surface === "anthropic-messages") {
+    return { ok: true };
+  }
+  return { ok: false, reason: `surface '${surface ?? "unknown"}' has no models list` };
+}
+const CANCELLED = {
+  ok: false,
+  models: [],
+  error: "models list request was cancelled",
+  source: "api"
+};
+function untilAborted(start, signal) {
+  if (!signal) return start();
+  if (signal.aborted) return Promise.resolve(CANCELLED);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => resolve(CANCELLED);
+    signal.addEventListener("abort", onAbort, { once: true });
+    start().finally(() => signal.removeEventListener("abort", onAbort)).then(resolve, reject);
+  });
+}
 export async function discoverProviderModels(providerId, registry, options) {
   const match = registryEntries(registry).find(([id]) => id === providerId);
   if (!match)
@@ -29,43 +60,36 @@ export async function discoverProviderModels(providerId, registry, options) {
   if (!isEntryEnabled(entry)) return { status: "error", providerId, error: "entry is disabled" };
   const refusal = entryPolicyRefusal(entry, options.policy);
   if (refusal) return { status: "error", providerId, error: refusal };
-  const credential = resolveEntryCredential(entry, {
-    env: options.env,
-    ...options.policy ? { policy: options.policy } : {},
-    ...options.key ? { key: options.key } : {},
-    ...options.path ? { path: options.path } : {}
-  });
+  const credential = resolveEntryCredential(entry, credentialStoreOptions(options.env, options));
   const secrets = [credential.value, ...options.redact ?? []];
   const scrub = (text) => scrubSecrets(text, secrets);
-  if (!entry.preset) {
-    return {
-      status: "unsupported",
-      providerId,
-      reason: "this entry names no catalog preset, so its models cannot be listed; enter a model id"
-    };
-  }
   if (credential.error && !credential.value) {
     return { status: "error", providerId, error: scrub(credential.error) };
   }
-  const staticList = getStaticModels(entry.preset).map(({ id, name }) => ({ id, name }));
-  if (!credential.value) {
-    return staticList.length > 0 ? {
-      status: "static",
-      providerId,
-      models: staticList,
-      reason: "no credential to query the provider with"
-    } : {
-      status: "unsupported",
-      providerId,
-      reason: "no credential, and no offline catalog for this preset"
-    };
+  const staticList = entry.preset ? getStaticModels(entry.preset).map(({ id, name }) => ({ id, name })) : [];
+  let live;
+  if (entry.preset && !entry.discovery && credential.value) {
+    const baseUrl = resolveEntryBaseUrl(entry);
+    const apiKey = credential.value;
+    live = await untilAborted(
+      () => fetchProviderModels(entry.preset, apiKey, {
+        ...baseUrl ? { baseUrl } : {},
+        env: options.env
+      }),
+      options.signal
+    );
+  } else {
+    const listing = entryListing(entry);
+    if (!listing.ok) {
+      return staticList.length > 0 ? { status: "static", providerId, models: staticList, reason: listing.reason } : { status: "unsupported", providerId, reason: `${listing.reason}; enter a model id` };
+    }
+    live = await fetchEntryModels(entry, {
+      env: {},
+      ...credential.value !== void 0 ? { secret: credential.value } : {},
+      ...options.signal ? { signal: options.signal } : {}
+    });
   }
-  const baseUrl = resolveEntryBaseUrl(entry);
-  const live = await fetchProviderModels(entry.preset, credential.value, {
-    ...baseUrl ? { baseUrl } : {},
-    env: options.env
-  });
-  if (live.ok && live.models.length > 0) {
+  if (live.ok) {
     return {
       status: "live",
       providerId,

package/dist/runtime/server/provider-layers.d.ts

@@ -7,7 +7,7 @@
  * therefore read the raw `providers` map and write it back unchanged apart
  * from the entry being edited.
  */
-import { type AIProviderPreset } from "@skaile/workspaces/sdk/bridge";
+import { type AIProviderPreset } from "@skaile/provider-registry/catalog";
 /**
  * The file a write to the layer at `path` goes to: the `.yaml` spelling when
  * only that one exists, so an edit never shadows a hand-written document.

package/dist/runtime/server/provider-layers.js

@@ -1,11 +1,9 @@
 import { existsSync, readFileSync } from "node:fs";
-import {
-  PROVIDERS_FILENAME,
-  saveProviderRegistryFile
-} from "@skaile/workspaces/core";
-import { AI_PROVIDER_PRESETS } from "@skaile/workspaces/sdk/bridge";
+import { AI_PROVIDER_PRESETS } from "@skaile/provider-registry/catalog";
+import { saveProviderRegistryFile } from "@skaile/provider-registry/files";
 import { parse as parseYaml } from "yaml";
 import { isPlainObject } from "../shared/guards.js";
+const PROVIDERS_FILENAME = "providers.yml";
 const PROVIDERS_FILENAME_ALIAS = "providers.yaml";
 export function providerLayerDocument(path) {
   if (existsSync(path)) return path;

package/dist/runtime/server/provider-service.d.ts

@@ -18,7 +18,7 @@
  *     `model_map`/`capabilities`; harness-backed discovery is
  *     `listModelsForHarness(harnessId, registry)` in the runtime.
  */
-import type { AIProviderCapabilities, AIProviderCredentialKind, AIProviderKind, AIProviderRegistryView, AIProviderSurface, AIProviderTransport, AIProviderVoiceParams, DataZone } from "../shared/provider-registry.js";
+import type { AIProviderCapabilities, AIProviderCredentialKind, AIProviderDataZone, AIProviderKind, AIProviderRegistryView, AIProviderSurface, AIProviderTransport, AIProviderVoiceParams } from "../shared/provider-registry.js";
 import { type CredentialSource, type CredentialStoreOptions } from "./credential-store.js";
 /** One registry entry, as a settings UI needs to see it. */
 export interface ProviderInfo {
@@ -72,7 +72,7 @@ export interface ProviderInfo {
     /** Frozen by the control plane: a lower layer cannot change or disable it. */
     locked: boolean;
     /** Where the entry processes data: its `data_zone`, else its preset's, else `transfer`. */
-    dataZone: DataZone;
+    dataZone: AIProviderDataZone;
     /** The entry's `eu_processing` switch (an `eu_option` entry counts as EU only with it on). */
     euProcessing: boolean;
     /**

package/dist/runtime/server/provider-write.d.ts

@@ -22,7 +22,7 @@
  * Auth stays in the app: it builds the {@link ProviderWriteScope} (paths, env,
  * lock state), asks {@link providerScopeWritable}, and answers 403 itself.
  */
-import { type AIProviderPreset } from "@skaile/workspaces/sdk/bridge";
+import { type AIProviderPreset } from "@skaile/provider-registry/catalog";
 import type { AIProviderRegistry } from "../shared/provider-registry.js";
 import { type CredentialPolicy } from "./credential-policy.js";
 /**

package/dist/runtime/server/provider-write.js

@@ -1,15 +1,15 @@
 import {
   isSafeProviderId,
-  loadProviderRegistryFile,
   mergeRegistries,
   parseCredentialRef,
   validateMergedRegistry,
   validateRegistry
-} from "@skaile/workspaces/core";
+} from "@skaile/provider-registry";
 import {
   AI_PROVIDER_PRESETS,
   expandPreset
-} from "@skaile/workspaces/sdk/bridge";
+} from "@skaile/provider-registry/catalog";
+import { loadProviderRegistryFile } from "@skaile/provider-registry/files";
 import { isDataZone } from "../shared/data-zone.js";
 import { isPlainObject } from "../shared/guards.js";
 import { missingRequiredParams } from "../shared/provider-accounts.js";

package/dist/runtime/server/voice-provider.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Voice selection: which `kind: stt|tts` registry entry serves a request and
+ * with which parameters.
+ *
+ * `sttProvider`/`ttsProvider` are registry ids of `kind: stt|tts` entries; the
+ * endpoint and the voice parameters live on the entry, and
+ * `sttLanguage`/`ttsVoice` are per-request overrides of two of those
+ * parameters. Resolving all of that used to be three apps' worth of hardcoded
+ * endpoints and voice ids.
+ */
+import type { AIProviderRegistryView, AIProviderVoiceEntry, AIProviderVoiceKind, AIProviderVoiceParams } from "../shared/provider-registry.js";
+/**
+ * Settings fields that name a voice entry and override its parameters — the
+ * same field names as the Workspaces `settings.json` document, so a
+ * `SkaileSettings` (`@skaile/forge-settings/workspaces`) can be passed as is.
+ */
+export interface VoiceSettings {
+    /** Registry id of the `kind: stt` entry. */
+    sttProvider?: string;
+    /** Registry id of the `kind: tts` entry. */
+    ttsProvider?: string;
+    /** Overrides the stt entry's `language` parameter. */
+    sttLanguage?: string;
+    /** Overrides the tts entry's `voice_id` parameter. */
+    ttsVoice?: string;
+}
+/** The `kind: stt|tts` entry a request runs against, with its parameters resolved. */
+export interface VoiceProviderSelection {
+    /** Registry id of the entry. */
+    providerId: string;
+    entry: AIProviderVoiceEntry;
+    /** Endpoint from the entry; absent when the entry inherits its preset's default. */
+    baseUrl?: string;
+    /**
+     * The entry's `params` with overrides applied — Deepgram `{model, language}`,
+     * ElevenLabs `{voice_id, output_format}`. This is the only place a forge app
+     * should read voice defaults from.
+     */
+    params: AIProviderVoiceParams;
+    /** True when settings named no usable entry and registry order decided. */
+    fallback: boolean;
+    /** Non-fatal notes, e.g. settings naming an entry the registry does not have. */
+    warnings: string[];
+}
+/**
+ * Resolve which registry entry serves speech-to-text or text-to-speech.
+ *
+ * Selection is `settings.sttProvider`/`settings.ttsProvider`, falling back to
+ * the first enabled entry of that kind in registry order when the setting is
+ * absent or names an entry that is gone — a missing setting must not silence an
+ * app that has a perfectly good entry configured.
+ *
+ * Parameter precedence, lowest first: the entry's `params`, then the settings
+ * overrides (`sttLanguage` → `language`, `ttsVoice` → `voice_id`), then
+ * `overrides` from the request. The per-request override is the contract
+ * forge-concept already honoured and the other apps silently dropped.
+ *
+ * @returns The selection, or `undefined` when the registry has no enabled entry
+ *          of that kind.
+ */
+export declare function resolveVoiceProvider(registry: AIProviderRegistryView, kind: AIProviderVoiceKind, settings?: VoiceSettings, overrides?: AIProviderVoiceParams): VoiceProviderSelection | undefined;

package/dist/runtime/server/voice-provider.js

@@ -0,0 +1,31 @@
+import {
+  entriesOfKind,
+  selectVoiceEntryId,
+  VOICE_OVERRIDE_PARAM
+} from "../shared/provider-registry.js";
+export function resolveVoiceProvider(registry, kind, settings = {}, overrides = {}) {
+  const candidates = entriesOfKind(registry, kind);
+  if (candidates.length === 0) return void 0;
+  const warnings = [];
+  const wanted = (kind === "stt" ? settings.sttProvider : settings.ttsProvider)?.trim();
+  const ids = candidates.map(([id]) => id);
+  const providerId = selectVoiceEntryId(ids, wanted);
+  const entry = candidates[ids.indexOf(providerId)][1];
+  if (wanted && wanted !== providerId) {
+    warnings.push(
+      `settings name '${wanted}' for ${kind}, which is not an enabled ${kind} entry \u2014 using '${providerId}' instead`
+    );
+  }
+  const fallback = wanted !== providerId;
+  const settingsOverride = {};
+  const override = (kind === "stt" ? settings.sttLanguage : settings.ttsVoice)?.trim();
+  if (override) settingsOverride[VOICE_OVERRIDE_PARAM[kind]] = override;
+  return {
+    providerId,
+    entry,
+    ...entry.base_url ? { baseUrl: entry.base_url } : {},
+    params: { ...entry.params, ...settingsOverride, ...overrides },
+    fallback,
+    warnings
+  };
+}

package/dist/runtime/shared/data-zone.d.ts

@@ -2,65 +2,67 @@
  * Data zones: where a provider entry processes data, and which entries a
  * host's data-zone rule ("Where may AI process data?") keeps.
  *
- * `@skaile/workspaces` 9.1 owns this (`entryDataZone`,
- * `entryAllowedByDataZone`, `filterRegistryByDataZone` in
- * `bridge/src/provider-catalog.ts`, the `data_zone` of each catalog preset).
- * forge-settings mirrors it here so the settings panel and a host on an older
- * SDK apply the same rule in the browser and on the server. Semantics match
- * upstream exactly; {@link PRESET_DATA_ZONES} is a copy of the catalog's
- * column, and the SDK catalog is its source.
+ * `@skaile/provider-registry` owns the vocabulary (`AI_PROVIDER_DATA_ZONES`,
+ * `AI_PROVIDER_DATA_ZONE_RULES`, re-exported by `./provider-registry`) and the
+ * catalog's `data_zone` column with `entryDataZone`, `entryAllowedByDataZone`
+ * and `filterRegistryByDataZone` in its `/catalog` entry. forge-settings keeps
+ * the browser-side view here so the settings panel does not ship the catalog
+ * (and its generated model table) to the browser: the same semantics, plus
+ * labels, refusal wording and a filter that keeps a merged registry merged.
+ * {@link PRESET_DATA_ZONES} is a copy of the catalog's column; a test holds it
+ * equal to `@skaile/provider-registry/catalog`.
  *
  * Browser-safe on purpose — no `node:` imports.
  */
-import { type AIProviderRegistry, type AIProviderRegistryView, type DataZone, type DataZoneRule, type MergedAIProviderRegistry } from "./provider-registry.js";
+import { type AIProviderDataZone, type AIProviderDataZoneRule, type AIProviderRegistry, type AIProviderRegistryView, type MergedAIProviderRegistry } from "./provider-registry.js";
 /**
  * The `data_zone` of each catalog preset, by preset id. Copied from
- * `@skaile/workspaces/bridge`'s `AI_PROVIDER_PRESETS` (9.1); change it there
+ * `@skaile/provider-registry/catalog`'s `AI_PROVIDER_PRESETS`; change it there
  * first. A preset this table does not name is `transfer`.
  */
-export declare const PRESET_DATA_ZONES: Readonly<Record<string, DataZone>>;
+export declare const PRESET_DATA_ZONES: Readonly<Record<string, AIProviderDataZone>>;
 /** What a provider row's zone chip says. */
-export declare const DATA_ZONE_LABELS: Readonly<Record<DataZone, string>>;
+export declare const DATA_ZONE_LABELS: Readonly<Record<AIProviderDataZone, string>>;
 /** What a host calls each rule when it names the rule that keeps an entry out. */
-export declare const DATA_ZONE_RULE_LABELS: Readonly<Record<DataZoneRule, string>>;
-/** Whether `value` is one of {@link DATA_ZONES}. */
-export declare function isDataZone(value: unknown): value is DataZone;
-/** Whether `value` is one of {@link DATA_ZONE_RULES}. */
-export declare function isDataZoneRule(value: unknown): value is DataZoneRule;
+export declare const DATA_ZONE_RULE_LABELS: Readonly<Record<AIProviderDataZoneRule, string>>;
+/** Whether `value` is one of `AI_PROVIDER_DATA_ZONES`. */
+export declare function isDataZone(value: unknown): value is AIProviderDataZone;
+/** Whether `value` is one of `AI_PROVIDER_DATA_ZONE_RULES`. */
+export declare function isDataZoneRule(value: unknown): value is AIProviderDataZoneRule;
 /** The zone of catalog preset `presetId`, or `undefined` for an id the catalog does not name. */
-export declare function presetDataZone(presetId: string | undefined): DataZone | undefined;
+export declare function presetDataZone(presetId: string | undefined): AIProviderDataZone | undefined;
 /**
  * Where an entry processes data: its own `data_zone`, else the zone of the
  * catalog preset it names, else `transfer` (an unknown endpoint is assumed to
  * leave the EU).
  */
 export declare function entryDataZone(entry: {
-    data_zone?: DataZone;
+    data_zone?: AIProviderDataZone;
     preset?: string;
-}): DataZone;
+}): AIProviderDataZone;
 /**
  * Whether `rule` allows an entry in `zone`: `any` allows all; `eu` allows
  * `eu` and `local`; `eu_options` additionally allows `eu_option` when
  * `euProcessing` is `true`.
  */
-export declare function dataZoneAllows(rule: DataZoneRule, zone: DataZone, euProcessing: boolean | undefined): boolean;
+export declare function dataZoneAllows(rule: AIProviderDataZoneRule, zone: AIProviderDataZone, euProcessing: boolean | undefined): boolean;
 /** Whether `rule` allows `entry` ({@link dataZoneAllows} over {@link entryDataZone}). */
 export declare function entryAllowedByDataZone(entry: {
-    data_zone?: DataZone;
+    data_zone?: AIProviderDataZone;
     preset?: string;
     eu_processing?: boolean;
-}, rule: DataZoneRule): boolean;
+}, rule: AIProviderDataZoneRule): boolean;
 /**
  * Why `rule` keeps an entry in `zone` out, naming the rule, or `undefined`
  * when the rule allows it. Secret-free, safe to render.
  */
-export declare function dataZoneRefusal(rule: DataZoneRule, zone: DataZone, euProcessing: boolean | undefined): string | undefined;
+export declare function dataZoneRefusal(rule: AIProviderDataZoneRule, zone: AIProviderDataZone, euProcessing: boolean | undefined): string | undefined;
 /**
  * The registry with only the entries `rule` allows, every kind alike
  * (`llm`, `embed`, `stt`, `tts`). Order is kept; the input is not mutated. A
  * merged registry comes back merged, its `order`, `origin` and `locked`
  * narrowed to the kept entries.
  */
-export declare function filterRegistryByDataZone(registry: AIProviderRegistry, rule: DataZoneRule): AIProviderRegistry;
-export declare function filterRegistryByDataZone(registry: MergedAIProviderRegistry, rule: DataZoneRule): MergedAIProviderRegistry;
-export declare function filterRegistryByDataZone(registry: AIProviderRegistryView, rule: DataZoneRule): AIProviderRegistryView;
+export declare function filterRegistryByDataZone(registry: AIProviderRegistry, rule: AIProviderDataZoneRule): AIProviderRegistry;
+export declare function filterRegistryByDataZone(registry: MergedAIProviderRegistry, rule: AIProviderDataZoneRule): MergedAIProviderRegistry;
+export declare function filterRegistryByDataZone(registry: AIProviderRegistryView, rule: AIProviderDataZoneRule): AIProviderRegistryView;

package/dist/runtime/shared/data-zone.js

@@ -1,6 +1,6 @@
 import {
-  DATA_ZONE_RULES,
-  DATA_ZONES,
+  AI_PROVIDER_DATA_ZONE_RULES,
+  AI_PROVIDER_DATA_ZONES,
   isMergedRegistry
 } from "./provider-registry.js";
 export const PRESET_DATA_ZONES = {
@@ -37,10 +37,10 @@ export const DATA_ZONE_RULE_LABELS = {
   eu: "EU only"
 };
 export function isDataZone(value) {
-  return typeof value === "string" && DATA_ZONES.includes(value);
+  return typeof value === "string" && AI_PROVIDER_DATA_ZONES.includes(value);
 }
 export function isDataZoneRule(value) {
-  return typeof value === "string" && DATA_ZONE_RULES.includes(value);
+  return typeof value === "string" && AI_PROVIDER_DATA_ZONE_RULES.includes(value);
 }
 export function presetDataZone(presetId) {
   return presetId !== void 0 && Object.hasOwn(PRESET_DATA_ZONES, presetId) ? PRESET_DATA_ZONES[presetId] : void 0;