@uapkg/cli 1.4.0 → 1.5.0

package/dist/types/uapkg-common-schema/primitives/PackageName.d.ts

@@ -0,0 +1,14 @@
+import { Brand } from "../brand/Brand.js";
+import { z } from "zod";
+//#region src/primitives/PackageName.d.ts
+/**
+ * Branded type for a uapkg package name.
+ * Unscoped (`my-package`) or scoped (`@owner/my-package`); each segment is
+ * lowercase alphanumeric with hyphens.
+ */
+type PackageName = Brand<string, 'PackageName'>;
+declare const PackageNameSchema: z.core.$ZodBranded<z.ZodString, "PackageName", "out">;
+/** True when the package name uses the `@owner/package` scoped form. */
+declare function isScopedPackageName(name: string): boolean;
+//#endregion
+export { PackageName, PackageNameSchema, isScopedPackageName };

package/dist/types/uapkg-common-schema/primitives/PackageSpec.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+//#region src/primitives/PackageSpec.d.ts
+/**
+ * Parsed CLI package specifier.
+ *
+ * Grammar: `(@<org>/)?<name>(@<range>)?`
+ *
+ * Examples:
+ *   - `awesome-pkg`                              → { name: "awesome-pkg" }
+ *   - `awesome-pkg@^1.0.0`                       → { name, range }
+ *   - `@myorg/awesome-pkg`                       → { org, name }
+ *   - `@myorg/awesome-pkg@^1.0.0`                → { org, name, range }
+ */
+declare const PackageSpecSchema: z.ZodObject<{
+  org: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "OrgName", "out">>;
+  name: z.core.$ZodBranded<z.ZodString, "PackageName", "out">;
+  range: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "VersionRange", "out">>;
+}, z.core.$strict>;
+type PackageSpec = z.infer<typeof PackageSpecSchema>;
+//#endregion
+export { PackageSpec, PackageSpecSchema };

package/dist/types/uapkg-common-schema/primitives/PackageVersion.d.ts

@@ -0,0 +1,10 @@
+import { Brand } from "../brand/Brand.js";
+import { z } from "zod";
+//#region src/primitives/PackageVersion.d.ts
+/**
+ * Branded type for a valid semver v2 version string (no `v` or `=` prefix).
+ */
+type PackageVersion = Brand<string, 'PackageVersion'>;
+declare const PackageVersionSchema: z.core.$ZodBranded<z.ZodString, "PackageVersion", "out">;
+//#endregion
+export { PackageVersion, PackageVersionSchema };

package/dist/types/uapkg-common-schema/primitives/PostInstallPolicy.d.ts

@@ -0,0 +1,21 @@
+import { Brand } from "../brand/Brand.js";
+import { z } from "zod";
+//#region src/primitives/PostInstallPolicy.d.ts
+/**
+ * PostInstallPolicy controls whether plugin-authored postinstall hooks are
+ * allowed to mutate the host Unreal project on install/update.
+ *
+ * - `allow`: postinstall hooks execute after extraction.
+ * - `deny`: postinstall hooks are skipped; an info diagnostic is emitted.
+ *
+ * The `prompt` variant is intentionally unsupported — uapkg commands must
+ * remain non-interactive so they can run unattended in CI.
+ */
+type PostInstallPolicy = Brand<'allow' | 'deny', 'PostInstallPolicy'>;
+declare const PostInstallPolicySchema: z.core.$ZodBranded<z.ZodEnum<{
+  allow: "allow";
+  deny: "deny";
+}>, "PostInstallPolicy", "out">;
+declare const POSTINSTALL_POLICY_DEFAULT: PostInstallPolicy;
+//#endregion
+export { POSTINSTALL_POLICY_DEFAULT, PostInstallPolicy, PostInstallPolicySchema };

package/dist/types/uapkg-common-schema/primitives/RegistryIdentifier.d.ts

