@fonoster/common 0.27.0 → 0.30.0

package/dist/config/parseConfigFile.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_EXTENSIONS = void 0;
+exports.parseConfigFile = parseConfigFile;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const path_1 = require("path");
+const jsonc_parser_1 = require("jsonc-parser");
+const yaml_1 = require("yaml");
+const YAML_EXTENSIONS = [".yaml", ".yml"];
+const JSON_EXTENSIONS = [".json", ".jsonc"];
+const CONFIG_EXTENSIONS = [...YAML_EXTENSIONS, ...JSON_EXTENSIONS];
+exports.CONFIG_EXTENSIONS = CONFIG_EXTENSIONS;
+function lineAndColumn(text, offset) {
+    const before = text.slice(0, offset);
+    const line = before.split("\n").length;
+    const column = offset - before.lastIndexOf("\n");
+    return { line, column };
+}
+/**
+ * Parses a config file's text. The extension picks the format: `.yaml`/`.yml`
+ * as YAML, `.json`/`.jsonc` as JSON with comments and trailing commas.
+ */
+function parseConfigFile(path, text) {
+    var _a;
+    const extension = (0, path_1.extname)(path).toLowerCase();
+    if (YAML_EXTENSIONS.includes(extension)) {
+        return (_a = (0, yaml_1.parse)(text)) !== null && _a !== void 0 ? _a : {};
+    }
+    if (JSON_EXTENSIONS.includes(extension)) {
+        const errors = [];
+        const value = (0, jsonc_parser_1.parse)(text, errors, {
+            allowTrailingComma: true,
+            disallowComments: false
+        });
+        if (errors.length > 0) {
+            const first = errors[0];
+            const { line, column } = lineAndColumn(text, first.offset);
+            throw new Error(`${(0, jsonc_parser_1.printParseErrorCode)(first.error)} at line ${line}, column ${column}`);
+        }
+        return value !== null && value !== void 0 ? value : {};
+    }
+    throw new Error(`unsupported extension "${extension}" (use ${CONFIG_EXTENSIONS.join(", ")})`);
+}

package/dist/config/resolveConfigFile.d.ts

@@ -0,0 +1,17 @@
+declare const DEFAULT_SEARCH_DIRS: string[];
+type ResolvedConfigFile = {
+    path: string;
+    explicit: boolean;
+} | {
+    path: undefined;
+    explicit: false;
+    searched: string[];
+};
+/**
+ * Finds a service's config file. `--config <path>` wins; otherwise each search
+ * directory is tried in order for `<fileBase>` with a supported extension.
+ * Two candidates in the same directory is an error: the operator would not
+ * know which one is in effect.
+ */
+declare function resolveConfigFile(fileBase: string, argv: string[], searchDirs?: string[]): ResolvedConfigFile;
+export { resolveConfigFile, DEFAULT_SEARCH_DIRS, ResolvedConfigFile };

package/dist/config/resolveConfigFile.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SEARCH_DIRS = void 0;
+exports.resolveConfigFile = resolveConfigFile;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const parseConfigFile_1 = require("./parseConfigFile");
+// `/config` is where the bundle mounts each service's file (unify-config-placeholders).
+const DEFAULT_SEARCH_DIRS = ["/config", "/opt/fonoster", "./config"];
+exports.DEFAULT_SEARCH_DIRS = DEFAULT_SEARCH_DIRS;
+/**
+ * Finds a service's config file. `--config <path>` wins; otherwise each search
+ * directory is tried in order for `<fileBase>` with a supported extension.
+ * Two candidates in the same directory is an error: the operator would not
+ * know which one is in effect.
+ */
+function resolveConfigFile(fileBase, argv, searchDirs = DEFAULT_SEARCH_DIRS) {
+    const flagIndex = argv.indexOf("--config");
+    const fromFlag = flagIndex >= 0 ? argv[flagIndex + 1] : undefined;
+    if (fromFlag) {
+        return { path: (0, path_1.resolve)(process.cwd(), fromFlag), explicit: true };
+    }
+    const searched = [];
+    for (const dir of searchDirs) {
+        const candidates = parseConfigFile_1.CONFIG_EXTENSIONS.map((extension) => (0, path_1.resolve)(process.cwd(), (0, path_1.join)(dir, `${fileBase}${extension}`)));
+        searched.push(...candidates);
+        const found = candidates.filter((candidate) => (0, fs_1.existsSync)(candidate));
+        if (found.length > 1) {
+            throw new Error(`found more than one ${fileBase} config file (${found.join(", ")}); keep only one`);
+        }
+        if (found.length === 1) {
+            return { path: found[0], explicit: false };
+        }
+    }
+    return { path: undefined, explicit: false, searched };
+}

