@uapkg/cli 1.4.0 → 1.5.0

package/dist/types/uapkg-package-manifest/core/DevDependencyPolicy.d.ts

@@ -0,0 +1,30 @@
+import { Dependency, Manifest } from "../../uapkg-package-manifest-schema/index.js";
+//#region src/core/DevDependencyPolicy.d.ts
+/**
+ * Policy codifying the uapkg rule:
+ *
+ *   `devDependencies` only apply when the manifest is the **root** of the
+ *   dependency graph under development (the project manifest, or a plugin
+ *   manifest that the developer is currently building locally).
+ *
+ * Transitive `devDependencies` of installed packages are never resolved or
+ * installed. This mirrors npm and cargo.
+ */
+declare class DevDependencyPolicy {
+  /**
+   * @param manifest The manifest being walked.
+   * @param isRoot True only for the very top of the walk (the manifest the
+   *   user invoked the command from).
+   * @returns The set of dependency buckets to walk for this node.
+   */
+  pickBuckets(manifest: Manifest, isRoot: boolean): Array<{
+    bucket: 'dependencies' | 'devDependencies' | 'peerDependencies';
+    map: Record<string, Dependency>;
+  }>;
+  /**
+   * Should a transitive child's `devDependencies` be walked? Always false.
+   */
+  includeTransitiveDev(): boolean;
+}
+//#endregion
+export { DevDependencyPolicy };

package/dist/types/uapkg-package-manifest/core/InstallPathResolver.d.ts

@@ -0,0 +1,35 @@
+import { Dependency, Manifest } from "../../uapkg-package-manifest-schema/index.js";
+import { DiagnosticBag } from "../../uapkg-diagnostics/index.js";
+import { InstallPath, PackageName } from "../../uapkg-common-schema/index.js";
+//#region src/core/InstallPathResolver.d.ts
+/**
+ * Result of resolving the final install path for a single dependency.
+ */
+interface ResolvedInstallPath {
+  readonly name: PackageName;
+  readonly path: InstallPath;
+  /** True when the dependency's declared `path` override was ignored. */
+  readonly overridden: boolean;
+}
+/**
+ * Decides where each dependency is installed, relative to the manifest root.
+ *
+ * Rules:
+ *  - A dependency's `path` override is honored **only** on project-kind manifests.
+ *  - On plugin-kind manifests, any declared `path` is ignored and a
+ *    `SAFETY_PATH_NOT_PROJECT_MANIFEST` warning is emitted. The default
+ *    `Plugins/<name>` location is used.
+ *  - Absent overrides, every dependency installs to `Plugins/<name>`.
+ */
+declare class InstallPathResolver {
+  /**
+   * Resolve the install path for a single dependency.
+   *
+   * Writes at most one warning to `bag`.
+   */
+  resolve(manifest: Manifest, depName: string, dep: Dependency, bag: DiagnosticBag): ResolvedInstallPath;
+  /** Default install location: `Plugins/<name>`. */
+  defaultPathFor(depName: string): InstallPath;
+}
+//#endregion
+export { InstallPathResolver, ResolvedInstallPath };

package/dist/types/uapkg-package-manifest/core/LockfileDiffer.d.ts

@@ -0,0 +1,40 @@
+import { LockDependency, Lockfile } from "../../uapkg-package-manifest-schema/index.js";
+import { PackageName } from "../../uapkg-common-schema/index.js";
+//#region src/core/LockfileDiffer.d.ts
+/**
+ * A change to a single package between two lockfile snapshots.
+ */
+interface LockfileChange {
+  readonly name: PackageName;
+  readonly previous?: LockDependency;
+  readonly current?: LockDependency;
+}
+/**
+ * Full diff between a previous and a current lockfile.
+ */
+interface LockfileDiff {
+  readonly added: readonly LockfileChange[];
+  readonly updated: readonly LockfileChange[];
+  readonly removed: readonly LockfileChange[];
+  readonly unchanged: readonly LockfileChange[];
+  readonly summary: {
+    readonly added: number;
+    readonly updated: number;
+    readonly removed: number;
+    readonly unchanged: number;
+  };
+}
+/**
+ * Pure diff of two lockfiles keyed by package name.
+ *
+ * Two entries are considered "unchanged" iff their
+ *   (version, registry, integrity, gitTree, dependencies)
+ * tuples are identical. Any other difference produces an "updated" record.
+ */
+declare class LockfileDiffer {
+  diff(previous: Lockfile | null, current: Lockfile): LockfileDiff;
+  private isSameEntry;
+  private isSameChildMap;
+}
+//#endregion
+export { LockfileChange, LockfileDiff, LockfileDiffer };