@@ -0,0 +1,15 @@
+import { Brand } from "../brand/Brand.js";
+import { z } from "zod";
+//#region src/primitives/RegistryIdentifier.d.ts
+/**
+ * Branded type for the full registry identifier (64-char hex SHA-256).
+ */
+type RegistryIdentifier = Brand<string, 'RegistryIdentifier'>;
+declare const RegistryIdentifierSchema: z.core.$ZodBranded<z.ZodString, "RegistryIdentifier", "out">;
+/**
+ * Branded type for the short registry identifier (first 16 hex chars).
+ */
+type RegistryIdentifierShort = Brand<string, 'RegistryIdentifierShort'>;
+declare const RegistryIdentifierShortSchema: z.core.$ZodBranded<z.ZodString, "RegistryIdentifierShort", "out">;
+//#endregion
+export { RegistryIdentifier, RegistryIdentifierSchema, RegistryIdentifierShort, RegistryIdentifierShortSchema };

package/dist/types/uapkg-common-schema/primitives/RegistryName.d.ts

@@ -0,0 +1,18 @@
+import { Brand } from "../brand/Brand.js";
+import { z } from "zod";
+//#region src/primitives/RegistryName.d.ts
+/**
+ * Branded type for a logical registry name (the key under `registries` in config).
+ */
+type RegistryName = Brand<string, 'RegistryName'>;
+declare const RegistryNameSchema: z.core.$ZodBranded<z.ZodString, "RegistryName", "out">;
+/**
+ * The machine-local alias that resolves to the user's configured default
+ * registry. In manifests and registry records the default is represented by
+ * an ABSENT `registry` field; this alias exists only at local resolution
+ * boundaries (config, CLI input) and an explicit `"default"` normalizes to
+ * absence.
+ */
+declare const DEFAULT_REGISTRY_ALIAS: RegistryName;
+//#endregion
+export { DEFAULT_REGISTRY_ALIAS, RegistryName, RegistryNameSchema };

package/dist/types/uapkg-common-schema/primitives/RegistryURL.d.ts

@@ -0,0 +1,10 @@
+import { Brand } from "../brand/Brand.js";
+import { z } from "zod";
+//#region src/primitives/RegistryURL.d.ts
+/**
+ * Branded type for a registry git URL.
+ */
+type RegistryURL = Brand<string, 'RegistryURL'>;
+declare const RegistryURLSchema: z.core.$ZodBranded<z.ZodString, "RegistryURL", "out">;
+//#endregion
+export { RegistryURL, RegistryURLSchema };

package/dist/types/uapkg-common-schema/primitives/UnixTimestamp.d.ts

@@ -0,0 +1,10 @@
+import { Brand } from "../brand/Brand.js";
+import { z } from "zod";
+//#region src/primitives/UnixTimestamp.d.ts
+/**
+ * Branded type for a Unix timestamp (seconds since epoch, UTC).
+ */
+type UnixTimestamp = Brand<number, 'UnixTimestamp'>;
+declare const UnixTimestampSchema: z.core.$ZodBranded<z.ZodNumber, "UnixTimestamp", "out">;
+//#endregion
+export { UnixTimestamp, UnixTimestampSchema };

package/dist/types/uapkg-common-schema/primitives/VersionRange.d.ts

@@ -0,0 +1,10 @@
+import { Brand } from "../brand/Brand.js";
+import { z } from "zod";
+//#region src/primitives/VersionRange.d.ts
+/**
+ * Branded type for a valid semver range expression (e.g. `^1.2.0`, `>=0.5.0 <1.0.0`).
+ */
+type VersionRange = Brand<string, 'VersionRange'>;
+declare const VersionRangeSchema: z.core.$ZodBranded<z.ZodString, "VersionRange", "out">;
+//#endregion
+export { VersionRange, VersionRangeSchema };

package/dist/types/uapkg-config/contracts/ConfigTypes.d.ts