package/dist/config/resolveSecretRefs.d.ts

@@ -0,0 +1,35 @@
+type Env = Record<string, string | undefined>;
+/**
+ * `secret://` references in config values (add-platform, decision D8). A string value that is
+ * exactly a reference is replaced at startup by the secret it names, so YAML never holds the raw
+ * secret:
+ *
+ *   secret://env/NAME                 the environment variable NAME
+ *   secret://file/<absolute path>     a file's contents (e.g. secret://file/run/secrets/db-url)
+ *   secret://k8s/<secret>#<key>       a Kubernetes Secret mounted as a volume, read from
+ *   secret://k8s/<ns>/<secret>#<key>  <FONOSTER_SECRETS_DIR>/<secret>/<key>
+ *                                     (default /var/run/fonoster/secrets; the Helm chart mounts
+ *                                     every referenced Secret there). The namespace, when given,
+ *                                     must be the pod's (POD_NAMESPACE) if that is known.
+ *
+ * File contents lose one trailing newline. Errors name the key path and the reference, never a
+ * value. Values that only contain `secret://` somewhere else are left alone.
+ */
+export declare const SECRET_PREFIX = "secret://";
+export declare const DEFAULT_SECRETS_DIR = "/var/run/fonoster/secrets";
+export type SecretRefOptions = {
+    env?: Env;
+    /** Where Kubernetes Secrets are mounted (default FONOSTER_SECRETS_DIR or /var/run/fonoster/secrets). */
+    secretsDir?: string;
+    /** Reads a file (tests). */
+    readFile?: (path: string) => string;
+};
+export declare function isSecretRef(value: unknown): value is string;
+/** Resolves one `secret://` reference. Throws with a message that never contains the secret. */
+export declare function resolveSecretRef(ref: string, options?: SecretRefOptions): string;
+/**
+ * Returns a copy of a parsed config with every `secret://` value resolved. Errors name the key
+ * path (`providers.deepgram.credential.value: secret://env/DG: environment variable DG is not set`).
+ */
+export declare function resolveSecretRefs<T>(input: T, options?: SecretRefOptions): T;
+export {};