package/dist/types/uapkg-package-manifest/core/LockfileSyncIssue.d.ts

@@ -0,0 +1,11 @@
+//#region src/core/LockfileSyncIssue.d.ts
+type LockfileSyncIssueSeverity = 'error' | 'warning' | 'info';
+interface LockfileSyncIssue {
+  readonly severity: LockfileSyncIssueSeverity;
+  readonly code: string;
+  readonly message: string;
+  readonly packageName?: string;
+}
+declare function sortLockfileSyncIssues(issues: readonly LockfileSyncIssue[]): LockfileSyncIssue[];
+//#endregion
+export { LockfileSyncIssue, LockfileSyncIssueSeverity, sortLockfileSyncIssues };

package/dist/types/uapkg-package-manifest/core/LockfileSyncValidator.d.ts

@@ -0,0 +1,26 @@
+import { LockfileDiffer } from "./LockfileDiffer.js";
+import { LockfileSyncIssue } from "./LockfileSyncIssue.js";
+import { LockfileSync } from "../resolver/LockfileSync.js";
+import { Resolver } from "../resolver/Resolver.js";
+import { Lockfile, Manifest } from "../../uapkg-package-manifest-schema/index.js";
+import { RegistryCore } from "../../uapkg-registry-core/index.js";
+import { ConfigInstance } from "../../uapkg-config/index.js";
+//#region src/core/LockfileSyncValidator.d.ts
+/**
+ * Validates whether a lockfile is still in sync with manifest + registry state.
+ */
+declare class LockfileSyncValidator {
+  private readonly registryCore;
+  private readonly resolver;
+  private readonly lockSync;
+  private readonly differ;
+  private readonly config?;
+  constructor(registryCore: RegistryCore, resolver: Resolver, lockSync: LockfileSync, differ: LockfileDiffer, config?: InstanceType<typeof ConfigInstance> | undefined);
+  collectIssues(manifest: Manifest, lockfile: Lockfile): Promise<LockfileSyncIssue[]>;
+  topIssues(issues: readonly LockfileSyncIssue[], count: number): readonly LockfileSyncIssue[];
+  private collectDeclaredDependencies;
+  private collectLockfileRegistries;
+  private collectConfiguredRegistries;
+}
+//#endregion
+export { LockfileSyncValidator };

package/dist/types/uapkg-package-manifest/core/OutdatedChecker.d.ts

@@ -0,0 +1,36 @@
+import { Lockfile, Manifest } from "../../uapkg-package-manifest-schema/index.js";
+import { Result } from "../../uapkg-diagnostics/index.js";
+import { PackageName, PackageVersion, RegistryName } from "../../uapkg-common-schema/index.js";
+import { RegistryCore } from "../../uapkg-registry-core/index.js";
+//#region src/core/OutdatedChecker.d.ts
+/**
+ * Classification for a package in the `outdated` table.
+ */
+type OutdatedStatus = 'up-to-date' | 'outdated-range' | 'outdated-latest' | 'pinned';
+/**
+ * One row in the `uapkg outdated` report.
+ */
+interface OutdatedEntry {
+  readonly name: PackageName;
+  readonly current: PackageVersion;
+  readonly wanted: PackageVersion;
+  readonly latest: PackageVersion;
+  readonly registry: RegistryName;
+  readonly status: OutdatedStatus;
+}
+/**
+ * Compute per-dependency outdated information.
+ *
+ * - `wanted`  is the best version that satisfies the manifest's declared range.
+ * - `latest`  is the absolute highest version in the registry, honoring the
+ *             npm-style prerelease rules from {@link SemverSelectionPolicy}.
+ */
+declare class OutdatedChecker {
+  private readonly registryCore;
+  private readonly policy;
+  constructor(registryCore: RegistryCore);
+  check(manifest: Manifest, lockfile: Lockfile): Promise<Result<OutdatedEntry[]>>;
+  private classify;
+}
+//#endregion
+export { OutdatedChecker, OutdatedEntry, OutdatedStatus };

