@dbx-tools/shared-core 0.9.40 → 0.9.43

package/README.md

@@ -22,6 +22,7 @@ import {
   log,
   net,
   object,
+  options,
   stringUtils,
 } from "@dbx-tools/shared-core";
 ```
@@ -47,6 +48,8 @@ Key features:
   grab-bag default import.
 - A Zod-backed `BrandContext` contract with dbx tools defaults, JSON Schema
   output, and prompt serialization for browser, library, and LLM consumers.
+- Shared Zod option schemas for Databricks environment names, normalized URLs,
+  TCP ports, listener addresses, and schema-driven parse/serialization.
 
 ## Brand Context
 
@@ -428,6 +431,8 @@ when disabled.
 - `http` - header iteration, cookie parsing, and fetch error creation.
 - `execution` - direct executor fallback, cancellation merging, and result unwrapping.
 - `net` - URL building, email parsing, path matching, IP/CIDR helpers.
+- `options` - Databricks environment/config schemas, ports, listener addresses,
+  URL normalization, nullable map parsing, and flag/env JSON serialization.
 - `token` - JWT payload and scope readers.
 - `functionUtils` - memoization.
 - `log` - tagged leveled logging.

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/shared-core";
-export const PACKAGE_VERSION = "0.9.40";
+export const PACKAGE_VERSION = "0.9.43";
 export * as asyncUtils from "./src/async-utils.ts";
 export * as brandUtils from "./src/brand-utils.ts";
 export * as environmentUtils from "./src/environment-utils.ts";
@@ -16,6 +16,7 @@ export * as json from "./src/json.ts";
 export * as log from "./src/log.ts";
 export * as net from "./src/net.ts";
 export * as object from "./src/object.ts";
+export * as options from "./src/options.ts";
 export * as pattern from "./src/pattern.ts";
 export * as predicate from "./src/predicate.ts";
 export * as stringUtils from "./src/string-utils.ts";
@@ -30,6 +31,8 @@ export type { HeaderLike } from "./src/http.ts";
 export type { LogLevel, Logger } from "./src/log.ts";
 export type { UrlLike, IpVersion, ParsedIp, Cidr, UrlBuilder, ParseEmailsOptions } from "./src/net.ts";
 export type { Sequence, Container, Collection, OneOrMany, NameLike, NonFunctionKeys, SerializablePrimitive, SerializableValue, ToNumberOptions, ToDateOptions, ToDurationOptions, DeepEqualComparator } from "./src/object.ts";
+export { DatabricksEnvironmentNamesSchema, databricksEnvironmentNames, MAX_TCP_PORT, tcpPortSchema, tcpPortOrZeroSchema, normalizedUrlSchema, DatabricksOptionsSchema, LakebaseOptionsSchema } from "./src/options.ts";
+export type { DatabricksEnvironmentNames, DatabricksOptions, OptionSerializationFormat, LakebaseOptions, OptionValueMap, ListenAddress, ListenAddressOptions } from "./src/options.ts";
 export type { PatternOptions } from "./src/pattern.ts";
 export type { PredicateFunction, TypePredicateFunction, PredicateInput, Predicate } from "./src/predicate.ts";
 export type { TokenizeOptions, KeyOptions, IdentifierOptions, DedentOptions, Description } from "./src/string-utils.ts";

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/shared-core";
-export declare const PACKAGE_VERSION = "0.9.40";
+export declare const PACKAGE_VERSION = "0.9.43";
 export * as asyncUtils from "./src/async-utils.ts";
 export * as brandUtils from "./src/brand-utils.ts";
 export * as environmentUtils from "./src/environment-utils.ts";
@@ -12,6 +12,7 @@ export * as json from "./src/json.ts";
 export * as log from "./src/log.ts";
 export * as net from "./src/net.ts";
 export * as object from "./src/object.ts";
+export * as options from "./src/options.ts";
 export * as pattern from "./src/pattern.ts";
 export * as predicate from "./src/predicate.ts";
 export * as stringUtils from "./src/string-utils.ts";
@@ -26,6 +27,8 @@ export type { HeaderLike } from "./src/http.ts";
 export type { LogLevel, Logger } from "./src/log.ts";
 export type { UrlLike, IpVersion, ParsedIp, Cidr, UrlBuilder, ParseEmailsOptions } from "./src/net.ts";
 export type { Sequence, Container, Collection, OneOrMany, NameLike, NonFunctionKeys, SerializablePrimitive, SerializableValue, ToNumberOptions, ToDateOptions, ToDurationOptions, DeepEqualComparator } from "./src/object.ts";
+export { DatabricksEnvironmentNamesSchema, databricksEnvironmentNames, MAX_TCP_PORT, tcpPortSchema, tcpPortOrZeroSchema, normalizedUrlSchema, DatabricksOptionsSchema, LakebaseOptionsSchema } from "./src/options.ts";
+export type { DatabricksEnvironmentNames, DatabricksOptions, OptionSerializationFormat, LakebaseOptions, OptionValueMap, ListenAddress, ListenAddressOptions } from "./src/options.ts";
 export type { PatternOptions } from "./src/pattern.ts";
 export type { PredicateFunction, TypePredicateFunction, PredicateInput, Predicate } from "./src/predicate.ts";
 export type { TokenizeOptions, KeyOptions, IdentifierOptions, DedentOptions, Description } from "./src/string-utils.ts";

package/lib/index.js

@@ -2,7 +2,7 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/shared-core";
-export const PACKAGE_VERSION = "0.9.40";
+export const PACKAGE_VERSION = "0.9.43";
 export * as asyncUtils from "./src/async-utils.js";
 export * as brandUtils from "./src/brand-utils.js";
 export * as environmentUtils from "./src/environment-utils.js";
@@ -15,10 +15,12 @@ export * as json from "./src/json.js";
 export * as log from "./src/log.js";
 export * as net from "./src/net.js";
 export * as object from "./src/object.js";
+export * as options from "./src/options.js";
 export * as pattern from "./src/pattern.js";
 export * as predicate from "./src/predicate.js";
 export * as stringUtils from "./src/string-utils.js";
 export * as token from "./src/token.js";
 export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand-utils.js";
+export { DatabricksEnvironmentNamesSchema, databricksEnvironmentNames, MAX_TCP_PORT, tcpPortSchema, tcpPortOrZeroSchema, normalizedUrlSchema, DatabricksOptionsSchema, LakebaseOptionsSchema } from "./src/options.js";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER } from "./src/token.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/environment-utils.js

@@ -1,7 +1,7 @@
 import { toBoolean } from "./object.js";
-const MAX_TCP_PORT = 65_535;
+import { MAX_TCP_PORT } from "./options.js";
 function runtimeEnvironment() {
-    return globalThis.process?.env ?? {};
+    return (globalThis.process?.env ?? {});
 }
 /** Detect a Databricks App runtime from its required name, host, and port. */
 export function isDatabricksAppEnv(source = runtimeEnvironment()) {
@@ -24,4 +24,4 @@ export function isDatabricksAppEnv(source = runtimeEnvironment()) {
         return false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/options.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Browser-safe option primitives shared across dbx-tools packages.
+ *
+ * @module
+ */
+import { z } from "zod";
+export declare const DatabricksEnvironmentNamesSchema: z.ZodObject<{
+    profile: z.ZodDefault<z.ZodLiteral<"DATABRICKS_CONFIG_PROFILE">>;
+    host: z.ZodDefault<z.ZodLiteral<"DATABRICKS_HOST">>;
+    accountId: z.ZodDefault<z.ZodLiteral<"DATABRICKS_ACCOUNT_ID">>;
+    workspaceId: z.ZodDefault<z.ZodLiteral<"DATABRICKS_WORKSPACE_ID">>;
+    configFile: z.ZodDefault<z.ZodLiteral<"DATABRICKS_CONFIG_FILE">>;
+    clientId: z.ZodDefault<z.ZodLiteral<"DATABRICKS_CLIENT_ID">>;
+    clientSecret: z.ZodDefault<z.ZodLiteral<"DATABRICKS_CLIENT_SECRET">>;
+    accessToken: z.ZodDefault<z.ZodLiteral<"DATABRICKS_TOKEN">>;
+    groupId: z.ZodDefault<z.ZodLiteral<"DATABRICKS_GROUP_ID">>;
+    authType: z.ZodDefault<z.ZodLiteral<"DATABRICKS_AUTH_TYPE">>;
+    appName: z.ZodDefault<z.ZodLiteral<"DATABRICKS_APP_NAME">>;
+    appPort: z.ZodDefault<z.ZodLiteral<"DATABRICKS_APP_PORT">>;
+    lakebaseEndpoint: z.ZodDefault<z.ZodLiteral<"LAKEBASE_ENDPOINT">>;
+}, z.core.$strict>;
+export type DatabricksEnvironmentNames = z.output<typeof DatabricksEnvironmentNamesSchema>;
+/** Canonical Databricks environment names derived from the owning schema. */
+export declare const databricksEnvironmentNames: Readonly<{
+    profile: "DATABRICKS_CONFIG_PROFILE";
+    host: "DATABRICKS_HOST";
+    accountId: "DATABRICKS_ACCOUNT_ID";
+    workspaceId: "DATABRICKS_WORKSPACE_ID";
+    configFile: "DATABRICKS_CONFIG_FILE";
+    clientId: "DATABRICKS_CLIENT_ID";
+    clientSecret: "DATABRICKS_CLIENT_SECRET";
+    accessToken: "DATABRICKS_TOKEN";
+    groupId: "DATABRICKS_GROUP_ID";
+    authType: "DATABRICKS_AUTH_TYPE";
+    appName: "DATABRICKS_APP_NAME";
+    appPort: "DATABRICKS_APP_PORT";
+    lakebaseEndpoint: "LAKEBASE_ENDPOINT";
+}>;
+/** Highest valid TCP port number. */
+export declare const MAX_TCP_PORT = 65535;
+export declare const tcpPortSchema: z.ZodCoercedNumber<number>;
+export declare const tcpPortOrZeroSchema: z.ZodCoercedNumber<number>;
+export declare const normalizedUrlSchema: z.ZodString;
+export declare const DatabricksOptionsSchema: z.ZodObject<{
+    profile: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    accountId: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    configFile: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    clientSecret: z.ZodOptional<z.ZodString>;
+    accessToken: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodString>;
+    authType: z.ZodOptional<z.ZodString>;
+    appName: z.ZodOptional<z.ZodString>;
+    appPort: z.ZodOptional<z.ZodCoercedNumber<number>>;
+    lakebaseEndpoint: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type DatabricksOptions = z.input<typeof DatabricksOptionsSchema>;
+/** Key format emitted by {@link serializeOpts}. */
+export type OptionSerializationFormat = "flag" | "env";
+/** Serialize complete parsed options as JSON keyed by flags or environment names. */
+export declare function serializeOpts<T extends z.ZodRawShape>(schema: z.ZodObject<T>, values: z.input<z.ZodObject<T>>, format: OptionSerializationFormat): string;
+export declare const LakebaseOptionsSchema: z.ZodObject<{
+    lakebaseEndpoint: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type LakebaseOptions = z.input<typeof LakebaseOptionsSchema>;
+/** Explicit option values or environment entries consumed by option parsing helpers. */
+export type OptionValueMap = Readonly<Record<string, unknown>> | null;
+/** Parse only supplied flag and environment values through an owning Zod object schema. */
+export declare function parseOpts<T extends z.ZodRawShape>(schema: z.ZodObject<T>, flags?: OptionValueMap, environment?: OptionValueMap): Partial<z.output<z.ZodObject<T>>>;
+/** Host and TCP port returned by {@link listenAddressSchema}. */
+export interface ListenAddress {
+    readonly host: string;
+    readonly port: number;
+}
+/** Defaults and validation policy for {@link listenAddressSchema}. */
+export interface ListenAddressOptions {
+    readonly port: number;
+    readonly host?: string;
+    readonly loopback?: boolean;
+}
+/** Build a listener address schema accepting a port, `:port`, `host:port`, or object. */
+export declare function listenAddressSchema(options: ListenAddressOptions): z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodObject<{
+    host: z.ZodDefault<z.ZodString>;
+    port: z.ZodDefault<z.ZodCoercedNumber<number>>;
+}, z.core.$strict>>>;
+/** Render a listener address as `host:port`, with IPv6 hosts bracketed. */
+export declare function formatListenAddress(address: ListenAddress): string;

package/lib/src/options.js

@@ -0,0 +1,262 @@
+/**
+ * Browser-safe option primitives shared across dbx-tools packages.
+ *
+ * @module
+ */
+import { z } from "zod";
+import { isLoopbackHost, urlBuilder } from "./net.js";
+import { isRecord, toBoolean } from "./object.js";
+import { parseList, toIdentifierWithOptions, toSlug } from "./string-utils.js";
+const environmentName = (name, description) => z.literal(name).default(name).describe(description);
+export const DatabricksEnvironmentNamesSchema = z
+    .object({
+    profile: environmentName("DATABRICKS_CONFIG_PROFILE", "Databricks CLI profile environment."),
+    host: environmentName("DATABRICKS_HOST", "Databricks host environment."),
+    accountId: environmentName("DATABRICKS_ACCOUNT_ID", "Databricks account ID environment."),
+    workspaceId: environmentName("DATABRICKS_WORKSPACE_ID", "Databricks workspace ID environment."),
+    configFile: environmentName("DATABRICKS_CONFIG_FILE", "Databricks CLI config file environment."),
+    clientId: environmentName("DATABRICKS_CLIENT_ID", "Databricks OAuth client ID environment."),
+    clientSecret: environmentName("DATABRICKS_CLIENT_SECRET", "Databricks OAuth client secret environment."),
+    accessToken: environmentName("DATABRICKS_TOKEN", "Databricks access token environment."),
+    groupId: environmentName("DATABRICKS_GROUP_ID", "Databricks group ID environment."),
+    authType: environmentName("DATABRICKS_AUTH_TYPE", "Databricks auth type environment."),
+    appName: environmentName("DATABRICKS_APP_NAME", "Databricks App name environment."),
+    appPort: environmentName("DATABRICKS_APP_PORT", "Databricks App port environment."),
+    lakebaseEndpoint: environmentName("LAKEBASE_ENDPOINT", "Lakebase endpoint environment."),
+})
+    .strict()
+    .describe("Canonical Databricks CLI, SDK, Apps, and Lakebase environment names.");
+/** Canonical Databricks environment names derived from the owning schema. */
+export const databricksEnvironmentNames = Object.freeze(DatabricksEnvironmentNamesSchema.parse({}));
+/** Highest valid TCP port number. */
+export const MAX_TCP_PORT = 65_535;
+export const tcpPortSchema = z.coerce
+    .number()
+    .int()
+    .min(1)
+    .max(MAX_TCP_PORT)
+    .describe("TCP port from 1 through 65535.");
+export const tcpPortOrZeroSchema = z.coerce
+    .number()
+    .int()
+    .min(0)
+    .max(MAX_TCP_PORT)
+    .describe("TCP port from 0 through 65535, where zero requests automatic allocation.");
+export const normalizedUrlSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .refine((value) => urlBuilder(value) !== undefined, {
+    message: "Expected a valid URL or host.",
+})
+    .overwrite(normalizeUrl)
+    .describe("URL normalized through the shared URL builder.");
+const databricksText = (description) => z.string().trim().min(1).optional().describe(description);
+export const DatabricksOptionsSchema = z
+    .object({
+    profile: databricksText("Databricks CLI profile.").meta({
+        env: databricksEnvironmentNames.profile,
+    }),
+    host: normalizedUrlSchema
+        .optional()
+        .describe("Databricks host.")
+        .meta({ env: databricksEnvironmentNames.host, flag: false }),
+    accountId: databricksText("Databricks account ID.").meta({
+        env: databricksEnvironmentNames.accountId,
+        flag: false,
+    }),
+    workspaceId: databricksText("Databricks workspace ID.").meta({
+        env: databricksEnvironmentNames.workspaceId,
+        flag: false,
+    }),
+    configFile: databricksText("Databricks CLI config file.").meta({
+        env: databricksEnvironmentNames.configFile,
+        flag: false,
+    }),
+    clientId: databricksText("Databricks OAuth client ID.").meta({
+        env: databricksEnvironmentNames.clientId,
+        flag: false,
+    }),
+    clientSecret: databricksText("Databricks OAuth client secret.").meta({
+        env: databricksEnvironmentNames.clientSecret,
+        flag: false,
+    }),
+    accessToken: databricksText("Databricks access token.").meta({
+        env: databricksEnvironmentNames.accessToken,
+        flag: false,
+    }),
+    groupId: databricksText("Databricks group ID.").meta({
+        env: databricksEnvironmentNames.groupId,
+        flag: false,
+    }),
+    authType: databricksText("Databricks authentication type.").meta({
+        env: databricksEnvironmentNames.authType,
+        flag: false,
+    }),
+    appName: databricksText("Databricks App name.").meta({
+        env: databricksEnvironmentNames.appName,
+        flag: false,
+    }),
+    appPort: tcpPortSchema.optional().describe("Databricks App port.").meta({
+        env: databricksEnvironmentNames.appPort,
+        flag: false,
+    }),
+    lakebaseEndpoint: databricksText("Lakebase endpoint.").meta({
+        env: databricksEnvironmentNames.lakebaseEndpoint,
+        flag: false,
+    }),
+})
+    .strict()
+    .describe("Common Databricks CLI, SDK, Apps, and Lakebase options.");
+/** Serialize complete parsed options as JSON keyed by flags or environment names. */
+export function serializeOpts(schema, values, format) {
+    const parsed = schema.parse(values);
+    const entries = optionProperties(schema).flatMap((property) => {
+        if (format === "flag" && property.flag === false)
+            return [];
+        const key = format === "flag"
+            ? `--${toSlug(property.key)}`
+            : (optionEnvironmentNames(property.key, property.env)[0] ?? "");
+        if (!key)
+            return [];
+        const value = parsed[property.key];
+        return value === undefined ? [] : [[key, serializedOptionValue(value)]];
+    });
+    return JSON.stringify(Object.fromEntries(entries), null, 2);
+}
+const optionalText = (description, env) => z.string().trim().min(1).optional().describe(description).meta({ env, flag: false });
+export const LakebaseOptionsSchema = z
+    .object({
+    lakebaseEndpoint: optionalText("Lakebase project, resource path, host, or URL.", databricksEnvironmentNames.lakebaseEndpoint),
+})
+    .strict()
+    .describe("Common Lakebase options.");
+/** Parse only supplied flag and environment values through an owning Zod object schema. */
+export function parseOpts(schema, flags = null, environment = null) {
+    const configured = optionValues(schema, flags, environment);
+    const parsed = schema.parse(configured);
+    return Object.fromEntries(Object.keys(configured).map((key) => [key, parsed[key]]));
+}
+/** Build a listener address schema accepting a port, `:port`, `host:port`, or object. */
+export function listenAddressSchema(options) {
+    const defaults = {
+        host: options.host ?? "localhost",
+        port: options.port,
+    };
+    return z
+        .preprocess((value) => parseListenAddress(value, defaults), z
+        .object({
+        host: z.string().trim().toLowerCase().min(1).default(defaults.host),
+        port: tcpPortOrZeroSchema.default(defaults.port),
+    })
+        .strict()
+        .refine((address) => !options.loopback || isLoopbackHost(address.host), "Listener host must be loopback."))
+        .default(defaults)
+        .describe("Listener host and port.");
+}
+/** Render a listener address as `host:port`, with IPv6 hosts bracketed. */
+export function formatListenAddress(address) {
+    const host = address.host.includes(":") ? `[${address.host}]` : address.host;
+    return `${host}:${address.port}`;
+}
+function parseListenAddress(value, defaults) {
+    if (typeof value === "number")
+        return { host: defaults.host, port: value };
+    if (typeof value !== "string")
+        return value;
+    const text = value.trim();
+    if (/^\d+$/.test(text))
+        return { host: defaults.host, port: text };
+    if (/^:\d+$/.test(text))
+        return { host: defaults.host, port: text.slice(1) };
+    const bracketed = text.match(/^\[([^\]]+)\](?::(\d+))?$/);
+    if (bracketed) {
+        return { host: bracketed[1], port: bracketed[2] ?? defaults.port };
+    }
+    const separator = text.lastIndexOf(":");
+    if (separator > 0 && !text.slice(0, separator).includes(":")) {
+        return {
+            host: text.slice(0, separator),
+            port: text.slice(separator + 1),
+        };
+    }
+    return { host: text || defaults.host, port: defaults.port };
+}
+function optionProperties(schema) {
+    const document = z.toJSONSchema(schema);
+    if (!isRecord(document.properties))
+        return [];
+    return Object.entries(document.properties).flatMap(([key, value]) => {
+        if (!isRecord(value))
+            return [];
+        return [
+            {
+                key,
+                type: typeof value.type === "string" ? value.type : undefined,
+                env: typeof value.env === "string" || Array.isArray(value.env)
+                    ? value.env
+                    : undefined,
+                flag: typeof value.flag === "boolean" ? value.flag : undefined,
+            },
+        ];
+    });
+}
+function serializedOptionValue(value) {
+    if (isRecord(value) && typeof value.host === "string" && typeof value.port === "number") {
+        return formatListenAddress({ host: value.host, port: value.port });
+    }
+    return value;
+}
+function optionValues(schema, values, environment) {
+    const document = z.toJSONSchema(schema);
+    const properties = isRecord(document.properties) ? document.properties : {};
+    const configured = {};
+    for (const [key, property] of Object.entries(properties)) {
+        if (!isRecord(property))
+            continue;
+        const explicit = firstOptionValue(values, [key, `--${toSlug(key)}`]);
+        if (explicit !== undefined) {
+            configured[key] = optionEnvironmentValue(property.type, explicit);
+            continue;
+        }
+        const names = optionEnvironmentNames(key, property.env);
+        const sourced = firstOptionValue(environment, names);
+        if (sourced === undefined)
+            continue;
+        configured[key] = optionEnvironmentValue(property.type, sourced);
+    }
+    return configured;
+}
+function optionEnvironmentNames(key, configured) {
+    if (typeof configured === "string")
+        return [configured];
+    if (Array.isArray(configured)) {
+        return configured.filter((value) => typeof value === "string");
+    }
+    return [toIdentifierWithOptions({ delimiter: "_" }, key).toUpperCase()];
+}
+function optionEnvironmentValue(type, value) {
+    if (type === "boolean")
+        return toBoolean(value) ?? value;
+    if (type === "array" && typeof value === "string")
+        return parseList(value);
+    return value;
+}
+function firstOptionValue(source, keys) {
+    if (!source)
+        return undefined;
+    for (const key of keys) {
+        const value = source[key];
+        if (value !== undefined && value !== null && value !== "")
+            return value;
+    }
+    return undefined;
+}
+function normalizeUrl(value) {
+    const url = urlBuilder(value);
+    if (!url)
+        return value;
+    const normalized = url.toString();
+    return url.pathname === "/" && !url.search && !url.hash ? normalized.slice(0, -1) : normalized;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"options.js","sourceRoot":"","sources":["../../src/options.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Browser-safe option primitives shared across dbx-tools packages.\n *\n * @module\n */\n\nimport { z } from \"zod\";\nimport { isLoopbackHost, urlBuilder } from \"./net.ts\";\nimport { isRecord, toBoolean } from \"./object.ts\";\nimport { parseList, toIdentifierWithOptions, toSlug } from \"./string-utils.ts\";\n\nconst environmentName = <T extends string>(name: T, description: string) =>\n  z.literal(name).default(name).describe(description);\n\nexport const DatabricksEnvironmentNamesSchema = z\n  .object({\n    profile: environmentName(\"DATABRICKS_CONFIG_PROFILE\", \"Databricks CLI profile environment.\"),\n    host: environmentName(\"DATABRICKS_HOST\", \"Databricks host environment.\"),\n    accountId: environmentName(\"DATABRICKS_ACCOUNT_ID\", \"Databricks account ID environment.\"),\n    workspaceId: environmentName(\"DATABRICKS_WORKSPACE_ID\", \"Databricks workspace ID environment.\"),\n    configFile: environmentName(\n      \"DATABRICKS_CONFIG_FILE\",\n      \"Databricks CLI config file environment.\",\n    ),\n    clientId: environmentName(\"DATABRICKS_CLIENT_ID\", \"Databricks OAuth client ID environment.\"),\n    clientSecret: environmentName(\n      \"DATABRICKS_CLIENT_SECRET\",\n      \"Databricks OAuth client secret environment.\",\n    ),\n    accessToken: environmentName(\"DATABRICKS_TOKEN\", \"Databricks access token environment.\"),\n    groupId: environmentName(\"DATABRICKS_GROUP_ID\", \"Databricks group ID environment.\"),\n    authType: environmentName(\"DATABRICKS_AUTH_TYPE\", \"Databricks auth type environment.\"),\n    appName: environmentName(\"DATABRICKS_APP_NAME\", \"Databricks App name environment.\"),\n    appPort: environmentName(\"DATABRICKS_APP_PORT\", \"Databricks App port environment.\"),\n    lakebaseEndpoint: environmentName(\"LAKEBASE_ENDPOINT\", \"Lakebase endpoint environment.\"),\n  })\n  .strict()\n  .describe(\"Canonical Databricks CLI, SDK, Apps, and Lakebase environment names.\");\n\nexport type DatabricksEnvironmentNames = z.output<typeof DatabricksEnvironmentNamesSchema>;\n\n/** Canonical Databricks environment names derived from the owning schema. */\nexport const databricksEnvironmentNames = Object.freeze(DatabricksEnvironmentNamesSchema.parse({}));\n\n/** Highest valid TCP port number. */\nexport const MAX_TCP_PORT = 65_535;\n\nexport const tcpPortSchema = z.coerce\n  .number<number>()\n  .int()\n  .min(1)\n  .max(MAX_TCP_PORT)\n  .describe(\"TCP port from 1 through 65535.\");\n\nexport const tcpPortOrZeroSchema = z.coerce\n  .number<number>()\n  .int()\n  .min(0)\n  .max(MAX_TCP_PORT)\n  .describe(\"TCP port from 0 through 65535, where zero requests automatic allocation.\");\n\nexport const normalizedUrlSchema = z\n  .string()\n  .trim()\n  .min(1)\n  .refine((value) => urlBuilder(value) !== undefined, {\n    message: \"Expected a valid URL or host.\",\n  })\n  .overwrite(normalizeUrl)\n  .describe(\"URL normalized through the shared URL builder.\");\n\nconst databricksText = (description: string) =>\n  z.string().trim().min(1).optional().describe(description);\n\nexport const DatabricksOptionsSchema = z\n  .object({\n    profile: databricksText(\"Databricks CLI profile.\").meta({\n      env: databricksEnvironmentNames.profile,\n    }),\n    host: normalizedUrlSchema\n      .optional()\n      .describe(\"Databricks host.\")\n      .meta({ env: databricksEnvironmentNames.host, flag: false }),\n    accountId: databricksText(\"Databricks account ID.\").meta({\n      env: databricksEnvironmentNames.accountId,\n      flag: false,\n    }),\n    workspaceId: databricksText(\"Databricks workspace ID.\").meta({\n      env: databricksEnvironmentNames.workspaceId,\n      flag: false,\n    }),\n    configFile: databricksText(\"Databricks CLI config file.\").meta({\n      env: databricksEnvironmentNames.configFile,\n      flag: false,\n    }),\n    clientId: databricksText(\"Databricks OAuth client ID.\").meta({\n      env: databricksEnvironmentNames.clientId,\n      flag: false,\n    }),\n    clientSecret: databricksText(\"Databricks OAuth client secret.\").meta({\n      env: databricksEnvironmentNames.clientSecret,\n      flag: false,\n    }),\n    accessToken: databricksText(\"Databricks access token.\").meta({\n      env: databricksEnvironmentNames.accessToken,\n      flag: false,\n    }),\n    groupId: databricksText(\"Databricks group ID.\").meta({\n      env: databricksEnvironmentNames.groupId,\n      flag: false,\n    }),\n    authType: databricksText(\"Databricks authentication type.\").meta({\n      env: databricksEnvironmentNames.authType,\n      flag: false,\n    }),\n    appName: databricksText(\"Databricks App name.\").meta({\n      env: databricksEnvironmentNames.appName,\n      flag: false,\n    }),\n    appPort: tcpPortSchema.optional().describe(\"Databricks App port.\").meta({\n      env: databricksEnvironmentNames.appPort,\n      flag: false,\n    }),\n    lakebaseEndpoint: databricksText(\"Lakebase endpoint.\").meta({\n      env: databricksEnvironmentNames.lakebaseEndpoint,\n      flag: false,\n    }),\n  })\n  .strict()\n  .describe(\"Common Databricks CLI, SDK, Apps, and Lakebase options.\");\n\nexport type DatabricksOptions = z.input<typeof DatabricksOptionsSchema>;\n\n/** Key format emitted by {@link serializeOpts}. */\nexport type OptionSerializationFormat = \"flag\" | \"env\";\n\ninterface OptionProperty {\n  readonly key: string;\n  readonly type?: string;\n  readonly env?: string | readonly string[];\n  readonly flag?: boolean;\n}\n\n/** Serialize complete parsed options as JSON keyed by flags or environment names. */\nexport function serializeOpts<T extends z.ZodRawShape>(\n  schema: z.ZodObject<T>,\n  values: z.input<z.ZodObject<T>>,\n  format: OptionSerializationFormat,\n): string {\n  const parsed = schema.parse(values) as Readonly<Record<string, unknown>>;\n  const entries = optionProperties(schema).flatMap((property) => {\n    if (format === \"flag\" && property.flag === false) return [];\n    const key =\n      format === \"flag\"\n        ? `--${toSlug(property.key)}`\n        : (optionEnvironmentNames(property.key, property.env)[0] ?? \"\");\n    if (!key) return [];\n    const value = parsed[property.key];\n    return value === undefined ? [] : [[key, serializedOptionValue(value)] as const];\n  });\n  return JSON.stringify(Object.fromEntries(entries), null, 2);\n}\n\nconst optionalText = (description: string, env: string) =>\n  z.string().trim().min(1).optional().describe(description).meta({ env, flag: false });\n\nexport const LakebaseOptionsSchema = z\n  .object({\n    lakebaseEndpoint: optionalText(\n      \"Lakebase project, resource path, host, or URL.\",\n      databricksEnvironmentNames.lakebaseEndpoint,\n    ),\n  })\n  .strict()\n  .describe(\"Common Lakebase options.\");\n\nexport type LakebaseOptions = z.input<typeof LakebaseOptionsSchema>;\n\n/** Explicit option values or environment entries consumed by option parsing helpers. */\nexport type OptionValueMap = Readonly<Record<string, unknown>> | null;\n\n/** Parse only supplied flag and environment values through an owning Zod object schema. */\nexport function parseOpts<T extends z.ZodRawShape>(\n  schema: z.ZodObject<T>,\n  flags: OptionValueMap = null,\n  environment: OptionValueMap = null,\n): Partial<z.output<z.ZodObject<T>>> {\n  const configured = optionValues(schema, flags, environment);\n  const parsed = schema.parse(configured);\n  return Object.fromEntries(\n    Object.keys(configured).map((key) => [key, parsed[key as keyof typeof parsed]]),\n  ) as Partial<z.output<z.ZodObject<T>>>;\n}\n\n/** Host and TCP port returned by {@link listenAddressSchema}. */\nexport interface ListenAddress {\n  readonly host: string;\n  readonly port: number;\n}\n\n/** Defaults and validation policy for {@link listenAddressSchema}. */\nexport interface ListenAddressOptions {\n  readonly port: number;\n  readonly host?: string;\n  readonly loopback?: boolean;\n}\n\n/** Build a listener address schema accepting a port, `:port`, `host:port`, or object. */\nexport function listenAddressSchema(options: ListenAddressOptions) {\n  const defaults: ListenAddress = {\n    host: options.host ?? \"localhost\",\n    port: options.port,\n  };\n  return z\n    .preprocess(\n      (value) => parseListenAddress(value, defaults),\n      z\n        .object({\n          host: z.string().trim().toLowerCase().min(1).default(defaults.host),\n          port: tcpPortOrZeroSchema.default(defaults.port),\n        })\n        .strict()\n        .refine(\n          (address) => !options.loopback || isLoopbackHost(address.host),\n          \"Listener host must be loopback.\",\n        ),\n    )\n    .default(defaults)\n    .describe(\"Listener host and port.\");\n}\n\n/** Render a listener address as `host:port`, with IPv6 hosts bracketed. */\nexport function formatListenAddress(address: ListenAddress): string {\n  const host = address.host.includes(\":\") ? `[${address.host}]` : address.host;\n  return `${host}:${address.port}`;\n}\n\nfunction parseListenAddress(value: unknown, defaults: ListenAddress): unknown {\n  if (typeof value === \"number\") return { host: defaults.host, port: value };\n  if (typeof value !== \"string\") return value;\n  const text = value.trim();\n  if (/^\\d+$/.test(text)) return { host: defaults.host, port: text };\n  if (/^:\\d+$/.test(text)) return { host: defaults.host, port: text.slice(1) };\n  const bracketed = text.match(/^\\[([^\\]]+)\\](?::(\\d+))?$/);\n  if (bracketed) {\n    return { host: bracketed[1], port: bracketed[2] ?? defaults.port };\n  }\n  const separator = text.lastIndexOf(\":\");\n  if (separator > 0 && !text.slice(0, separator).includes(\":\")) {\n    return {\n      host: text.slice(0, separator),\n      port: text.slice(separator + 1),\n    };\n  }\n  return { host: text || defaults.host, port: defaults.port };\n}\n\nfunction optionProperties(schema: z.ZodObject<z.ZodRawShape>): OptionProperty[] {\n  const document = z.toJSONSchema(schema);\n  if (!isRecord(document.properties)) return [];\n  return Object.entries(document.properties).flatMap(([key, value]) => {\n    if (!isRecord(value)) return [];\n    return [\n      {\n        key,\n        type: typeof value.type === \"string\" ? value.type : undefined,\n        env:\n          typeof value.env === \"string\" || Array.isArray(value.env)\n            ? (value.env as string | readonly string[])\n            : undefined,\n        flag: typeof value.flag === \"boolean\" ? value.flag : undefined,\n      },\n    ];\n  });\n}\n\nfunction serializedOptionValue(value: unknown): unknown {\n  if (isRecord(value) && typeof value.host === \"string\" && typeof value.port === \"number\") {\n    return formatListenAddress({ host: value.host, port: value.port });\n  }\n  return value;\n}\n\nfunction optionValues<T extends z.ZodRawShape>(\n  schema: z.ZodObject<T>,\n  values: OptionValueMap,\n  environment: OptionValueMap,\n): Record<string, unknown> {\n  const document = z.toJSONSchema(schema);\n  const properties = isRecord(document.properties) ? document.properties : {};\n  const configured: Record<string, unknown> = {};\n  for (const [key, property] of Object.entries(properties)) {\n    if (!isRecord(property)) continue;\n    const explicit = firstOptionValue(values, [key, `--${toSlug(key)}`]);\n    if (explicit !== undefined) {\n      configured[key] = optionEnvironmentValue(property.type, explicit);\n      continue;\n    }\n    const names = optionEnvironmentNames(key, property.env);\n    const sourced = firstOptionValue(environment, names);\n    if (sourced === undefined) continue;\n    configured[key] = optionEnvironmentValue(property.type, sourced);\n  }\n  return configured;\n}\n\nfunction optionEnvironmentNames(key: string, configured: unknown): string[] {\n  if (typeof configured === \"string\") return [configured];\n  if (Array.isArray(configured)) {\n    return configured.filter((value): value is string => typeof value === \"string\");\n  }\n  return [toIdentifierWithOptions({ delimiter: \"_\" }, key).toUpperCase()];\n}\n\nfunction optionEnvironmentValue(type: unknown, value: unknown): unknown {\n  if (type === \"boolean\") return toBoolean(value) ?? value;\n  if (type === \"array\" && typeof value === \"string\") return parseList(value);\n  return value;\n}\n\nfunction firstOptionValue(source: OptionValueMap, keys: readonly string[]): unknown | undefined {\n  if (!source) return undefined;\n  for (const key of keys) {\n    const value = source[key];\n    if (value !== undefined && value !== null && value !== \"\") return value;\n  }\n  return undefined;\n}\n\nfunction normalizeUrl(value: string): string {\n  const url = urlBuilder(value);\n  if (!url) return value;\n  const normalized = url.toString();\n  return url.pathname === \"/\" && !url.search && !url.hash ? normalized.slice(0, -1) : normalized;\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/async-utils.ts","../src/brand-utils.ts","../src/environment-utils.ts","../src/error-utils.ts","../src/execution.ts","../src/function-utils.ts","../src/hash.ts","../src/http.ts","../src/json.ts","../src/log.ts","../src/net.ts","../src/object.ts","../src/pattern.ts","../src/predicate.ts","../src/string-utils.ts","../src/token.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/async-utils.ts","../src/brand-utils.ts","../src/environment-utils.ts","../src/error-utils.ts","../src/execution.ts","../src/function-utils.ts","../src/hash.ts","../src/http.ts","../src/json.ts","../src/log.ts","../src/net.ts","../src/object.ts","../src/options.ts","../src/pattern.ts","../src/predicate.ts","../src/string-utils.ts","../src/token.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -19,7 +19,7 @@
     "projen": "projen"
   },
   "devDependencies": {
-    "@dbx-tools/test-polyglot": "^0.9.40",
+    "@dbx-tools/test-polyglot": "^0.9.43",
     "typescript": "^5.9.3"
   },
   "dependencies": {
@@ -84,6 +84,10 @@
         "types": "./lib/src/object.d.ts",
         "default": "./lib/src/object.js"
       },
+      "./options": {
+        "types": "./lib/src/options.d.ts",
+        "default": "./lib/src/options.js"
+      },
       "./pattern": {
         "types": "./lib/src/pattern.d.ts",
         "default": "./lib/src/pattern.js"
@@ -103,7 +107,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.40",
+  "version": "0.9.43",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [
@@ -164,6 +168,10 @@
       "types": "./lib/src/object.d.ts",
       "default": "./lib/src/object.js"
     },
+    "./options": {
+      "types": "./lib/src/options.d.ts",
+      "default": "./lib/src/options.js"
+    },
     "./pattern": {
       "types": "./lib/src/pattern.d.ts",
       "default": "./lib/src/pattern.js"

package/src/environment-utils.ts

@@ -1,13 +1,14 @@
 import { toBoolean } from "./object.ts";
-
-const MAX_TCP_PORT = 65_535;
+import { MAX_TCP_PORT } from "./options.ts";
 
 function runtimeEnvironment(): Record<string, string | undefined> {
   return (
-    globalThis as typeof globalThis & {
-      process?: { env?: Record<string, string | undefined> };
-    }
-  ).process?.env ?? {};
+    (
+      globalThis as typeof globalThis & {
+        process?: { env?: Record<string, string | undefined> };
+      }
+    ).process?.env ?? {}
+  );
 }
 
 /** Detect a Databricks App runtime from its required name, host, and port. */

package/src/options.ts

@@ -0,0 +1,335 @@
+/**
+ * Browser-safe option primitives shared across dbx-tools packages.
+ *
+ * @module
+ */
+
+import { z } from "zod";
+import { isLoopbackHost, urlBuilder } from "./net.ts";
+import { isRecord, toBoolean } from "./object.ts";
+import { parseList, toIdentifierWithOptions, toSlug } from "./string-utils.ts";
+
+const environmentName = <T extends string>(name: T, description: string) =>
+  z.literal(name).default(name).describe(description);
+
+export const DatabricksEnvironmentNamesSchema = z
+  .object({
+    profile: environmentName("DATABRICKS_CONFIG_PROFILE", "Databricks CLI profile environment."),
+    host: environmentName("DATABRICKS_HOST", "Databricks host environment."),
+    accountId: environmentName("DATABRICKS_ACCOUNT_ID", "Databricks account ID environment."),
+    workspaceId: environmentName("DATABRICKS_WORKSPACE_ID", "Databricks workspace ID environment."),
+    configFile: environmentName(
+      "DATABRICKS_CONFIG_FILE",
+      "Databricks CLI config file environment.",
+    ),
+    clientId: environmentName("DATABRICKS_CLIENT_ID", "Databricks OAuth client ID environment."),
+    clientSecret: environmentName(
+      "DATABRICKS_CLIENT_SECRET",
+      "Databricks OAuth client secret environment.",
+    ),
+    accessToken: environmentName("DATABRICKS_TOKEN", "Databricks access token environment."),
+    groupId: environmentName("DATABRICKS_GROUP_ID", "Databricks group ID environment."),
+    authType: environmentName("DATABRICKS_AUTH_TYPE", "Databricks auth type environment."),
+    appName: environmentName("DATABRICKS_APP_NAME", "Databricks App name environment."),
+    appPort: environmentName("DATABRICKS_APP_PORT", "Databricks App port environment."),
+    lakebaseEndpoint: environmentName("LAKEBASE_ENDPOINT", "Lakebase endpoint environment."),
+  })
+  .strict()
+  .describe("Canonical Databricks CLI, SDK, Apps, and Lakebase environment names.");
+
+export type DatabricksEnvironmentNames = z.output<typeof DatabricksEnvironmentNamesSchema>;
+
+/** Canonical Databricks environment names derived from the owning schema. */
+export const databricksEnvironmentNames = Object.freeze(DatabricksEnvironmentNamesSchema.parse({}));
+
+/** Highest valid TCP port number. */
+export const MAX_TCP_PORT = 65_535;
+
+export const tcpPortSchema = z.coerce
+  .number<number>()
+  .int()
+  .min(1)
+  .max(MAX_TCP_PORT)
+  .describe("TCP port from 1 through 65535.");
+
+export const tcpPortOrZeroSchema = z.coerce
+  .number<number>()
+  .int()
+  .min(0)
+  .max(MAX_TCP_PORT)
+  .describe("TCP port from 0 through 65535, where zero requests automatic allocation.");
+
+export const normalizedUrlSchema = z
+  .string()
+  .trim()
+  .min(1)
+  .refine((value) => urlBuilder(value) !== undefined, {
+    message: "Expected a valid URL or host.",
+  })
+  .overwrite(normalizeUrl)
+  .describe("URL normalized through the shared URL builder.");
+
+const databricksText = (description: string) =>
+  z.string().trim().min(1).optional().describe(description);
+
+export const DatabricksOptionsSchema = z
+  .object({
+    profile: databricksText("Databricks CLI profile.").meta({
+      env: databricksEnvironmentNames.profile,
+    }),
+    host: normalizedUrlSchema
+      .optional()
+      .describe("Databricks host.")
+      .meta({ env: databricksEnvironmentNames.host, flag: false }),
+    accountId: databricksText("Databricks account ID.").meta({
+      env: databricksEnvironmentNames.accountId,
+      flag: false,
+    }),
+    workspaceId: databricksText("Databricks workspace ID.").meta({
+      env: databricksEnvironmentNames.workspaceId,
+      flag: false,
+    }),
+    configFile: databricksText("Databricks CLI config file.").meta({
+      env: databricksEnvironmentNames.configFile,
+      flag: false,
+    }),
+    clientId: databricksText("Databricks OAuth client ID.").meta({
+      env: databricksEnvironmentNames.clientId,
+      flag: false,
+    }),
+    clientSecret: databricksText("Databricks OAuth client secret.").meta({
+      env: databricksEnvironmentNames.clientSecret,
+      flag: false,
+    }),
+    accessToken: databricksText("Databricks access token.").meta({
+      env: databricksEnvironmentNames.accessToken,
+      flag: false,
+    }),
+    groupId: databricksText("Databricks group ID.").meta({
+      env: databricksEnvironmentNames.groupId,
+      flag: false,
+    }),
+    authType: databricksText("Databricks authentication type.").meta({
+      env: databricksEnvironmentNames.authType,
+      flag: false,
+    }),
+    appName: databricksText("Databricks App name.").meta({
+      env: databricksEnvironmentNames.appName,
+      flag: false,
+    }),
+    appPort: tcpPortSchema.optional().describe("Databricks App port.").meta({
+      env: databricksEnvironmentNames.appPort,
+      flag: false,
+    }),
+    lakebaseEndpoint: databricksText("Lakebase endpoint.").meta({
+      env: databricksEnvironmentNames.lakebaseEndpoint,
+      flag: false,
+    }),
+  })
+  .strict()
+  .describe("Common Databricks CLI, SDK, Apps, and Lakebase options.");
+
+export type DatabricksOptions = z.input<typeof DatabricksOptionsSchema>;
+
+/** Key format emitted by {@link serializeOpts}. */
+export type OptionSerializationFormat = "flag" | "env";
+
+interface OptionProperty {
+  readonly key: string;
+  readonly type?: string;
+  readonly env?: string | readonly string[];
+  readonly flag?: boolean;
+}
+
+/** Serialize complete parsed options as JSON keyed by flags or environment names. */
+export function serializeOpts<T extends z.ZodRawShape>(
+  schema: z.ZodObject<T>,
+  values: z.input<z.ZodObject<T>>,
+  format: OptionSerializationFormat,
+): string {
+  const parsed = schema.parse(values) as Readonly<Record<string, unknown>>;
+  const entries = optionProperties(schema).flatMap((property) => {
+    if (format === "flag" && property.flag === false) return [];
+    const key =
+      format === "flag"
+        ? `--${toSlug(property.key)}`
+        : (optionEnvironmentNames(property.key, property.env)[0] ?? "");
+    if (!key) return [];
+    const value = parsed[property.key];
+    return value === undefined ? [] : [[key, serializedOptionValue(value)] as const];
+  });
+  return JSON.stringify(Object.fromEntries(entries), null, 2);
+}
+
+const optionalText = (description: string, env: string) =>
+  z.string().trim().min(1).optional().describe(description).meta({ env, flag: false });
+
+export const LakebaseOptionsSchema = z
+  .object({
+    lakebaseEndpoint: optionalText(
+      "Lakebase project, resource path, host, or URL.",
+      databricksEnvironmentNames.lakebaseEndpoint,
+    ),
+  })
+  .strict()
+  .describe("Common Lakebase options.");
+
+export type LakebaseOptions = z.input<typeof LakebaseOptionsSchema>;
+
+/** Explicit option values or environment entries consumed by option parsing helpers. */
+export type OptionValueMap = Readonly<Record<string, unknown>> | null;
+
+/** Parse only supplied flag and environment values through an owning Zod object schema. */
+export function parseOpts<T extends z.ZodRawShape>(
+  schema: z.ZodObject<T>,
+  flags: OptionValueMap = null,
+  environment: OptionValueMap = null,
+): Partial<z.output<z.ZodObject<T>>> {
+  const configured = optionValues(schema, flags, environment);
+  const parsed = schema.parse(configured);
+  return Object.fromEntries(
+    Object.keys(configured).map((key) => [key, parsed[key as keyof typeof parsed]]),
+  ) as Partial<z.output<z.ZodObject<T>>>;
+}
+
+/** Host and TCP port returned by {@link listenAddressSchema}. */
+export interface ListenAddress {
+  readonly host: string;
+  readonly port: number;
+}
+
+/** Defaults and validation policy for {@link listenAddressSchema}. */
+export interface ListenAddressOptions {
+  readonly port: number;
+  readonly host?: string;
+  readonly loopback?: boolean;
+}
+
+/** Build a listener address schema accepting a port, `:port`, `host:port`, or object. */
+export function listenAddressSchema(options: ListenAddressOptions) {
+  const defaults: ListenAddress = {
+    host: options.host ?? "localhost",
+    port: options.port,
+  };
+  return z
+    .preprocess(
+      (value) => parseListenAddress(value, defaults),
+      z
+        .object({
+          host: z.string().trim().toLowerCase().min(1).default(defaults.host),
+          port: tcpPortOrZeroSchema.default(defaults.port),
+        })
+        .strict()
+        .refine(
+          (address) => !options.loopback || isLoopbackHost(address.host),
+          "Listener host must be loopback.",
+        ),
+    )
+    .default(defaults)
+    .describe("Listener host and port.");
+}
+
+/** Render a listener address as `host:port`, with IPv6 hosts bracketed. */
+export function formatListenAddress(address: ListenAddress): string {
+  const host = address.host.includes(":") ? `[${address.host}]` : address.host;
+  return `${host}:${address.port}`;
+}
+
+function parseListenAddress(value: unknown, defaults: ListenAddress): unknown {
+  if (typeof value === "number") return { host: defaults.host, port: value };
+  if (typeof value !== "string") return value;
+  const text = value.trim();
+  if (/^\d+$/.test(text)) return { host: defaults.host, port: text };
+  if (/^:\d+$/.test(text)) return { host: defaults.host, port: text.slice(1) };
+  const bracketed = text.match(/^\[([^\]]+)\](?::(\d+))?$/);
+  if (bracketed) {
+    return { host: bracketed[1], port: bracketed[2] ?? defaults.port };
+  }
+  const separator = text.lastIndexOf(":");
+  if (separator > 0 && !text.slice(0, separator).includes(":")) {
+    return {
+      host: text.slice(0, separator),
+      port: text.slice(separator + 1),
+    };
+  }
+  return { host: text || defaults.host, port: defaults.port };
+}
+
+function optionProperties(schema: z.ZodObject<z.ZodRawShape>): OptionProperty[] {
+  const document = z.toJSONSchema(schema);
+  if (!isRecord(document.properties)) return [];
+  return Object.entries(document.properties).flatMap(([key, value]) => {
+    if (!isRecord(value)) return [];
+    return [
+      {
+        key,
+        type: typeof value.type === "string" ? value.type : undefined,
+        env:
+          typeof value.env === "string" || Array.isArray(value.env)
+            ? (value.env as string | readonly string[])
+            : undefined,
+        flag: typeof value.flag === "boolean" ? value.flag : undefined,
+      },
+    ];
+  });
+}
+
+function serializedOptionValue(value: unknown): unknown {
+  if (isRecord(value) && typeof value.host === "string" && typeof value.port === "number") {
+    return formatListenAddress({ host: value.host, port: value.port });
+  }
+  return value;
+}
+
+function optionValues<T extends z.ZodRawShape>(
+  schema: z.ZodObject<T>,
+  values: OptionValueMap,
+  environment: OptionValueMap,
+): Record<string, unknown> {
+  const document = z.toJSONSchema(schema);
+  const properties = isRecord(document.properties) ? document.properties : {};
+  const configured: Record<string, unknown> = {};
+  for (const [key, property] of Object.entries(properties)) {
+    if (!isRecord(property)) continue;
+    const explicit = firstOptionValue(values, [key, `--${toSlug(key)}`]);
+    if (explicit !== undefined) {
+      configured[key] = optionEnvironmentValue(property.type, explicit);
+      continue;
+    }
+    const names = optionEnvironmentNames(key, property.env);
+    const sourced = firstOptionValue(environment, names);
+    if (sourced === undefined) continue;
+    configured[key] = optionEnvironmentValue(property.type, sourced);
+  }
+  return configured;
+}
+
+function optionEnvironmentNames(key: string, configured: unknown): string[] {
+  if (typeof configured === "string") return [configured];
+  if (Array.isArray(configured)) {
+    return configured.filter((value): value is string => typeof value === "string");
+  }
+  return [toIdentifierWithOptions({ delimiter: "_" }, key).toUpperCase()];
+}
+
+function optionEnvironmentValue(type: unknown, value: unknown): unknown {
+  if (type === "boolean") return toBoolean(value) ?? value;
+  if (type === "array" && typeof value === "string") return parseList(value);
+  return value;
+}
+
+function firstOptionValue(source: OptionValueMap, keys: readonly string[]): unknown | undefined {
+  if (!source) return undefined;
+  for (const key of keys) {
+    const value = source[key];
+    if (value !== undefined && value !== null && value !== "") return value;
+  }
+  return undefined;
+}
+
+function normalizeUrl(value: string): string {
+  const url = urlBuilder(value);
+  if (!url) return value;
+  const normalized = url.toString();
+  return url.pathname === "/" && !url.search && !url.hash ? normalized.slice(0, -1) : normalized;
+}