package/dist/config/resolveSecretRefs.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SECRETS_DIR = exports.SECRET_PREFIX = void 0;
+exports.isSecretRef = isSecretRef;
+exports.resolveSecretRef = resolveSecretRef;
+exports.resolveSecretRefs = resolveSecretRefs;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * `secret://` references in config values (add-platform, decision D8). A string value that is
+ * exactly a reference is replaced at startup by the secret it names, so YAML never holds the raw
+ * secret:
+ *
+ *   secret://env/NAME                 the environment variable NAME
+ *   secret://file/<absolute path>     a file's contents (e.g. secret://file/run/secrets/db-url)
+ *   secret://k8s/<secret>#<key>       a Kubernetes Secret mounted as a volume, read from
+ *   secret://k8s/<ns>/<secret>#<key>  <FONOSTER_SECRETS_DIR>/<secret>/<key>
+ *                                     (default /var/run/fonoster/secrets; the Helm chart mounts
+ *                                     every referenced Secret there). The namespace, when given,
+ *                                     must be the pod's (POD_NAMESPACE) if that is known.
+ *
+ * File contents lose one trailing newline. Errors name the key path and the reference, never a
+ * value. Values that only contain `secret://` somewhere else are left alone.
+ */
+exports.SECRET_PREFIX = "secret://";
+exports.DEFAULT_SECRETS_DIR = "/var/run/fonoster/secrets";
+const NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const K8S_NAME = /^[a-z0-9]([-a-z0-9.]*[a-z0-9])?$/;
+const K8S_KEY = /^[-._a-zA-Z0-9]+$/;
+function isSecretRef(value) {
+    return typeof value === "string" && value.startsWith(exports.SECRET_PREFIX);
+}
+function readSecretFile(ref, path, options) {
+    var _a;
+    const read = (_a = options.readFile) !== null && _a !== void 0 ? _a : ((p) => (0, fs_1.readFileSync)(p, { encoding: "utf8" }));
+    try {
+        return read(path).replace(/\r?\n$/, "");
+    }
+    catch (e) {
+        const code = e.code;
+        throw new Error(`${ref}: cannot read ${path}${code ? ` (${code})` : ""}`);
+    }
+}
+/** Resolves one `secret://` reference. Throws with a message that never contains the secret. */
+function resolveSecretRef(ref, options = {}) {
+    var _a, _b, _c;
+    const env = (_a = options.env) !== null && _a !== void 0 ? _a : process.env;
+    const rest = ref.slice(exports.SECRET_PREFIX.length);
+    const slash = rest.indexOf("/");
+    const kind = slash < 0 ? rest : rest.slice(0, slash);
+    const target = slash < 0 ? "" : rest.slice(slash + 1);
+    if (kind === "env") {
+        if (!NAME.test(target))
+            throw new Error(`invalid variable name in ${ref}`);
+        const value = env[target];
+        if (value === undefined || value === "")
+            throw new Error(`${ref}: environment variable ${target} is not set`);
+        return value;
+    }
+    if (kind === "file") {
+        if (!target)
+            throw new Error(`${ref}: missing file path`);
+        const path = (0, path_1.resolve)("/", target);
+        return readSecretFile(ref, path, options);
+    }
+    if (kind === "k8s") {
+        const hash = target.indexOf("#");
+        if (hash < 0)
+            throw new Error(`${ref}: missing #<key>`);
+        const parts = target.slice(0, hash).split("/");
+        const key = target.slice(hash + 1);
+        if (parts.length > 2 || !parts.every((p) => K8S_NAME.test(p)))
+            throw new Error(`${ref}: expected secret://k8s/[<namespace>/]<secret>#<key>`);
+        if (!K8S_KEY.test(key))
+            throw new Error(`${ref}: invalid key`);
+        const [namespace, name] = parts.length === 2 ? parts : [undefined, parts[0]];
+        const podNamespace = env.POD_NAMESPACE;
+        if (namespace && podNamespace && namespace !== podNamespace)
+            throw new Error(`${ref}: Secrets of namespace ${namespace} are not mounted here (${podNamespace})`);
+        const dir = (_c = (_b = options.secretsDir) !== null && _b !== void 0 ? _b : env.FONOSTER_SECRETS_DIR) !== null && _c !== void 0 ? _c : exports.DEFAULT_SECRETS_DIR;
+        const base = (0, path_1.isAbsolute)(dir) ? dir : (0, path_1.resolve)(dir);
+        return readSecretFile(ref, (0, path_1.join)(base, name, key), options);
+    }
+    throw new Error(`unsupported reference ${ref} (use secret://env/NAME, secret://file/<path> or secret://k8s/<secret>#<key>)`);
+}
+function walk(input, options, path) {
+    if (isSecretRef(input)) {
+        try {
+            return resolveSecretRef(input, options);
+        }
+        catch (e) {
+            throw new Error(`${path || "(root)"}: ${e.message}`);
+        }
+    }
+    if (Array.isArray(input))
+        return input.map((item, i) => walk(item, options, `${path}[${i}]`));
+    if (input !== null && typeof input === "object") {
+        return Object.fromEntries(Object.entries(input).map(([k, v]) => [
+            k,
+            walk(v, options, path ? `${path}.${k}` : k)
+        ]));
+    }
+    return input;
+}
+/**
+ * Returns a copy of a parsed config with every `secret://` value resolved. Errors name the key
+ * path (`providers.deepgram.credential.value: secret://env/DG: environment variable DG is not set`).
+ */
+function resolveSecretRefs(input, options = {}) {
+    return walk(input, options, "");
+}

package/dist/{assistants/audioFiltersSchema.d.ts → config/strictDeep.d.ts}