@@ -0,0 +1,58 @@
+import { PartialConfig, PostInstallPolicyValue, RegistryConfig, RegistryRef, ResolvedConfig } from "../schema/configSchema.js";
+import { Diagnostic } from "../../uapkg-diagnostics/index.js";
+//#region src/contracts/ConfigTypes.d.ts
+type ConfigLayerSource = 'default' | 'global' | 'intermediary' | 'local';
+type ConfigValue = unknown;
+interface ConfigLayer {
+  source: ConfigLayerSource;
+  file?: string;
+  values: Record<string, unknown>;
+}
+interface ConfigValueWithOrigin {
+  value: ConfigValue;
+  source: ConfigLayerSource;
+  file?: string;
+}
+interface ConfigTraceEntry {
+  source: ConfigLayerSource;
+  value: ConfigValue;
+  file?: string;
+}
+type ConfigScope = 'global' | 'local';
+interface ConfigReloadOptions {
+  cwd?: string;
+}
+interface ConfigCreateOptions {
+  cwd?: string;
+}
+interface ConfigGetOptions {
+  scope?: ConfigScope;
+}
+interface ConfigListOptions {
+  scope?: ConfigScope;
+}
+interface ConfigWriteOptions {
+  scope?: ConfigScope;
+}
+interface ConfigPaths {
+  cwd: string;
+  manifestRoot: string;
+  globalFile: string;
+  localFile: string;
+  intermediaryFiles: string[];
+}
+interface ConfigReadResult {
+  values: Record<string, unknown>;
+  exists: boolean;
+  diagnostics: readonly Diagnostic[];
+}
+interface ConfigLayerBuildResult {
+  layers: ConfigLayer[];
+  diagnostics: readonly Diagnostic[];
+}
+interface ConfigResolvedResult {
+  value: Record<string, unknown>;
+  diagnostics: readonly Diagnostic[];
+}
+//#endregion
+export { ConfigCreateOptions, ConfigGetOptions, ConfigLayer, ConfigLayerBuildResult, ConfigLayerSource, ConfigListOptions, ConfigPaths, ConfigReadResult, ConfigReloadOptions, ConfigResolvedResult, ConfigScope, ConfigTraceEntry, ConfigValue, ConfigValueWithOrigin, ConfigWriteOptions, type PartialConfig, type PostInstallPolicyValue, type RegistryConfig, type RegistryRef, type ResolvedConfig };

package/dist/types/uapkg-config/core/ConfigInstance.d.ts

@@ -0,0 +1,43 @@
+import { ResolvedConfig } from "../schema/configSchema.js";
+import { ConfigCreateOptions, ConfigGetOptions, ConfigListOptions, ConfigReloadOptions, ConfigTraceEntry, ConfigValueWithOrigin, ConfigWriteOptions } from "../contracts/ConfigTypes.js";
+import { ConfigLayerBuilder } from "./ConfigLayerBuilder.js";
+import { ConfigResolver } from "./ConfigResolver.js";
+import { ConfigWriter } from "./ConfigWriter.js";
+import { Diagnostic, Result } from "../../uapkg-diagnostics/index.js";
+//#region src/core/ConfigInstance.d.ts
+declare class ConfigInstance {
+  private readonly layerBuilder;
+  private readonly resolver;
+  private readonly writer;
+  private cwd;
+  private layers;
+  private resolved;
+  private diagnostics;
+  constructor(options?: ConfigCreateOptions, layerBuilder?: ConfigLayerBuilder, resolver?: ConfigResolver, writer?: ConfigWriter);
+  get(pathToProperty?: string, options?: ConfigGetOptions): unknown;
+  getAll(options?: ConfigListOptions): ResolvedConfig | Record<string, unknown> | null;
+  getDefaultRegistry(): {
+    url: string;
+    ref: {
+      type: string;
+      value: string;
+    };
+  } | null;
+  getWithOrigin(pathToProperty: string): ConfigValueWithOrigin | null;
+  trace(pathToProperty: string): ConfigTraceEntry[];
+  set(pathToProperty: string, value: unknown, options?: ConfigWriteOptions): Result<{
+    file: string;
+    values: Record<string, unknown>;
+  }>;
+  delete(pathToProperty: string, options?: ConfigWriteOptions): Result<{
+    file: string;
+    values: Record<string, unknown>;
+  }>;
+  getEditTarget(options?: ConfigWriteOptions): string;
+  toDisplayPath(filePath: string): string;
+  getDiagnostics(): readonly Diagnostic[];
+  reload(options?: ConfigReloadOptions): this;
+  private getValueFromObject;
+}
+//#endregion
+export { ConfigInstance };