package/dist/types/uapkg-package-manifest/core/PackageManifest.d.ts

@@ -0,0 +1,63 @@
+import { ResolvedGraph, ResolverOptions } from "../contracts/ManifestTypes.js";
+import { AddDependencyOptions } from "./DependencyMutator.js";
+import { LockfileDiff } from "./LockfileDiffer.js";
+import { OutdatedEntry } from "./OutdatedChecker.js";
+import { WhyResult } from "./WhyGraph.js";
+import { Dependency, Lockfile, Manifest } from "../../uapkg-package-manifest-schema/index.js";
+import { Result } from "../../uapkg-diagnostics/index.js";
+import { PackageName } from "../../uapkg-common-schema/index.js";
+import { RegistryCore } from "../../uapkg-registry-core/index.js";
+import { ConfigInstance } from "../../uapkg-config/index.js";
+//#region src/core/PackageManifest.d.ts
+interface PackageManifestOptions {
+  /** Absolute path to the directory containing `uapkg.json`. */
+  readonly manifestRoot: string;
+  /** The `RegistryCore` instance to use for registry operations. */
+  readonly registryCore: RegistryCore;
+  /** Optional `@uapkg/config` instance to share state. */
+  readonly configInstance?: InstanceType<typeof ConfigInstance>;
+}
+/**
+ * High-level facade for working with `uapkg.json` and `uapkg.lock`.
+ *
+ * All operations execute relative to `manifestRoot`. Composes small,
+ * single-responsibility collaborators (reader/writer, resolver, mutator,
+ * differ, outdated-checker, why-graph). Never throws — all fallible paths
+ * return a `Result<T>` carrying diagnostics.
+ */
+declare class PackageManifest {
+  private readonly manifestRoot;
+  private readonly registryCore;
+  private readonly reader;
+  private readonly writer;
+  private readonly lockReader;
+  private readonly lockWriter;
+  private readonly resolver;
+  private readonly lockSync;
+  private readonly mutator;
+  private readonly differ;
+  private readonly lockfileSyncValidator;
+  private readonly lockfileSyncIssueWriter;
+  private readonly outdated;
+  private readonly whyGraph;
+  constructor(options: PackageManifestOptions);
+  readManifest(): Promise<Result<Manifest>>;
+  writeManifest(manifest: Manifest): Promise<Result<void>>;
+  readLockfile(): Promise<Result<Lockfile>>;
+  readLockfileOptional(): Promise<Result<Lockfile | null>>;
+  writeLockfile(lockfile: Lockfile): Promise<Result<void>>;
+  validate(): Promise<Result<Manifest>>;
+  resolve(options?: ResolverOptions): Promise<Result<ResolvedGraph>>;
+  install(options?: ResolverOptions): Promise<Result<Lockfile>>;
+  /** Add or replace a dependency and persist `uapkg.json`. */
+  addDependency(name: string, dep: Dependency, options?: AddDependencyOptions): Promise<Result<Manifest>>;
+  /** Remove a dependency from every bucket and persist `uapkg.json`. */
+  removeDependency(name: string): Promise<Result<Manifest>>;
+  diffLockfile(previous: Lockfile | null, current: Lockfile): LockfileDiff;
+  checkOutdated(): Promise<Result<OutdatedEntry[]>>;
+  explainWhy(target: PackageName): Promise<Result<WhyResult>>;
+  getLockfileForReadOnly(): Promise<Result<Lockfile>>;
+  validateLockfileSync(lockfile: Lockfile): Promise<Result<void>>;
+}
+//#endregion
+export { PackageManifest, PackageManifestOptions };