@@ -16,15 +16,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { z } from "zod";
-declare const audioFiltersSchema: z.ZodDefault<z.ZodArray<z.ZodObject<{
-    name: z.ZodString;
-    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, "strip", z.ZodTypeAny, {
-    options?: Record<string, unknown>;
-    name?: string;
-}, {
-    options?: Record<string, unknown>;
-    name?: string;
-}>, "many">>;
-export { audioFiltersSchema };
+import { ZodTypeAny } from "zod";
+/**
+ * Returns a copy of `schema` in which every object rejects unknown keys, so a
+ * misspelled config key fails validation instead of being silently dropped.
+ * Objects declared with `.passthrough()` (free-form blocks such as provider
+ * credentials) are left as they are.
+ */
+declare function strictDeep<T extends ZodTypeAny>(schema: T): T;
+export { strictDeep };

package/dist/config/strictDeep.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strictDeep = strictDeep;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const zod_1 = require("zod");
+/**
+ * Returns a copy of `schema` in which every object rejects unknown keys, so a
+ * misspelled config key fails validation instead of being silently dropped.
+ * Objects declared with `.passthrough()` (free-form blocks such as provider
+ * credentials) are left as they are.
+ */
+function strictDeep(schema) {
+    if (schema instanceof zod_1.ZodObject) {
+        const shape = schema.shape;
+        const strictShape = Object.fromEntries(Object.entries(shape).map(([key, value]) => [key, strictDeep(value)]));
+        const unknownKeys = schema._def.unknownKeys === "passthrough" ? "passthrough" : "strict";
+        return new zod_1.ZodObject(Object.assign(Object.assign({}, schema._def), { shape: () => strictShape, unknownKeys }));
+    }
+    if (schema instanceof zod_1.ZodOptional) {
+        return new zod_1.ZodOptional(Object.assign(Object.assign({}, schema._def), { innerType: strictDeep(schema._def.innerType) }));
+    }
+    if (schema instanceof zod_1.ZodNullable) {
+        return new zod_1.ZodNullable(Object.assign(Object.assign({}, schema._def), { innerType: strictDeep(schema._def.innerType) }));
+    }
+    if (schema instanceof zod_1.ZodDefault) {
+        return new zod_1.ZodDefault(Object.assign(Object.assign({}, schema._def), { innerType: strictDeep(schema._def.innerType) }));
+    }
+    if (schema instanceof zod_1.ZodArray) {
+        return new zod_1.ZodArray(Object.assign(Object.assign({}, schema._def), { type: strictDeep(schema._def.type) }));
+    }
+    if (schema instanceof zod_1.ZodEffects) {
+        return new zod_1.ZodEffects(Object.assign(Object.assign({}, schema._def), { schema: strictDeep(schema._def.schema) }));
+    }
+    if (schema instanceof zod_1.ZodUnion) {
+        return new zod_1.ZodUnion(Object.assign(Object.assign({}, schema._def), { options: schema._def.options.map((option) => strictDeep(option)) }));
+    }
+    if (schema instanceof zod_1.ZodRecord) {
+        return new zod_1.ZodRecord(Object.assign(Object.assign({}, schema._def), { valueType: strictDeep(schema._def.valueType) }));
+    }
+    return schema;
+}

package/dist/config/telemetrySchema.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from "zod";
+/**
+ * The `telemetry` section shared by every Fonoster service's config file
+ * (unify-config-placeholders): the OTLP/HTTP endpoint telemetry goes to. Empty or absent means
+ * off, unless the container environment sets `OTEL_EXPORTER_OTLP_ENDPOINT`.
+ */
+declare const telemetrySchema: z.ZodOptional<z.ZodObject<{
+    /** Usually `"${OTEL_EXPORTER_OTLP_ENDPOINT:-}"`, e.g. http://otel-collector:4318. */
+    otlpEndpoint: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    otlpEndpoint?: string;
+}, {
+    otlpEndpoint?: string;
+}>>;
+type TelemetryConfig = z.infer<typeof telemetrySchema>;
+/**
+ * The environment `initTelemetry` reads, with the config's endpoint (when set) in
+ * `OTEL_EXPORTER_OTLP_ENDPOINT`.
+ */
+declare function telemetryEnv(config: TelemetryConfig, env?: Record<string, string | undefined>): Record<string, string | undefined>;
+export { telemetrySchema, telemetryEnv, TelemetryConfig };

package/dist/config/telemetrySchema.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telemetrySchema = void 0;
+exports.telemetryEnv = telemetryEnv;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const zod_1 = require("zod");
+/**
+ * The `telemetry` section shared by every Fonoster service's config file
+ * (unify-config-placeholders): the OTLP/HTTP endpoint telemetry goes to. Empty or absent means
+ * off, unless the container environment sets `OTEL_EXPORTER_OTLP_ENDPOINT`.
+ */
+const telemetrySchema = zod_1.z
+    .object({
+    /** Usually `"${OTEL_EXPORTER_OTLP_ENDPOINT:-}"`, e.g. http://otel-collector:4318. */
+    otlpEndpoint: zod_1.z.string().optional()
+})
+    .optional();
+exports.telemetrySchema = telemetrySchema;
+/**
+ * The environment `initTelemetry` reads, with the config's endpoint (when set) in
+ * `OTEL_EXPORTER_OTLP_ENDPOINT`.
+ */
+function telemetryEnv(config, env = process.env) {
+    var _a;
+    const endpoint = (_a = config === null || config === void 0 ? void 0 : config.otlpEndpoint) === null || _a === void 0 ? void 0 : _a.trim();
+    return endpoint ? Object.assign(Object.assign({}, env), { OTEL_EXPORTER_OTLP_ENDPOINT: endpoint }) : env;
+}

package/dist/config/toJsonSchema.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { ZodTypeAny } from "zod";
+export type JsonSchema = Record<string, unknown>;
+/**
+ * The JSON Schema (draft 2020-12) of a service config schema. Unknown keys are rejected
+ * (`additionalProperties: false`) wherever the service rejects them: every object, as
+ * `strictDeep` makes them, except `.passthrough()` blocks.
+ */
+declare function toJsonSchema(schema: ZodTypeAny, options?: {
+    id?: string;
+    title?: string;
+}): JsonSchema;
+export { toJsonSchema };

package/dist/config/toJsonSchema.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toJsonSchema = toJsonSchema;
+/**
+ * Copyright (C) 2025 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const zod_1 = require("zod");
+const strictDeep_1 = require("./strictDeep");
+function stringSchema(checks) {
+    const out = { type: "string" };
+    for (const c of checks) {
+        if (c.kind === "min")
+            out.minLength = c.value;
+        else if (c.kind === "max")
+            out.maxLength = c.value;
+        else if (c.kind === "length")
+            out.minLength = out.maxLength = c.value;
+        else if (c.kind === "regex")
+            out.pattern = c.regex.source;
+        else if (c.kind === "url")
+            out.format = "uri";
+        else if (c.kind === "email")
+            out.format = "email";
+    }
+    return out;
+}
+function numberSchema(checks) {
+    const out = { type: "number" };
+    for (const c of checks) {
+        if (c.kind === "int")
+            out.type = "integer";
+        else if (c.kind === "min")
+            out[c.inclusive ? "minimum" : "exclusiveMinimum"] = c.value;
+        else if (c.kind === "max")
+            out[c.inclusive ? "maximum" : "exclusiveMaximum"] = c.value;
+        else if (c.kind === "multipleOf")
+            out.multipleOf = c.value;
+    }
+    return out;
+}
+/** Whether an object key may be left out of the input (optional, or has a default). */
+function isOptionalInput(schema) {
+    const kind = schema._def.typeName;
+    if (kind === zod_1.ZodFirstPartyTypeKind.ZodOptional ||
+        kind === zod_1.ZodFirstPartyTypeKind.ZodDefault)
+        return true;
+    if (kind === zod_1.ZodFirstPartyTypeKind.ZodEffects)
+        return isOptionalInput(schema._def.schema);
+    if (kind === zod_1.ZodFirstPartyTypeKind.ZodNullable)
+        return isOptionalInput(schema._def.innerType);
+    if (kind === zod_1.ZodFirstPartyTypeKind.ZodAny ||
+        kind === zod_1.ZodFirstPartyTypeKind.ZodUnknown)
+        return true;
+    return false;
+}
+function convert(schema, path) {
+    const def = schema._def;
+    const description = schema.description
+        ? { description: schema.description }
+        : {};
+    switch (def.typeName) {
+        case zod_1.ZodFirstPartyTypeKind.ZodString:
+            return Object.assign(Object.assign({}, stringSchema(def.checks)), description);
+        case zod_1.ZodFirstPartyTypeKind.ZodNumber:
+            return Object.assign(Object.assign({}, numberSchema(def.checks)), description);
+        case zod_1.ZodFirstPartyTypeKind.ZodBoolean:
+            return Object.assign({ type: "boolean" }, description);
+        case zod_1.ZodFirstPartyTypeKind.ZodLiteral:
+            return Object.assign({ const: def.value }, description);
+        case zod_1.ZodFirstPartyTypeKind.ZodEnum:
+            return Object.assign({ type: "string", enum: [...def.values] }, description);
+        case zod_1.ZodFirstPartyTypeKind.ZodAny:
+        case zod_1.ZodFirstPartyTypeKind.ZodUnknown:
+            return Object.assign({}, description);
+        case zod_1.ZodFirstPartyTypeKind.ZodNull:
+            return { type: "null" };
+        case zod_1.ZodFirstPartyTypeKind.ZodObject: {
+            const shape = def.shape();
+            const properties = {};
+            const required = [];
+            for (const [key, value] of Object.entries(shape)) {
+                properties[key] = convert(value, path ? `${path}.${key}` : key);
+                if (!isOptionalInput(value))
+                    required.push(key);
+            }
+            const catchall = def.catchall;
+            const hasCatchall = catchall && catchall._def.typeName !== zod_1.ZodFirstPartyTypeKind.ZodNever;
+            return Object.assign(Object.assign(Object.assign({ type: "object", properties }, (required.length ? { required } : {})), { additionalProperties: hasCatchall
+                    ? convert(catchall, `${path}.*`)
+                    : def.unknownKeys !== "strict" }), description);
+        }
+        case zod_1.ZodFirstPartyTypeKind.ZodArray: {
+            const out = Object.assign({ type: "array", items: convert(def.type, `${path}[]`) }, description);
+            if (def.minLength)
+                out.minItems = def.minLength.value;
+            if (def.maxLength)
+                out.maxItems = def.maxLength.value;
+            if (def.exactLength)
+                out.minItems = out.maxItems = def.exactLength.value;
+            return out;
+        }
+        case zod_1.ZodFirstPartyTypeKind.ZodRecord:
+            return Object.assign({ type: "object", additionalProperties: convert(def.valueType, `${path}.*`) }, description);
+        case zod_1.ZodFirstPartyTypeKind.ZodUnion:
+        case zod_1.ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
+            const options = Array.isArray(def.options)
+                ? def.options
+                : [...def.options.values()];
+            return Object.assign({ anyOf: options.map((o, i) => convert(o, `${path}|${i}`)) }, description);
+        }
+        case zod_1.ZodFirstPartyTypeKind.ZodOptional:
+            return Object.assign(Object.assign({}, convert(def.innerType, path)), description);
+        case zod_1.ZodFirstPartyTypeKind.ZodNullable:
+            return Object.assign({ anyOf: [convert(def.innerType, path), { type: "null" }] }, description);
+        case zod_1.ZodFirstPartyTypeKind.ZodDefault: {
+            const inner = convert(def.innerType, path);
+            // Object defaults such as `{}` are filled in by the inner schema; only scalars are shown.
+            const value = def.defaultValue();
+            return Object.assign(Object.assign(Object.assign({}, inner), (value === null || typeof value !== "object"
+                ? { default: value }
+                : {})), description);
+        }
+        case zod_1.ZodFirstPartyTypeKind.ZodEffects:
+            return Object.assign(Object.assign({}, convert(def.schema, path)), description);
+        case zod_1.ZodFirstPartyTypeKind.ZodBranded:
+            return convert(def.type, path);
+        case zod_1.ZodFirstPartyTypeKind.ZodCatch:
+            return convert(def.innerType, path);
+        case zod_1.ZodFirstPartyTypeKind.ZodReadonly:
+            return convert(def.innerType, path);
+        case zod_1.ZodFirstPartyTypeKind.ZodPipeline:
+            return convert(def.in, path);
+        case zod_1.ZodFirstPartyTypeKind.ZodLazy:
+            return convert(def.getter(), path);
+        default:
+            throw new Error(`toJsonSchema: unsupported Zod type ${def.typeName} at ${path || "(root)"}`);
+    }
+}
+/**
+ * The JSON Schema (draft 2020-12) of a service config schema. Unknown keys are rejected
+ * (`additionalProperties: false`) wherever the service rejects them: every object, as
+ * `strictDeep` makes them, except `.passthrough()` blocks.
+ */
+function toJsonSchema(schema, options = {}) {
+    return Object.assign(Object.assign(Object.assign({ $schema: "https://json-schema.org/draft/2020-12/schema" }, (options.id ? { $id: options.id } : {})), (options.title ? { title: options.title } : {})), convert((0, strictDeep_1.strictDeep)(schema), ""));
+}