package/dist/types/uapkg-config/core/ConfigLayerBuilder.d.ts

@@ -0,0 +1,13 @@
+import { ConfigLayerBuildResult } from "../contracts/ConfigTypes.js";
+import { ConfigFileRepository } from "../files/ConfigFileRepository.js";
+import { ConfigPathResolver } from "../files/ConfigPathResolver.js";
+//#region src/core/ConfigLayerBuilder.d.ts
+declare class ConfigLayerBuilder {
+  private readonly pathResolver;
+  private readonly repository;
+  constructor(pathResolver?: ConfigPathResolver, repository?: ConfigFileRepository);
+  build(cwd: string): ConfigLayerBuildResult;
+  private readValues;
+}
+//#endregion
+export { ConfigLayerBuilder };

package/dist/types/uapkg-config/core/ConfigResolver.d.ts

@@ -0,0 +1,19 @@
+import { ConfigLayer, ConfigResolvedResult, ConfigTraceEntry, ConfigValueWithOrigin } from "../contracts/ConfigTypes.js";
+import { ConfigMerger } from "../merge/ConfigMerger.js";
+import { ConfigSemanticValidator } from "./ConfigSemanticValidator.js";
+import { Diagnostic } from "../../uapkg-diagnostics/index.js";
+//#region src/core/ConfigResolver.d.ts
+declare class ConfigResolver {
+  private readonly merger;
+  private readonly semanticValidator;
+  constructor(merger?: ConfigMerger, semanticValidator?: ConfigSemanticValidator);
+  resolveAll(layers: ConfigLayer[]): ConfigResolvedResult;
+  resolvePath(layers: ConfigLayer[], pathToProperty: string): {
+    value: unknown;
+    diagnostics: readonly Diagnostic[];
+  };
+  getWithOrigin(layers: ConfigLayer[], pathToProperty: string): ConfigValueWithOrigin;
+  trace(layers: ConfigLayer[], pathToProperty: string): ConfigTraceEntry[];
+}
+//#endregion
+export { ConfigResolver };

package/dist/types/uapkg-config/core/ConfigSemanticValidator.d.ts

@@ -0,0 +1,13 @@
+import { Diagnostic } from "../../uapkg-diagnostics/index.js";
+//#region src/core/ConfigSemanticValidator.d.ts
+/**
+ * Runs post-merge semantic checks and narrow-rule validation.
+ */
+declare class ConfigSemanticValidator {
+  validate(merged: Record<string, unknown>): readonly Diagnostic[];
+  private validateCrossFieldRules;
+  private validateNarrowSchemaRules;
+  private isRecord;
+}
+//#endregion
+export { ConfigSemanticValidator };

package/dist/types/uapkg-config/core/ConfigWriter.d.ts