package/dist/types/uapkg-package-manifest/core/WhyGraph.d.ts

@@ -0,0 +1,31 @@
+import { ResolvedGraph } from "../contracts/ManifestTypes.js";
+import { PackageName, PackageVersion } from "../../uapkg-common-schema/index.js";
+//#region src/core/WhyGraph.d.ts
+/**
+ * One ancestor chain showing *why* a package is present in the graph.
+ * Ordered root → target.
+ */
+interface WhyPath {
+  readonly path: readonly {
+    readonly name: PackageName;
+    readonly version: PackageVersion;
+  }[];
+}
+/**
+ * Full `uapkg why <name>` result.
+ */
+interface WhyResult {
+  readonly target: PackageName;
+  readonly paths: readonly WhyPath[];
+  readonly foundAsRoot: boolean;
+}
+/**
+ * Walk a resolved dependency graph to enumerate every path from a root node
+ * down to the target package. Pure — no IO, no shared state.
+ */
+declare class WhyGraph {
+  explain(graph: ResolvedGraph, target: PackageName): WhyResult;
+  private walk;
+}
+//#endregion
+export { WhyGraph, WhyPath, WhyResult };

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

@@ -0,0 +1,18 @@
+import { DependencyChangeResult, ManifestOperationOptions, PackageNode, ResolvedGraph, ResolverOptions } from "./contracts/ManifestTypes.js";
+import { AddDependencyOptions, DependencyBucket, DependencyMutator, RemoveDependencyResult } from "./core/DependencyMutator.js";
+import { DevDependencyPolicy } from "./core/DevDependencyPolicy.js";
+import { InstallPathResolver, ResolvedInstallPath } from "./core/InstallPathResolver.js";
+import { LockfileChange, LockfileDiff, LockfileDiffer } from "./core/LockfileDiffer.js";
+import { LockfileSyncIssue, LockfileSyncIssueSeverity, sortLockfileSyncIssues } from "./core/LockfileSyncIssue.js";
+import { LockfileSync } from "./resolver/LockfileSync.js";
+import { Resolver } from "./resolver/Resolver.js";
+import { LockfileSyncValidator } from "./core/LockfileSyncValidator.js";
+import { OutdatedChecker, OutdatedEntry, OutdatedStatus } from "./core/OutdatedChecker.js";
+import { WhyGraph, WhyPath, WhyResult } from "./core/WhyGraph.js";
+import { PackageManifest, PackageManifestOptions } from "./core/PackageManifest.js";
+import { LockfileReader } from "./io/LockfileReader.js";
+import { LockfileSyncIssueWriter } from "./io/LockfileSyncIssueWriter.js";
+import { LockfileWriter } from "./io/LockfileWriter.js";
+import { ManifestReader } from "./io/ManifestReader.js";
+import { ManifestWriter } from "./io/ManifestWriter.js";
+export { type AddDependencyOptions, type DependencyBucket, type DependencyChangeResult, DependencyMutator, DevDependencyPolicy, InstallPathResolver, type LockfileChange, type LockfileDiff, LockfileDiffer, LockfileReader, LockfileSync, type LockfileSyncIssue, type LockfileSyncIssueSeverity, LockfileSyncIssueWriter, LockfileSyncValidator, LockfileWriter, type ManifestOperationOptions, ManifestReader, ManifestWriter, OutdatedChecker, type OutdatedEntry, type OutdatedStatus, PackageManifest, type PackageManifestOptions, type PackageNode, type RemoveDependencyResult, type ResolvedGraph, type ResolvedInstallPath, Resolver, type ResolverOptions, WhyGraph, type WhyPath, type WhyResult, sortLockfileSyncIssues };

package/dist/types/uapkg-package-manifest/io/LockfileReader.d.ts