@@ -0,0 +1,25 @@
+import { ConfigGetOptions, ConfigListOptions, ConfigScope, ConfigWriteOptions } from "../contracts/ConfigTypes.js";
+import { ConfigFileRepository } from "../files/ConfigFileRepository.js";
+import { ConfigPathResolver } from "../files/ConfigPathResolver.js";
+import { Result } from "../../uapkg-diagnostics/index.js";
+//#region src/core/ConfigWriter.d.ts
+declare class ConfigWriter {
+  private readonly pathResolver;
+  private readonly repository;
+  constructor(pathResolver?: ConfigPathResolver, repository?: ConfigFileRepository);
+  getRaw(cwd: string, options?: ConfigGetOptions): Result<Record<string, unknown> | null>;
+  listRaw(cwd: string, options?: ConfigListOptions): Result<Record<string, unknown> | null>;
+  prepareSet(cwd: string, pathToProperty: string, value: unknown, options?: ConfigWriteOptions): Result<{
+    file: string;
+    values: Record<string, unknown>;
+  }>;
+  prepareDelete(cwd: string, pathToProperty: string, options?: ConfigWriteOptions): Result<{
+    file: string;
+    values: Record<string, unknown>;
+  }>;
+  getEditTarget(cwd: string, scope?: ConfigScope): string;
+  private resolveWriteTarget;
+  toDisplayPath(cwd: string, filePath: string): string;
+}
+//#endregion
+export { ConfigWriter };

package/dist/types/uapkg-config/core/PostInstallPolicyResolver.d.ts

@@ -0,0 +1,22 @@
+import { PostInstallPolicyValue, ResolvedConfig } from "../schema/configSchema.js";
+import "../contracts/ConfigTypes.js";
+//#region src/core/PostInstallPolicyResolver.d.ts
+/**
+ * Resolves the effective `PostInstallPolicy` for a given install action.
+ *
+ * Resolution order (nearest wins):
+ *   1. `registries.<registryName>.postInstallPolicy` (if defined)
+ *   2. `install.postInstallPolicy` (global default, which itself defaults to `deny`)
+ *
+ * Whichever level provided the value is reported via `resolvedFrom` so that
+ * consumers (e.g. `POSTINSTALL_POLICY_DENIED` diagnostics) can point the user
+ * at the correct config key.
+ */
+declare class PostInstallPolicyResolver {
+  resolve(config: ResolvedConfig, registryName: string): {
+    policy: PostInstallPolicyValue;
+    resolvedFrom: 'registry' | 'install';
+  };
+}
+//#endregion
+export { PostInstallPolicyResolver };

package/dist/types/uapkg-config/factory/createConfig.d.ts

@@ -0,0 +1,6 @@
+import { ConfigCreateOptions } from "../contracts/ConfigTypes.js";
+import { ConfigInstance } from "../core/ConfigInstance.js";
+//#region src/factory/createConfig.d.ts
+declare function createConfig(options?: ConfigCreateOptions): ConfigInstance;
+//#endregion
+export { createConfig };

package/dist/types/uapkg-config/files/ConfigFileRepository.d.ts

@@ -0,0 +1,11 @@
+import { ConfigReadResult } from "../contracts/ConfigTypes.js";
+import { Result } from "../../uapkg-diagnostics/index.js";
+//#region src/files/ConfigFileRepository.d.ts
+declare class ConfigFileRepository {
+  read(filePath: string): Result<ConfigReadResult>;
+  write(filePath: string, values: Record<string, unknown>): Result<void>;
+  private isRecord;
+  private describeType;
+}
+//#endregion
+export { ConfigFileRepository };

package/dist/types/uapkg-config/files/ConfigPathResolver.d.ts

@@ -0,0 +1,14 @@
+import { ConfigPaths } from "../contracts/ConfigTypes.js";
+//#region src/files/ConfigPathResolver.d.ts
+declare class ConfigPathResolver {
+  private readonly profileRoot;
+  constructor(profileRoot?: string);
+  resolve(cwd: string): ConfigPaths;
+  private findManifestRoot;
+  private findIntermediaryFiles;
+  findNearestLocalConfig(cwd: string): string | null;
+  resolveLocalWriteTarget(cwd: string): string;
+  isInProject(cwd: string): boolean;
+}
+//#endregion
+export { ConfigPathResolver };

package/dist/types/uapkg-config/index.d.ts

@@ -0,0 +1,127 @@
+import { PostInstallPolicyValue, RegistryConfig, RegistryRef, ResolvedConfig } from "./schema/configSchema.js";
+import { ConfigCreateOptions, ConfigTraceEntry, ConfigValueWithOrigin } from "./contracts/ConfigTypes.js";
+import { ConfigInstance } from "./core/ConfigInstance.js";
+import { PostInstallPolicyResolver } from "./core/PostInstallPolicyResolver.js";
+import { createConfig } from "./factory/createConfig.js";
+import { getConfigSchemaAtPath, isLeafConfigPath, isValidConfigPath, validateConfigPath } from "./schema/pathSchema.js";
+import { parseConfigCliValue } from "./schema/runtime/ConfigSchemaRuntimeProvider.js";
+//#region src/index.d.ts
+declare const Config: {
+  get(pathToProperty?: string, options?: {
+    scope?: 'global' | 'local';
+  }): unknown;
+  getAll(options?: {
+    scope?: 'global' | 'local';
+  }): Record<string, unknown> | {
+    registry: string;
+    registries: Record<string, {
+      url: string;
+      ref: {
+        type: "branch" | "rev" | "tag";
+        value: string;
+      };
+      ttlSeconds?: number | undefined;
+      postInstallPolicy?: "allow" | "deny" | undefined;
+    }>;
+    launcher: {
+      cliSource: "github-releases" | "npm";
+      defaultCliVersion?: (string & import("zod").$brand<"PackageVersion">) | undefined;
+    };
+    git: string;
+    editor: string;
+    exec: {
+      shell: string;
+    };
+    cache: {
+      enabled: boolean;
+    };
+    registryCache: {
+      ttlSeconds: number;
+    };
+    network: {
+      retries: number;
+      timeout: number;
+      maxConcurrentDownloads: number;
+    };
+    install: {
+      postInstallPolicy: "allow" | "deny";
+    };
+    term: {
+      quiet: boolean;
+      verbose: boolean;
+    };
+  } | null;
+  getDefaultRegistry(): {
+    url: string;
+    ref: {
+      type: string;
+      value: string;
+    };
+  } | null;
+  getWithOrigin(pathToProperty: string): ConfigValueWithOrigin | null;
+  trace(pathToProperty: string): ConfigTraceEntry[];
+  getDiagnostics(): readonly import("../uapkg-diagnostics/index.js").Diagnostic[];
+  reload(options?: {
+    cwd?: string;
+  }): {
+    get(pathToProperty?: string, options?: {
+      scope?: 'global' | 'local';
+    }): unknown;
+    getAll(options?: {
+      scope?: 'global' | 'local';
+    }): Record<string, unknown> | {
+      registry: string;
+      registries: Record<string, {
+        url: string;
+        ref: {
+          type: "branch" | "rev" | "tag";
+          value: string;
+        };
+        ttlSeconds?: number | undefined;
+        postInstallPolicy?: "allow" | "deny" | undefined;
+      }>;
+      launcher: {
+        cliSource: "github-releases" | "npm";
+        defaultCliVersion?: (string & import("zod").$brand<"PackageVersion">) | undefined;
+      };
+      git: string;
+      editor: string;
+      exec: {
+        shell: string;
+      };
+      cache: {
+        enabled: boolean;
+      };
+      registryCache: {
+        ttlSeconds: number;
+      };
+      network: {
+        retries: number;
+        timeout: number;
+        maxConcurrentDownloads: number;
+      };
+      install: {
+        postInstallPolicy: "allow" | "deny";
+      };
+      term: {
+        quiet: boolean;
+        verbose: boolean;
+      };
+    } | null;
+    getDefaultRegistry(): {
+      url: string;
+      ref: {
+        type: string;
+        value: string;
+      };
+    } | null;
+    getWithOrigin(pathToProperty: string): ConfigValueWithOrigin | null;
+    trace(pathToProperty: string): ConfigTraceEntry[];
+    getDiagnostics(): readonly import("../uapkg-diagnostics/index.js").Diagnostic[];
+    reload(options?: {
+      cwd?: string;
+    }): /*elided*/ any;
+  };
+};
+//#endregion
+export { type ConfigCreateOptions, ConfigInstance, type ConfigTraceEntry, type ConfigValueWithOrigin, PostInstallPolicyResolver, type PostInstallPolicyValue, type RegistryConfig, type RegistryRef, type ResolvedConfig, createConfig, Config as default, getConfigSchemaAtPath, isLeafConfigPath, isValidConfigPath, parseConfigCliValue, validateConfigPath };