@@ -0,0 +1,12 @@
+import { Lockfile } from "../../uapkg-package-manifest-schema/index.js";
+import { Result } from "../../uapkg-diagnostics/index.js";
+//#region src/io/LockfileReader.d.ts
+/**
+ * Reads and validates `uapkg.lock` from a given root directory.
+ */
+declare class LockfileReader {
+  readOptional(manifestRoot: string): Promise<Result<Lockfile | null>>;
+  readRequired(manifestRoot: string): Promise<Result<Lockfile>>;
+}
+//#endregion
+export { LockfileReader };

package/dist/types/uapkg-package-manifest/io/LockfileSyncIssueWriter.d.ts

@@ -0,0 +1,12 @@
+import { LockfileSyncIssue } from "../core/LockfileSyncIssue.js";
+import { Result } from "../../uapkg-diagnostics/index.js";
+//#region src/io/LockfileSyncIssueWriter.d.ts
+/**
+ * Persists detailed lockfile sync issues to disk for large diagnostic sets.
+ */
+declare class LockfileSyncIssueWriter {
+  write(manifestRoot: string, issues: readonly LockfileSyncIssue[]): Promise<Result<string>>;
+  private resolveLogPath;
+}
+//#endregion
+export { LockfileSyncIssueWriter };

package/dist/types/uapkg-package-manifest/io/LockfileWriter.d.ts

@@ -0,0 +1,11 @@
+import { Lockfile } from "../../uapkg-package-manifest-schema/index.js";
+import { Result } from "../../uapkg-diagnostics/index.js";
+//#region src/io/LockfileWriter.d.ts
+/**
+ * Writes `uapkg.lock` to a given root directory.
+ */
+declare class LockfileWriter {
+  write(manifestRoot: string, lockfile: Lockfile): Promise<Result<void>>;
+}
+//#endregion
+export { LockfileWriter };

package/dist/types/uapkg-package-manifest/io/ManifestReader.d.ts

@@ -0,0 +1,12 @@
+import { Manifest } from "../../uapkg-package-manifest-schema/index.js";
+import { Result } from "../../uapkg-diagnostics/index.js";
+//#region src/io/ManifestReader.d.ts
+/**
+ * Reads and validates `uapkg.json` from a given root directory.
+ */
+declare class ManifestReader {
+  /** Read and parse the manifest. */
+  read(manifestRoot: string): Promise<Result<Manifest>>;
+}
+//#endregion
+export { ManifestReader };

package/dist/types/uapkg-package-manifest/io/ManifestWriter.d.ts

@@ -0,0 +1,13 @@
+import { Manifest } from "../../uapkg-package-manifest-schema/index.js";
+import { Result } from "../../uapkg-diagnostics/index.js";
+//#region src/io/ManifestWriter.d.ts
+/**
+ * Writes `uapkg.json` to a given root directory.
+ */
+declare class ManifestWriter {
+  /** Serialize and write the manifest. */
+  write(manifestRoot: string, manifest: Manifest): Promise<Result<void>>;
+  private toSerializableManifest;
+}
+//#endregion
+export { ManifestWriter };

package/dist/types/uapkg-package-manifest/resolver/LockfileSync.d.ts

@@ -0,0 +1,13 @@
+import { ResolvedGraph } from "../contracts/ManifestTypes.js";
+import { Lockfile } from "../../uapkg-package-manifest-schema/index.js";
+//#region src/resolver/LockfileSync.d.ts
+/**
+ * Produces a `Lockfile` from a resolved dependency graph.
+ */
+declare class LockfileSync {
+  /** Build a lockfile from the resolved graph. */
+  buildLockfile(graph: ResolvedGraph): Lockfile;
+  private nodeToLockEntry;
+}
+//#endregion
+export { LockfileSync };

package/dist/types/uapkg-package-manifest/resolver/Resolver.d.ts