package/dist/types/uapkg-config/merge/ConfigMerger.d.ts

@@ -0,0 +1,10 @@
+import { ConfigLayer, ConfigResolvedResult } from "../contracts/ConfigTypes.js";
+import { ConfigSchemaMergeEngine } from "./ConfigSchemaMergeEngine.js";
+//#region src/merge/ConfigMerger.d.ts
+declare class ConfigMerger {
+  private readonly engine;
+  constructor(engine?: ConfigSchemaMergeEngine);
+  mergeLayers(layers: readonly ConfigLayer[]): ConfigResolvedResult;
+}
+//#endregion
+export { ConfigMerger };

package/dist/types/uapkg-config/merge/ConfigSchemaMergeEngine.d.ts

@@ -0,0 +1,26 @@
+import { ConfigLayer, ConfigResolvedResult } from "../contracts/ConfigTypes.js";
+import { ZodType } from "zod";
+//#region src/merge/ConfigSchemaMergeEngine.d.ts
+/**
+ * Generic schema-driven config merge engine.
+ *
+ * - Object/record container mismatches are ignored with diagnostics.
+ * - Primitive broad-type mismatches are ignored with diagnostics.
+ * - Narrow rule violations (enum/min/etc) are preserved and diagnosed later by
+ *   semantic validation.
+ */
+declare class ConfigSchemaMergeEngine {
+  private readonly rootSchema;
+  constructor(rootSchema: ZodType);
+  mergeLayers(layers: readonly ConfigLayer[]): ConfigResolvedResult;
+  private mergeNode;
+  private mergeObjectNode;
+  private mergeRecordNode;
+  private mergeScalarNode;
+  private isBroadTypeCompatible;
+  private addTypeMismatch;
+  private pathOf;
+  private asRecord;
+}
+//#endregion
+export { ConfigSchemaMergeEngine };

package/dist/types/uapkg-config/schema/configSchema.d.ts

@@ -0,0 +1,114 @@
+import { z } from "zod";
+//#region src/schema/configSchema.d.ts
+declare const configSchema: z.ZodObject<{
+  registry: z.ZodString;
+  registries: z.ZodRecord<z.ZodString, z.ZodObject<{
+    url: z.ZodPipe<z.core.$ZodBranded<z.ZodString, "RegistryURL", "out">, z.ZodTransform<string, string & z.$brand<"RegistryURL">>>;
+    ref: z.ZodDefault<z.ZodObject<{
+      type: z.ZodEnum<{
+        branch: "branch";
+        rev: "rev";
+        tag: "tag";
+      }>;
+      value: z.ZodString;
+    }, z.core.$strict>>;
+    ttlSeconds: z.ZodOptional<z.ZodNumber>;
+    postInstallPolicy: z.ZodOptional<z.ZodEnum<{
+      allow: "allow";
+      deny: "deny";
+    }>>;
+  }, z.core.$strict>>;
+  launcher: z.ZodObject<{
+    cliSource: z.ZodEnum<{
+      "github-releases": "github-releases";
+      npm: "npm";
+    }>;
+    defaultCliVersion: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "PackageVersion", "out">>;
+  }, z.core.$strict>;
+  git: z.ZodString;
+  editor: z.ZodString;
+  exec: z.ZodObject<{
+    shell: z.ZodString;
+  }, z.core.$strict>;
+  cache: z.ZodObject<{
+    enabled: z.ZodBoolean;
+  }, z.core.$strict>;
+  registryCache: z.ZodObject<{
+    ttlSeconds: z.ZodNumber;
+  }, z.core.$strict>;
+  network: z.ZodObject<{
+    retries: z.ZodNumber;
+    timeout: z.ZodNumber;
+    maxConcurrentDownloads: z.ZodNumber;
+  }, z.core.$strict>;
+  install: z.ZodObject<{
+    postInstallPolicy: z.ZodEnum<{
+      allow: "allow";
+      deny: "deny";
+    }>;
+  }, z.core.$strict>;
+  term: z.ZodObject<{
+    quiet: z.ZodBoolean;
+    verbose: z.ZodBoolean;
+  }, z.core.$strict>;
+}, z.core.$strict>;
+declare const partialConfigSchema: z.ZodObject<{
+  registry: z.ZodOptional<z.ZodString>;
+  registries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    url: z.ZodOptional<z.ZodPipe<z.core.$ZodBranded<z.ZodString, "RegistryURL", "out">, z.ZodTransform<string, string & z.$brand<"RegistryURL">>>>;
+    ref: z.ZodOptional<z.ZodObject<{
+      type: z.ZodOptional<z.ZodEnum<{
+        branch: "branch";
+        rev: "rev";
+        tag: "tag";
+      }>>;
+      value: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    ttlSeconds: z.ZodOptional<z.ZodNumber>;
+    postInstallPolicy: z.ZodOptional<z.ZodEnum<{
+      allow: "allow";
+      deny: "deny";
+    }>>;
+  }, z.core.$strict>>>;
+  launcher: z.ZodOptional<z.ZodObject<{
+    cliSource: z.ZodOptional<z.ZodEnum<{
+      "github-releases": "github-releases";
+      npm: "npm";
+    }>>;
+    defaultCliVersion: z.ZodOptional<z.ZodOptional<z.core.$ZodBranded<z.ZodString, "PackageVersion", "out">>>;
+  }, z.core.$strict>>;
+  git: z.ZodOptional<z.ZodString>;
+  editor: z.ZodOptional<z.ZodString>;
+  exec: z.ZodOptional<z.ZodObject<{
+    shell: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  cache: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>>;
+  registryCache: z.ZodOptional<z.ZodObject<{
+    ttlSeconds: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>>;
+  network: z.ZodOptional<z.ZodObject<{
+    retries: z.ZodOptional<z.ZodNumber>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    maxConcurrentDownloads: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strict>>;
+  install: z.ZodOptional<z.ZodObject<{
+    postInstallPolicy: z.ZodOptional<z.ZodEnum<{
+      allow: "allow";
+      deny: "deny";
+    }>>;
+  }, z.core.$strict>>;
+  term: z.ZodOptional<z.ZodObject<{
+    quiet: z.ZodOptional<z.ZodBoolean>;
+    verbose: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type ResolvedConfig = z.infer<typeof configSchema>;
+type PartialConfig = z.infer<typeof partialConfigSchema>;
+type RegistryConfig = ResolvedConfig['registries'][string];
+type RegistryRef = RegistryConfig['ref'];
+type PostInstallPolicyValue = ResolvedConfig['install']['postInstallPolicy'];
+declare function getDefaultConfig(): ResolvedConfig;
+//#endregion
+export { PartialConfig, PostInstallPolicyValue, RegistryConfig, RegistryRef, ResolvedConfig, configSchema, getDefaultConfig, partialConfigSchema };