@@ -0,0 +1,16 @@
+import { ResolvedGraph, ResolverOptions } from "../contracts/ManifestTypes.js";
+import { Manifest } from "../../uapkg-package-manifest-schema/index.js";
+import { Result } from "../../uapkg-diagnostics/index.js";
+import { RegistryCore } from "../../uapkg-registry-core/index.js";
+//#region src/resolver/Resolver.d.ts
+declare class Resolver {
+  private readonly registryCore;
+  private readonly devPolicy;
+  constructor(registryCore: RegistryCore);
+  resolve(manifest: Manifest, options?: ResolverOptions): Promise<Result<ResolvedGraph>>;
+  private resolveNode;
+  private applyOverrides;
+  private checkNameCollisions;
+}
+//#endregion
+export { Resolver };

package/dist/types/uapkg-package-manifest-schema/index.d.ts

@@ -0,0 +1,10 @@
+import { LockDependency, LockDependencySchema } from "./lockfile/LockDependencySchema.js";
+import { Lockfile, LockfileSchema } from "./lockfile/LockfileSchema.js";
+import { Dependency, DependencyDeclaration, DependencyDeclarationSchema, DependencyLongSchema, DependencySchema, DependencyShortSchema, normalizeDependencyDeclaration, normalizeDependencyRecord, toDependencyDeclaration, toDependencyRecordDeclaration } from "./manifest/DependencySchema.js";
+import { BaseManifest, BaseManifestSchema } from "./manifest/BaseManifestSchema.js";
+import { ManifestKind, ManifestKindSchema } from "./manifest/ManifestKind.js";
+import { Manifest, ManifestSchema } from "./manifest/ManifestSchema.js";
+import { PluginManifest, PluginManifestSchema } from "./manifest/PluginManifestSchema.js";
+import { ProjectManifest, ProjectManifestSchema, ProjectPostinstall, ProjectPostinstallSchema } from "./manifest/ProjectManifestSchema.js";
+import { Publish, PublishSchema } from "./manifest/PublishSchema.js";
+export { type BaseManifest, BaseManifestSchema, type Dependency, type DependencyDeclaration, DependencyDeclarationSchema, DependencyLongSchema, DependencySchema, DependencyShortSchema, type LockDependency, LockDependencySchema, type Lockfile, LockfileSchema, type Manifest, type ManifestKind, ManifestKindSchema, ManifestSchema, type PluginManifest, PluginManifestSchema, type ProjectManifest, ProjectManifestSchema, type ProjectPostinstall, ProjectPostinstallSchema, type Publish, PublishSchema, normalizeDependencyDeclaration, normalizeDependencyRecord, toDependencyDeclaration, toDependencyRecordDeclaration };

package/dist/types/uapkg-package-manifest-schema/lockfile/LockDependencySchema.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+//#region src/lockfile/LockDependencySchema.d.ts
+/**
+ * A locked (resolved) dependency entry in `uapkg.lock`.
+ */
+declare const LockDependencySchema: z.ZodObject<{
+  version: z.core.$ZodBranded<z.ZodString, "PackageVersion", "out">;
+  registry: z.core.$ZodBranded<z.ZodString, "RegistryName", "out">;
+  integrity: z.core.$ZodBranded<z.ZodString, "AssetHash", "out">;
+  gitTree: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "GitTree", "out">>;
+  dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+type LockDependency = z.infer<typeof LockDependencySchema>;
+//#endregion
+export { LockDependency, LockDependencySchema };

package/dist/types/uapkg-package-manifest-schema/lockfile/LockfileSchema.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+//#region src/lockfile/LockfileSchema.d.ts
+/** Lockfile versions this build understands. Unknown versions fail closed. */
+declare const SUPPORTED_LOCKFILE_VERSIONS: readonly [1];
+/**
+ * Schema for `uapkg.lock`. `lockfileVersion` dispatches exact supported
+ * values; an unrecognized version means the lockfile was written by a newer
+ * client and must not be reinterpreted.
+ */
+declare const LockfileSchema: z.ZodObject<{
+  lockfileVersion: z.ZodLiteral<1>;
+  packages: z.ZodRecord<z.core.$ZodBranded<z.ZodString, "PackageName", "out">, z.ZodObject<{
+    version: z.core.$ZodBranded<z.ZodString, "PackageVersion", "out">;
+    registry: z.core.$ZodBranded<z.ZodString, "RegistryName", "out">;
+    integrity: z.core.$ZodBranded<z.ZodString, "AssetHash", "out">;
+    gitTree: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "GitTree", "out">>;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type Lockfile = z.infer<typeof LockfileSchema>;
+//#endregion
+export { Lockfile, LockfileSchema, SUPPORTED_LOCKFILE_VERSIONS };

package/dist/types/uapkg-package-manifest-schema/manifest/BaseManifestSchema.d.ts

@@ -0,0 +1,56 @@
+import { Dependency } from "./DependencySchema.js";
+import { z } from "zod";
+//#region src/manifest/BaseManifestSchema.d.ts
+/**
+ * Fields shared by all manifest kinds.
+ *
+ * Loose: unknown top-level members are preserved so read-modify-write
+ * commands do not strip fields this build does not understand, and newer
+ * optional manifest fields never fail an older client.
+ */
+declare const BaseManifestSchema: z.ZodObject<{
+  name: z.core.$ZodBranded<z.ZodString, "PackageName", "out">;
+  version: z.core.$ZodBranded<z.ZodString, "PackageVersion", "out">;
+  kind: z.ZodEnum<{
+    plugin: "plugin";
+    project: "project";
+  }>;
+  private: z.ZodOptional<z.ZodBoolean>;
+  publish: z.ZodOptional<z.ZodObject<{
+    registry: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RegistryName", "out">>;
+    owner: z.ZodOptional<z.ZodString>;
+    repository: z.ZodOptional<z.ZodString>;
+    asset: z.ZodOptional<z.ZodString>;
+    manifestPath: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "VersionRange", "out">, z.ZodObject<{
+    version: z.core.$ZodBranded<z.ZodString, "VersionRange", "out">;
+    registry: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RegistryName", "out">>;
+    path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InstallPath", "out">>;
+  }, z.core.$strip>]>, z.ZodTransform<Dependency, {
+    version: string & z.$brand<"VersionRange">;
+    registry?: (string & z.$brand<"RegistryName">) | undefined;
+    path?: (string & z.$brand<"InstallPath">) | undefined;
+  } | (string & z.$brand<"VersionRange">)>>>>;
+  devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "VersionRange", "out">, z.ZodObject<{
+    version: z.core.$ZodBranded<z.ZodString, "VersionRange", "out">;
+    registry: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RegistryName", "out">>;
+    path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InstallPath", "out">>;
+  }, z.core.$strip>]>, z.ZodTransform<Dependency, {
+    version: string & z.$brand<"VersionRange">;
+    registry?: (string & z.$brand<"RegistryName">) | undefined;
+    path?: (string & z.$brand<"InstallPath">) | undefined;
+  } | (string & z.$brand<"VersionRange">)>>>>;
+  peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "VersionRange", "out">, z.ZodObject<{
+    version: z.core.$ZodBranded<z.ZodString, "VersionRange", "out">;
+    registry: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RegistryName", "out">>;
+    path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InstallPath", "out">>;
+  }, z.core.$strip>]>, z.ZodTransform<Dependency, {
+    version: string & z.$brand<"VersionRange">;
+    registry?: (string & z.$brand<"RegistryName">) | undefined;
+    path?: (string & z.$brand<"InstallPath">) | undefined;
+  } | (string & z.$brand<"VersionRange">)>>>>;
+}, z.core.$loose>;
+type BaseManifest = z.infer<typeof BaseManifestSchema>;
+//#endregion
+export { BaseManifest, BaseManifestSchema };

package/dist/types/uapkg-package-manifest-schema/manifest/DependencySchema.d.ts

@@ -0,0 +1,57 @@
+import { InstallPathSchema, RegistryName, VersionRangeSchema } from "../../uapkg-common-schema/index.js";
+import { z } from "zod";
+//#region src/manifest/DependencySchema.d.ts
+/**
+ * A dependency intent entry in `uapkg.json`.
+ *
+ * - `version`  — semver range (branded)
+ * - `registry` — logical registry name (branded); ABSENT means the dependency
+ *                inherits the containing registry (or the user's configured
+ *                default registry at a project root). An explicit `"default"`
+ *                normalizes to absence.
+ * - `path`     — OPTIONAL install path relative to manifest root.
+ *                Only meaningful on **project** manifests; on plugin manifests
+ *                a warning (`SAFETY_PATH_NOT_PROJECT_MANIFEST`) is emitted by
+ *                the installer and the default path (`Plugins/<name>`) is used.
+ */
+declare const DependencyLongSchema: z.ZodObject<{
+  version: z.core.$ZodBranded<z.ZodString, "VersionRange", "out">;
+  registry: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RegistryName", "out">>;
+  path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InstallPath", "out">>;
+}, z.core.$strip>;
+declare const DependencyShortSchema: z.core.$ZodBranded<z.ZodString, "VersionRange", "out">;
+declare const DependencyDeclarationSchema: z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "VersionRange", "out">, z.ZodObject<{
+  version: z.core.$ZodBranded<z.ZodString, "VersionRange", "out">;
+  registry: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RegistryName", "out">>;
+  path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InstallPath", "out">>;
+}, z.core.$strip>]>;
+type DependencyDeclaration = z.infer<typeof DependencyDeclarationSchema>;
+interface Dependency {
+  readonly version: z.infer<typeof VersionRangeSchema>;
+  /** Absent means inherited/default; only explicit non-default aliases persist. */
+  readonly registry?: RegistryName;
+  readonly path?: z.infer<typeof InstallPathSchema>;
+}
+declare const DependencySchema: z.ZodPipe<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "VersionRange", "out">, z.ZodObject<{
+  version: z.core.$ZodBranded<z.ZodString, "VersionRange", "out">;
+  registry: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "RegistryName", "out">>;
+  path: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "InstallPath", "out">>;
+}, z.core.$strip>]>, z.ZodTransform<Dependency, {
+  version: string & z.$brand<"VersionRange">;
+  registry?: (string & z.$brand<"RegistryName">) | undefined;
+  path?: (string & z.$brand<"InstallPath">) | undefined;
+} | (string & z.$brand<"VersionRange">)>>;
+/**
+ * Convert either dependency declaration style into canonical full form.
+ * An omitted registry and an explicit `"default"` both normalize to absence.
+ */
+declare function normalizeDependencyDeclaration(input: DependencyDeclaration | Dependency): Dependency;
+/**
+ * Convert a canonical dependency into declaration form, preferring short form
+ * when no extra metadata would be lost.
+ */
+declare function toDependencyDeclaration(input: Dependency): DependencyDeclaration;
+declare function normalizeDependencyRecord(input?: Record<string, DependencyDeclaration | Dependency>): Record<string, Dependency> | undefined;
+declare function toDependencyRecordDeclaration(input?: Record<string, Dependency>): Record<string, DependencyDeclaration> | undefined;
+//#endregion
+export { Dependency, DependencyDeclaration, DependencyDeclarationSchema, DependencyLongSchema, DependencySchema, DependencyShortSchema, normalizeDependencyDeclaration, normalizeDependencyRecord, toDependencyDeclaration, toDependencyRecordDeclaration };

package/dist/types/uapkg-package-manifest-schema/manifest/ManifestKind.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+//#region src/manifest/ManifestKind.d.ts
+/**
+ * Manifest kind determines schema-level constraints.
+ *
+ * - `project`  — root project manifest (may have overrides)
+ * - `plugin`   — plugin manifest (must NOT have overrides)
+ *
+ * Future kinds (e.g. `shard`) can be added here.
+ */
+declare const ManifestKindSchema: z.ZodEnum<{
+  plugin: "plugin";
+  project: "project";
+}>;
+type ManifestKind = z.infer<typeof ManifestKindSchema>;
+//#endregion
+export { ManifestKind, ManifestKindSchema };