@soda-gql/common 0.11.10 → 0.11.12

package/dist/{index-D1tzB3W5.d.cts → index-BMa2_rDb.d.mts}

@@ -1,6 +1,6 @@
 //#region packages/common/src/portable/fs.d.ts
 /**
- * Portable filesystem API that works on both Bun and Node.js
+ * Portable filesystem API using Node.js fs
  */
 interface PortableFS {
   readFile(path: string): Promise<string>;
@@ -47,7 +47,7 @@ declare function __resetPortableFSForTests(): void;
 //#endregion
 //#region packages/common/src/portable/hash.d.ts
 /**
- * Portable hashing API that works on both Bun and Node.js
+ * Portable hashing API using Node.js crypto
  */
 type HashAlgorithm = "sha256" | "xxhash";
 interface PortableHasher {
@@ -61,50 +61,21 @@ declare function getPortableHasher(): PortableHasher;
  */
 declare function __resetPortableHasherForTests(): void;
 //#endregion
-//#region packages/common/src/portable/id.d.ts
-/**
- * Portable ID generation that works on both Bun and Node.js
- */
-/**
- * Generate a unique ID
- * Uses UUIDv7 on Bun (monotonic), falls back to randomUUID on Node.js
- */
-declare function generateId(): string;
-//#endregion
 //#region packages/common/src/portable/runtime.d.ts
 /**
  * Runtime detection utilities for portable API implementation
+ * Note: Bun-specific code has been removed. Node.js APIs are always used.
  */
 declare const runtime: {
-  readonly isBun: boolean;
+  readonly isBun: false;
   readonly isNode: boolean;
   readonly supportsWebCrypto: boolean;
 };
-/**
- * Helper to cache module imports to avoid repeated dynamic imports
- */
-declare function once<T>(fn: () => T): () => T;
 /**
  * Reset runtime state for testing purposes only
  * @internal
  */
 declare function resetPortableForTests(): void;
 //#endregion
-//#region packages/common/src/portable/spawn.d.ts
-/**
- * Portable subprocess spawning that works on both Bun and Node.js
- */
-interface SpawnOptions {
-  cmd: string[];
-  cwd?: string;
-  env?: Record<string, string>;
-}
-interface SpawnResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}
-declare function spawn(options: SpawnOptions): Promise<SpawnResult>;
-//#endregion
-export { resetPortableForTests as a, HashAlgorithm as c, createPortableHasher as d, getPortableHasher as f, getPortableFS as g, createPortableFS as h, once as i, PortableHasher as l, __resetPortableFSForTests as m, SpawnResult as n, runtime as o, PortableFS as p, spawn as r, generateId as s, SpawnOptions as t, __resetPortableHasherForTests as u };
-//# sourceMappingURL=index-D1tzB3W5.d.cts.map
+export { __resetPortableHasherForTests as a, PortableFS as c, getPortableFS as d, PortableHasher as i, __resetPortableFSForTests as l, runtime as n, createPortableHasher as o, HashAlgorithm as r, getPortableHasher as s, resetPortableForTests as t, createPortableFS as u };
+//# sourceMappingURL=index-BMa2_rDb.d.mts.map

package/dist/index-BMa2_rDb.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BMa2_rDb.d.mts","names":[],"sources":["../src/portable/fs.ts","../src/portable/hash.ts","../src/portable/runtime.ts"],"sourcesContent":[],"mappings":";;AAIA;;AAE4C,UAF3B,UAAA,CAE2B;EAKM,QAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EANxB,OAMwB,CAAA,MAAA,CAAA;EAC1B,SAAA,CAAA,IAAA,EAAA,MAAA,EAAA,OAAA,EAAA,MAAA,CAAA,EANoB,OAMpB,CAAA,IAAA,CAAA;EACe;;;;EAWf,eAAA,CAAA,IAAA,EAAA,MAAA,EAAA,OAAA,EAAA,MAAA,CAAA,EAb0B,OAa1B,CAAA,IAAA,CAAA;EAAO,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EAZP,OAYO,CAAA,OAAA,CAAA;EAuEf,IAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EAlFM,OAkFU,CAAA;IAwHhB,KAAA,EA1MuB,IA0MvB;IAWA,IAAA,EAAA,MAAA;;4CApN4B;6BCN3B;IAFL,SAAA,CAAA,EAAa,OAAA;EAER,CAAA,CAAA,EDOyC,OCPzC,CAAA,IAAA,CAAc;EAIf;AAgBhB;AAWA;;;;AClCA;AAUA;wBFSwB;;;;;;;;;;iBAuER,gBAAA,CAAA,GAAoB;iBAwHpB,aAAA,CAAA,GAAiB;;;;;iBAWjB,yBAAA,CAAA;;;;AA9NhB;;AAE4C,KCAhC,aAAA,GDAgC,QAAA,GAAA,QAAA;AAKM,UCHjC,cAAA,CDGiC;EAC1B,IAAA,CAAA,OAAA,EAAA,MAAA,EAAA,SAAA,CAAA,ECHY,aDGZ,CAAA,EAAA,MAAA;;AACF,iBCDN,oBAAA,CAAA,CDCM,ECDkB,cDClB;AACsB,iBCc5B,iBAAA,CAAA,CDd4B,ECcP,cDdO;;;;AAiF5C;AAwHgB,iBChLA,6BAAA,CAAA,CDgL2B,EAAA,IAAA;;;;AAnN3C;;;AAOkD,cENrC,OFMqC,EAAA;EAC1B,SAAA,KAAA,EAAA,KAAA;EACe,SAAA,MAAA,EAAA,OAAA;EAAjB,SAAA,iBAAA,EAAA,OAAA;CACsB;;;;AAiF5C;AAwHgB,iBExMA,qBAAA,CAAA,CFwM2B,EAAA,IAAA"}

package/dist/index-BMl8pzFY.d.cts

@@ -0,0 +1,139 @@
+import { Result } from "neverthrow";
+
+//#region packages/common/src/utils/tsconfig.d.ts
+
+/**
+ * Parsed tsconfig.json paths configuration.
+ * All paths are resolved to absolute paths.
+ */
+type TsconfigPathsConfig = {
+  /** Absolute base URL for path resolution */
+  readonly baseUrl: string;
+  /** Path mappings with absolute paths */
+  readonly paths: Readonly<Record<string, readonly string[]>>;
+};
+/**
+ * Error types for tsconfig reading.
+ */
+type TsconfigReadError = {
+  readonly code: "TSCONFIG_READ_FAILED" | "TSCONFIG_PARSE_FAILED" | "TSCONFIG_INVALID";
+  readonly message: string;
+};
+/**
+ * Read and parse tsconfig.json to extract paths configuration.
+ * Currently does not support `extends` - reads only the specified file.
+ *
+ * @param tsconfigPath - Absolute path to tsconfig.json
+ * @returns Parsed paths configuration or null if no paths defined
+ */
+declare const readTsconfigPaths: (tsconfigPath: string) => Result<TsconfigPathsConfig | null, TsconfigReadError>;
+//#endregion
+//#region packages/common/src/utils/alias-resolver.d.ts
+/**
+ * Alias resolver interface for resolving path aliases to file paths.
+ */
+type AliasResolver = {
+  /**
+   * Resolve an alias specifier to an absolute file path.
+   * Returns null if the specifier doesn't match any alias pattern
+   * or if the resolved file doesn't exist.
+   */
+  readonly resolve: (specifier: string) => string | null;
+};
+/**
+ * Create an alias resolver from tsconfig paths configuration.
+ *
+ * Resolution behavior:
+ * 1. Try each pattern in order (first match wins per TS spec)
+ * 2. For each matched pattern, try all target paths in order
+ * 3. For each target, apply extension resolution
+ * 4. Return first found file, or null if none found
+ */
+declare const createAliasResolver: (config: TsconfigPathsConfig) => AliasResolver;
+//#endregion
+//#region packages/common/src/utils/cached-fn.d.ts
+declare const cachedFn: <T>(fn: () => T) => {
+  (): T;
+  clear(): void;
+};
+//#endregion
+//#region packages/common/src/utils/path.d.ts
+/**
+ * File extensions to try when resolving module specifiers.
+ * Ordered to match TypeScript's module resolution order.
+ * @see https://www.typescriptlang.org/docs/handbook/module-resolution.html
+ */
+declare const MODULE_EXTENSION_CANDIDATES: readonly [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".jsx"];
+/**
+ * Result of parsing a JS extension from a specifier.
+ */
+type JsExtensionInfo = {
+  /** The specifier without the JS extension */
+  readonly base: string;
+  /** The JS extension found (e.g., ".js", ".mjs") */
+  readonly jsExtension: string;
+  /** The corresponding TS extensions to try (e.g., [".ts", ".tsx"] for ".js") */
+  readonly tsExtensions: readonly string[];
+};
+/**
+ * Parse a JS extension from a specifier for ESM-style import resolution.
+ * Returns the base path (without extension), the JS extension, and corresponding TS extensions.
+ *
+ * @param specifier - The import specifier to parse
+ * @returns Object with base, jsExtension, and tsExtensions, or null if no JS extension found
+ *
+ * @example
+ * parseJsExtension("./foo.js") // { base: "./foo", jsExtension: ".js", tsExtensions: [".ts", ".tsx"] }
+ * parseJsExtension("./foo.mjs") // { base: "./foo", jsExtension: ".mjs", tsExtensions: [".mts"] }
+ * parseJsExtension("./foo") // null
+ * parseJsExtension("./foo.ts") // null
+ */
+declare const parseJsExtension: (specifier: string) => JsExtensionInfo | null;
+/**
+ * Normalize path to use forward slashes (cross-platform).
+ * Ensures consistent path handling across platforms.
+ */
+declare const normalizePath: (value: string) => string;
+/**
+ * Resolve a relative import specifier to an absolute file path.
+ * Tries the specifier as-is, with extensions, and as a directory with index files.
+ *
+ * @param from - Absolute path to the importing file
+ * @param specifier - Relative module specifier (must start with '.')
+ * @returns Absolute POSIX path to the resolved file, or null if not found
+ */
+declare const resolveRelativeImportWithExistenceCheck: ({
+  filePath,
+  specifier
+}: {
+  filePath: string;
+  specifier: string;
+}) => string | null;
+/**
+ * Resolve a relative import specifier to an absolute file path.
+ * Tries the specifier as-is, with extensions, and as a directory with index files.
+ *
+ * @param from - Absolute path to the importing file
+ * @param specifier - Relative module specifier (must start with '.')
+ * @returns Absolute POSIX path to the resolved file, or null if not found
+ */
+declare const resolveRelativeImportWithReferences: <_>({
+  filePath,
+  specifier,
+  references
+}: {
+  filePath: string;
+  specifier: string;
+  references: Map<string, _> | Set<string>;
+}) => string | null;
+/**
+ * Check if a module specifier is relative (starts with '.' or '..')
+ */
+declare const isRelativeSpecifier: (specifier: string) => boolean;
+/**
+ * Check if a module specifier is external (package name, not relative)
+ */
+declare const isExternalSpecifier: (specifier: string) => boolean;
+//#endregion
+export { normalizePath as a, resolveRelativeImportWithReferences as c, createAliasResolver as d, TsconfigPathsConfig as f, isRelativeSpecifier as i, cachedFn as l, readTsconfigPaths as m, MODULE_EXTENSION_CANDIDATES as n, parseJsExtension as o, TsconfigReadError as p, isExternalSpecifier as r, resolveRelativeImportWithExistenceCheck as s, JsExtensionInfo as t, AliasResolver as u };
+//# sourceMappingURL=index-BMl8pzFY.d.cts.map

package/dist/index-BMl8pzFY.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BMl8pzFY.d.cts","names":[],"sources":["../src/utils/tsconfig.ts","../src/utils/alias-resolver.ts","../src/utils/cached-fn.ts","../src/utils/path.ts"],"sourcesContent":[],"mappings":";;;;;;AAQA;AAUA;AA4Ba,KAtCD,mBAAA,GAgGX;EA1D+D;EAA4B,SAAA,OAAA,EAAA,MAAA;EAAnC;EAAM,SAAA,KAAA,EAlC7C,QAkC6C,CAlCpC,MAkCoC,CAAA,MAAA,EAAA,SAAA,MAAA,EAAA,CAAA,CAAA;;;;ACtC/D;AAoJa,KD1ID,iBAAA,GCyKX;;;;AC3LD;;;;ACQA;AAgBA;AAsBA;AAiBa,cHjBA,iBGiB+E,EAAA,CAAA,YAAA,EAAA,MAAA,EAAA,GHjBnC,MGiBmC,CHjB5B,mBGiB4B,GAAA,IAAA,EHjBA,iBGiBA,CAAA;;;;;AHvD5F;AAUY,KCVA,aAAA,GDUiB;EA4BhB;;;;;;;;ACtCb;AAoJA;;;;AC5JA;;;cD4Ja,8BAA+B,wBAAsB;;;cC5JrD,wBAAyB;MAAA;;AFQtC,CAAA;;;;;;AAAA;AAUA;AA4Ba,cGtCA,2BHgGZ,EAAA,SAAA,CAAA,KAAA,EAAA,MAAA,EAAA,MAAA,EAAA,MAAA,EAAA,KAAA,EAAA,MAAA,EAAA,MAAA,EAAA,MAAA,CAAA;;;;AA1D8D,KGtBnD,eAAA,GHsBmD;;;;ECtCnD,SAAA,WAAa,EAAA,MAAA;EAoJZ;;;;AC5Jb;;;;ACQA;AAgBA;AAsBA;AAiBA;AAUA;AA+EA;;;AAAuD,cA1G1C,gBA0G0C,EAAA,CAAA,SAAA,EAAA,MAAA,EAAA,GA1GF,eA0GE,GAAA,IAAA;;;;;AA4D1C,cArJA,aAqJ+G,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GAAA,MAAA;AAK5H;;;;;;;;cAhJa;;;;;;;;;;;;;;;cA+EA;;;;;;;cAOC,YAAY,KAAK;;;;;cAqDlB;;;;cAKA"}

package/dist/{index-B424kKYS.d.mts → index-CbQyueYV.d.cts}

@@ -1,6 +1,6 @@
 //#region packages/common/src/portable/fs.d.ts
 /**
- * Portable filesystem API that works on both Bun and Node.js
+ * Portable filesystem API using Node.js fs
  */
 interface PortableFS {
   readFile(path: string): Promise<string>;
@@ -47,7 +47,7 @@ declare function __resetPortableFSForTests(): void;
 //#endregion
 //#region packages/common/src/portable/hash.d.ts
 /**
- * Portable hashing API that works on both Bun and Node.js
+ * Portable hashing API using Node.js crypto
  */
 type HashAlgorithm = "sha256" | "xxhash";
 interface PortableHasher {
@@ -61,50 +61,21 @@ declare function getPortableHasher(): PortableHasher;
  */
 declare function __resetPortableHasherForTests(): void;
 //#endregion
-//#region packages/common/src/portable/id.d.ts
-/**
- * Portable ID generation that works on both Bun and Node.js
- */
-/**
- * Generate a unique ID
- * Uses UUIDv7 on Bun (monotonic), falls back to randomUUID on Node.js
- */
-declare function generateId(): string;
-//#endregion
 //#region packages/common/src/portable/runtime.d.ts
 /**
  * Runtime detection utilities for portable API implementation
+ * Note: Bun-specific code has been removed. Node.js APIs are always used.
  */
 declare const runtime: {
-  readonly isBun: boolean;
+  readonly isBun: false;
   readonly isNode: boolean;
   readonly supportsWebCrypto: boolean;
 };
-/**
- * Helper to cache module imports to avoid repeated dynamic imports
- */
-declare function once<T>(fn: () => T): () => T;
 /**
  * Reset runtime state for testing purposes only
  * @internal
  */
 declare function resetPortableForTests(): void;
 //#endregion
-//#region packages/common/src/portable/spawn.d.ts
-/**
- * Portable subprocess spawning that works on both Bun and Node.js
- */
-interface SpawnOptions {
-  cmd: string[];
-  cwd?: string;
-  env?: Record<string, string>;
-}
-interface SpawnResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}
-declare function spawn(options: SpawnOptions): Promise<SpawnResult>;
-//#endregion
-export { resetPortableForTests as a, HashAlgorithm as c, createPortableHasher as d, getPortableHasher as f, getPortableFS as g, createPortableFS as h, once as i, PortableHasher as l, __resetPortableFSForTests as m, SpawnResult as n, runtime as o, PortableFS as p, spawn as r, generateId as s, SpawnOptions as t, __resetPortableHasherForTests as u };
-//# sourceMappingURL=index-B424kKYS.d.mts.map
+export { __resetPortableHasherForTests as a, PortableFS as c, getPortableFS as d, PortableHasher as i, __resetPortableFSForTests as l, runtime as n, createPortableHasher as o, HashAlgorithm as r, getPortableHasher as s, resetPortableForTests as t, createPortableFS as u };
+//# sourceMappingURL=index-CbQyueYV.d.cts.map

package/dist/index-CbQyueYV.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CbQyueYV.d.cts","names":[],"sources":["../src/portable/fs.ts","../src/portable/hash.ts","../src/portable/runtime.ts"],"sourcesContent":[],"mappings":";;AAIA;;AAE4C,UAF3B,UAAA,CAE2B;EAKM,QAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EANxB,OAMwB,CAAA,MAAA,CAAA;EAC1B,SAAA,CAAA,IAAA,EAAA,MAAA,EAAA,OAAA,EAAA,MAAA,CAAA,EANoB,OAMpB,CAAA,IAAA,CAAA;EACe;;;;EAWf,eAAA,CAAA,IAAA,EAAA,MAAA,EAAA,OAAA,EAAA,MAAA,CAAA,EAb0B,OAa1B,CAAA,IAAA,CAAA;EAAO,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EAZP,OAYO,CAAA,OAAA,CAAA;EAuEf,IAAA,CAAA,IAAA,EAAA,MAAA,CAAA,EAlFM,OAkFU,CAAA;IAwHhB,KAAA,EA1MuB,IA0MvB;IAWA,IAAA,EAAA,MAAA;;4CApN4B;6BCN3B;IAFL,SAAA,CAAA,EAAa,OAAA;EAER,CAAA,CAAA,EDOyC,OCPzC,CAAA,IAAA,CAAc;EAIf;AAgBhB;AAWA;;;;AClCA;AAUA;wBFSwB;;;;;;;;;;iBAuER,gBAAA,CAAA,GAAoB;iBAwHpB,aAAA,CAAA,GAAiB;;;;;iBAWjB,yBAAA,CAAA;;;;AA9NhB;;AAE4C,KCAhC,aAAA,GDAgC,QAAA,GAAA,QAAA;AAKM,UCHjC,cAAA,CDGiC;EAC1B,IAAA,CAAA,OAAA,EAAA,MAAA,EAAA,SAAA,CAAA,ECHY,aDGZ,CAAA,EAAA,MAAA;;AACF,iBCDN,oBAAA,CAAA,CDCM,ECDkB,cDClB;AACsB,iBCc5B,iBAAA,CAAA,CDd4B,ECcP,cDdO;;;;AAiF5C;AAwHgB,iBChLA,6BAAA,CAAA,CDgL2B,EAAA,IAAA;;;;AAnN3C;;;AAOkD,cENrC,OFMqC,EAAA;EAC1B,SAAA,KAAA,EAAA,KAAA;EACe,SAAA,MAAA,EAAA,OAAA;EAAjB,SAAA,iBAAA,EAAA,OAAA;CACsB;;;;AAiF5C;AAwHgB,iBExMA,qBAAA,CAAA,CFwM2B,EAAA,IAAA"}

package/dist/{index-CPpVc8Id.d.mts → index-DZSebwar.d.cts}

@@ -5,7 +5,34 @@ type CanonicalId = string & {
   readonly __brand: "CanonicalId";
 };
 declare const CanonicalIdSchema: z$1.ZodType<CanonicalId>;
-declare const createCanonicalId: (filePath: string, astPath: string) => CanonicalId;
+/**
+ * Options for creating a canonical ID.
+ */
+type CreateCanonicalIdOptions = {
+  /**
+   * Base directory for relative path computation.
+   * When provided, the canonical ID will use a relative path from baseDir.
+   * When undefined, an absolute path is required and used as-is.
+   */
+  readonly baseDir?: string;
+};
+/**
+ * Create a canonical ID from a file path and AST path.
+ *
+ * @param filePath - The file path (absolute, or relative if baseDir is provided)
+ * @param astPath - The AST path identifying the definition within the file
+ * @param options - Optional configuration including baseDir for relative path support
+ * @returns A canonical ID in the format "{path}::{astPath}"
+ */
+declare const createCanonicalId: (filePath: string, astPath: string, options?: CreateCanonicalIdOptions) => CanonicalId;
+/**
+ * Check if a canonical ID uses a relative path.
+ * Relative canonical IDs do not start with '/'.
+ *
+ * @param canonicalId - The canonical ID to check
+ * @returns true if the canonical ID uses a relative path
+ */
+declare const isRelativeCanonicalId: (canonicalId: CanonicalId | string) => boolean;
 /**
  * Parse a canonical ID into its components.
  * @param canonicalId - The canonical ID to parse (e.g., "/app/src/user.ts::userFragment")
@@ -15,6 +42,24 @@ declare const parseCanonicalId: (canonicalId: CanonicalId | string) => {
   filePath: string;
   astPath: string;
 };
+/**
+ * Validation result for canonical ID format.
+ */
+type CanonicalIdValidationResult = {
+  readonly isValid: true;
+} | {
+  readonly isValid: false;
+  readonly reason: string;
+};
+/**
+ * Validate a canonical ID format.
+ * A valid canonical ID has format: "{filePath}::{astPath}"
+ * where both filePath and astPath are non-empty.
+ *
+ * @param canonicalId - The canonical ID to validate
+ * @returns Validation result with isValid boolean and optional error reason
+ */
+declare const validateCanonicalId: (canonicalId: string) => CanonicalIdValidationResult;
 //#endregion
 //#region packages/common/src/canonical-id/path-tracker.d.ts
 
@@ -110,6 +155,11 @@ interface CanonicalPathTracker {
  */
 declare const createCanonicalTracker: (options: {
   filePath: string;
+  /**
+   * Base directory for relative path computation in canonical IDs.
+   * When provided, canonical IDs will use relative paths from baseDir.
+   */
+  baseDir?: string;
   getExportName?: (localName: string) => string | undefined;
 }) => CanonicalPathTracker;
 /**
@@ -129,5 +179,5 @@ declare const createPathTracker: () => {
  */
 declare const buildAstPath: (stack: readonly ScopeFrame[]) => string;
 //#endregion
-export { createCanonicalTracker as a, CanonicalId as c, parseCanonicalId as d, buildAstPath as i, CanonicalIdSchema as l, ScopeFrame as n, createOccurrenceTracker as o, ScopeHandle as r, createPathTracker as s, CanonicalPathTracker as t, createCanonicalId as u };
-//# sourceMappingURL=index-CPpVc8Id.d.mts.map
+export { createCanonicalTracker as a, CanonicalId as c, CreateCanonicalIdOptions as d, createCanonicalId as f, validateCanonicalId as h, buildAstPath as i, CanonicalIdSchema as l, parseCanonicalId as m, ScopeFrame as n, createOccurrenceTracker as o, isRelativeCanonicalId as p, ScopeHandle as r, createPathTracker as s, CanonicalPathTracker as t, CanonicalIdValidationResult as u };
+//# sourceMappingURL=index-DZSebwar.d.cts.map

package/dist/index-DZSebwar.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DZSebwar.d.cts","names":[],"sources":["../src/canonical-id/canonical-id.ts","../src/canonical-id/path-tracker.ts"],"sourcesContent":[],"mappings":";;;KAIY,WAAA;;AAAZ,CAAA;AAIa,cAAA,iBAA6B,EAAV,GAAA,CAAE,OAAF,CAAU,WAAD,CAAA;AAKzC;AAiBA;AAoCA;AASa,KA9DD,wBAAA,GA+DG;EAkBH;AAUZ;;;;ECnFY,SAAA,OAAU,CAAA,EAAA,MAAA;AAYtB,CAAA;AAQA;;;;;;AA8EA;AA4GA;AAiBa,cDtNA,iBCuOZ,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,OAAA,EAAA,MAAA,EAAA,OAAA,CAAA,EDvO8E,wBCuO9E,EAAA,GDvOyG,WCuOzG;AAKD;;;;;;;cDxMa,qCAAsC;;;;;;cAStC,gCACE;;;;;;;KAkBH,2BAAA;;;;;;;;;;;;;;cAUC,8CAA6C;;;;ACvE1D;AAQA;;AAM0F,KA1B9E,UAAA,GA0B8E;EAMtE;EAiBmB,SAAA,WAAA,EAAA,MAAA;EAAW;EAiDrC,SAAA,IAAA,EAAA,UAuGZ,GAAA,OAAA,GA/FG,UAAA,GAAA,UA+FH,GAAA,QAAA,GAAA,YAAA;EAKY;EAiBA,SAAA,UAAA,EAiBZ,MAAA;AAKD,CAAA;;;;KAzOY,WAAA;;;;;;;UAQK,oBAAA;;;;;;;;UAM8B;;MAA2C;;;;;oBAMtE;;;;;;;;;;;;;;;uCAiBmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiD1B;;;;;;;;MAQT;;;;cAoGS;;;;;;cAiBA;;;;;;cAsBA,+BAAgC"}

package/dist/index-Dit86qkX.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index-Dit86qkX.d.mts","names":[],"sources":["../src/zod/schema-helper.ts"],"sourcesContent":[],"mappings":";;;KAGY,qBAAqB,CAAA,CAAE,QAAQ;KAE/B,2CAFA,MAEiD,OAFxC,KAEoD,SAF9B,CAEwC,OAFhD,CAEwD,CAFxD,CAAA,CAAA,EAEnC;AAA6D,iBAE7C,eAF6C,CAAA,gBAAA,MAAA,CAAA,CAAA,CAAA,EAAA,CAAA,eAGpC,QAHoC,CAG3B,OAH2B,CAGnB,OAHmB,CAAA,CAAA,CAAA,CAAA,KAAA,EAGD,MAHC,GAAA,QAGgB,OAHhB,CAAA,MAG8B,MAH9B,EAAA,MAG4C,OAH5C,CAAA,GAAA,KAAA,EAAA,EAAA,GAG8D,CAAA,CAAA,SAH9D,CAG8D,MAH9D,GAAA,QAGY,OAHZ,CAAA,MAGY,MAHZ,EAAA,MAGY,OAHZ,CAAA,GAAA,KAAA,EAAA,SAAA,KAAA,EAAA,GAAA,kBAAA,MAGY,CAHZ,GAGY,CAHZ,CAGY,CAHZ,CAAA,EAAA,GAAA,KAAA,EAGY,CAAA,CAAA,IAAA,CAAA,OAHZ,CAAA"}
+{"version":3,"file":"index-Dit86qkX.d.mts","names":[],"sources":["../src/zod/schema-helper.ts"],"sourcesContent":[],"mappings":";;;KAGY,qBAAqB,CAAA,CAAE,QAAQ;KAE/B,2CAFA,MAEiD,OAFxC,KAEoD,SAF9B,CAEwC,OAFlD,CAE0D,CAFxD,CAAA,CAAA,EAEnC;AAA6D,iBAE7C,eAF6C,CAAA,gBAAA,MAAA,CAAA,CAAA,CAAA,EAAA,CAAA,eAGpC,QAHoC,CAG3B,OAH2B,CAGnB,OAHmB,CAAA,CAAA,CAAA,CAAA,KAAA,EAGD,MAHC,GAAA,QAGgB,OAHhB,CAAA,MAG8B,MAH9B,EAAA,MAG4C,OAH5C,CAAA,GAAA,KAAA,EAAA,EAAA,GAG8D,CAAA,CAAA,SAH9D,CAG8D,MAH9D,GAAA,QAGY,OAHZ,CAAA,MAGY,MAHZ,EAAA,MAGY,OAHZ,CAAA,GAAA,KAAA,EAAA,SAAA,KAAA,EAAA,GAAA,kBAAA,MAGY,CAHZ,GAGY,CAHZ,CAGY,CAHZ,CAAA,EAAA,GAAA,KAAA,EAGY,CAAA,CAAA,IAAA,CAAA,OAHZ,CAAA"}

package/dist/index.cjs

@@ -1,7 +1,7 @@
-const require_canonical_id = require('./canonical-id-CgMNOZyn.cjs');
-const require_utils = require('./utils-CsTwS1dw.cjs');
-const require_portable = require('./portable-cJqkfeHw.cjs');
-const require_zod = require('./zod-C_6JfuYV.cjs');
+const require_canonical_id = require('./canonical-id-DHdeYIsT.cjs');
+const require_utils = require('./utils-Rs7YbafF.cjs');
+const require_portable = require('./portable-B3K3IE7E.cjs');
+const require_zod = require('./zod-DjI3IUH3.cjs');
 let neverthrow = require("neverthrow");
 
 //#region packages/common/src/scheduler/types.ts
@@ -269,6 +269,7 @@ exports.__resetPortableFSForTests = require_portable.__resetPortableFSForTests;
 exports.__resetPortableHasherForTests = require_portable.__resetPortableHasherForTests;
 exports.buildAstPath = require_canonical_id.buildAstPath;
 exports.cachedFn = require_utils.cachedFn;
+exports.createAliasResolver = require_utils.createAliasResolver;
 exports.createAsyncScheduler = createAsyncScheduler;
 exports.createCanonicalId = require_canonical_id.createCanonicalId;
 exports.createCanonicalTracker = require_canonical_id.createCanonicalTracker;
@@ -279,17 +280,18 @@ exports.createPortableHasher = require_portable.createPortableHasher;
 exports.createSchedulerError = createSchedulerError;
 exports.createSyncScheduler = createSyncScheduler;
 exports.defineSchemaFor = require_zod.defineSchemaFor;
-exports.generateId = require_portable.generateId;
 exports.getPortableFS = require_portable.getPortableFS;
 exports.getPortableHasher = require_portable.getPortableHasher;
 exports.isExternalSpecifier = require_utils.isExternalSpecifier;
+exports.isRelativeCanonicalId = require_canonical_id.isRelativeCanonicalId;
 exports.isRelativeSpecifier = require_utils.isRelativeSpecifier;
 exports.normalizePath = require_utils.normalizePath;
-exports.once = require_portable.once;
 exports.parseCanonicalId = require_canonical_id.parseCanonicalId;
+exports.parseJsExtension = require_utils.parseJsExtension;
+exports.readTsconfigPaths = require_utils.readTsconfigPaths;
 exports.resetPortableForTests = require_portable.resetPortableForTests;
 exports.resolveRelativeImportWithExistenceCheck = require_utils.resolveRelativeImportWithExistenceCheck;
 exports.resolveRelativeImportWithReferences = require_utils.resolveRelativeImportWithReferences;
 exports.runtime = require_portable.runtime;
-exports.spawn = require_portable.spawn;
+exports.validateCanonicalId = require_canonical_id.validateCanonicalId;
 //# sourceMappingURL=index.cjs.map

package/dist/index.d.cts

@@ -1,6 +1,6 @@
-import { a as createCanonicalTracker, c as CanonicalId, d as parseCanonicalId, i as buildAstPath, l as CanonicalIdSchema, n as ScopeFrame, o as createOccurrenceTracker, r as ScopeHandle, s as createPathTracker, t as CanonicalPathTracker, u as createCanonicalId } from "./index-Cm2Zwk9m.cjs";
-import { a as resetPortableForTests, c as HashAlgorithm, d as createPortableHasher, f as getPortableHasher, g as getPortableFS, h as createPortableFS, i as once, l as PortableHasher, m as __resetPortableFSForTests, n as SpawnResult, o as runtime, p as PortableFS, r as spawn, s as generateId, t as SpawnOptions, u as __resetPortableHasherForTests } from "./index-D1tzB3W5.cjs";
-import { a as resolveRelativeImportWithExistenceCheck, i as normalizePath, n as isExternalSpecifier, o as resolveRelativeImportWithReferences, r as isRelativeSpecifier, s as cachedFn, t as MODULE_EXTENSION_CANDIDATES } from "./index-LaXfl_e_.cjs";
+import { a as createCanonicalTracker, c as CanonicalId, d as CreateCanonicalIdOptions, f as createCanonicalId, h as validateCanonicalId, i as buildAstPath, l as CanonicalIdSchema, m as parseCanonicalId, n as ScopeFrame, o as createOccurrenceTracker, p as isRelativeCanonicalId, r as ScopeHandle, s as createPathTracker, t as CanonicalPathTracker, u as CanonicalIdValidationResult } from "./index-DZSebwar.cjs";
+import { a as __resetPortableHasherForTests, c as PortableFS, d as getPortableFS, i as PortableHasher, l as __resetPortableFSForTests, n as runtime, o as createPortableHasher, r as HashAlgorithm, s as getPortableHasher, t as resetPortableForTests, u as createPortableFS } from "./index-CbQyueYV.cjs";
+import { a as normalizePath, c as resolveRelativeImportWithReferences, d as createAliasResolver, f as TsconfigPathsConfig, i as isRelativeSpecifier, l as cachedFn, m as readTsconfigPaths, n as MODULE_EXTENSION_CANDIDATES, o as parseJsExtension, p as TsconfigReadError, r as isExternalSpecifier, s as resolveRelativeImportWithExistenceCheck, t as JsExtensionInfo, u as AliasResolver } from "./index-BMl8pzFY.cjs";
 import { n as ShapeFor, r as defineSchemaFor, t as SchemaFor } from "./index-LHYortIn.cjs";
 import { Result } from "neverthrow";
 
@@ -216,5 +216,5 @@ declare const Effects: {
  */
 declare const createSyncScheduler: () => SyncScheduler;
 //#endregion
-export { type AsyncScheduler, CanonicalId, CanonicalIdSchema, CanonicalPathTracker, DeferEffect, Effect, type EffectGenerator, type EffectGeneratorFn, type EffectResult, Effects, HashAlgorithm, MODULE_EXTENSION_CANDIDATES, ParallelEffect, PortableFS, PortableHasher, PureEffect, type SchedulerError, SchemaFor, ScopeFrame, ScopeHandle, ShapeFor, SpawnOptions, SpawnResult, type SyncScheduler, YieldEffect, __resetPortableFSForTests, __resetPortableHasherForTests, buildAstPath, cachedFn, createAsyncScheduler, createCanonicalId, createCanonicalTracker, createOccurrenceTracker, createPathTracker, createPortableFS, createPortableHasher, createSchedulerError, createSyncScheduler, defineSchemaFor, generateId, getPortableFS, getPortableHasher, isExternalSpecifier, isRelativeSpecifier, normalizePath, once, parseCanonicalId, resetPortableForTests, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences, runtime, spawn };
+export { AliasResolver, type AsyncScheduler, CanonicalId, CanonicalIdSchema, CanonicalIdValidationResult, CanonicalPathTracker, CreateCanonicalIdOptions, DeferEffect, Effect, type EffectGenerator, type EffectGeneratorFn, type EffectResult, Effects, HashAlgorithm, JsExtensionInfo, MODULE_EXTENSION_CANDIDATES, ParallelEffect, PortableFS, PortableHasher, PureEffect, type SchedulerError, SchemaFor, ScopeFrame, ScopeHandle, ShapeFor, type SyncScheduler, TsconfigPathsConfig, TsconfigReadError, YieldEffect, __resetPortableFSForTests, __resetPortableHasherForTests, buildAstPath, cachedFn, createAliasResolver, createAsyncScheduler, createCanonicalId, createCanonicalTracker, createOccurrenceTracker, createPathTracker, createPortableFS, createPortableHasher, createSchedulerError, createSyncScheduler, defineSchemaFor, getPortableFS, getPortableHasher, isExternalSpecifier, isRelativeCanonicalId, isRelativeSpecifier, normalizePath, parseCanonicalId, parseJsExtension, readTsconfigPaths, resetPortableForTests, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences, runtime, validateCanonicalId };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { a as createCanonicalTracker, c as CanonicalId, d as parseCanonicalId, i as buildAstPath, l as CanonicalIdSchema, n as ScopeFrame, o as createOccurrenceTracker, r as ScopeHandle, s as createPathTracker, t as CanonicalPathTracker, u as createCanonicalId } from "./index-CPpVc8Id.mjs";
-import { a as resetPortableForTests, c as HashAlgorithm, d as createPortableHasher, f as getPortableHasher, g as getPortableFS, h as createPortableFS, i as once, l as PortableHasher, m as __resetPortableFSForTests, n as SpawnResult, o as runtime, p as PortableFS, r as spawn, s as generateId, t as SpawnOptions, u as __resetPortableHasherForTests } from "./index-B424kKYS.mjs";
-import { a as resolveRelativeImportWithExistenceCheck, i as normalizePath, n as isExternalSpecifier, o as resolveRelativeImportWithReferences, r as isRelativeSpecifier, s as cachedFn, t as MODULE_EXTENSION_CANDIDATES } from "./index-Dv8spPt0.mjs";
+import { a as createCanonicalTracker, c as CanonicalId, d as CreateCanonicalIdOptions, f as createCanonicalId, h as validateCanonicalId, i as buildAstPath, l as CanonicalIdSchema, m as parseCanonicalId, n as ScopeFrame, o as createOccurrenceTracker, p as isRelativeCanonicalId, r as ScopeHandle, s as createPathTracker, t as CanonicalPathTracker, u as CanonicalIdValidationResult } from "./index-AqkJhrm3.mjs";
+import { a as __resetPortableHasherForTests, c as PortableFS, d as getPortableFS, i as PortableHasher, l as __resetPortableFSForTests, n as runtime, o as createPortableHasher, r as HashAlgorithm, s as getPortableHasher, t as resetPortableForTests, u as createPortableFS } from "./index-BMa2_rDb.mjs";
+import { a as normalizePath, c as resolveRelativeImportWithReferences, d as createAliasResolver, f as TsconfigPathsConfig, i as isRelativeSpecifier, l as cachedFn, m as readTsconfigPaths, n as MODULE_EXTENSION_CANDIDATES, o as parseJsExtension, p as TsconfigReadError, r as isExternalSpecifier, s as resolveRelativeImportWithExistenceCheck, t as JsExtensionInfo, u as AliasResolver } from "./index-BCu9PNbZ.mjs";
 import { n as ShapeFor, r as defineSchemaFor, t as SchemaFor } from "./index-Dit86qkX.mjs";
 import { Result } from "neverthrow";
 
@@ -216,5 +216,5 @@ declare const Effects: {
  */
 declare const createSyncScheduler: () => SyncScheduler;
 //#endregion
-export { type AsyncScheduler, CanonicalId, CanonicalIdSchema, CanonicalPathTracker, DeferEffect, Effect, type EffectGenerator, type EffectGeneratorFn, type EffectResult, Effects, HashAlgorithm, MODULE_EXTENSION_CANDIDATES, ParallelEffect, PortableFS, PortableHasher, PureEffect, type SchedulerError, SchemaFor, ScopeFrame, ScopeHandle, ShapeFor, SpawnOptions, SpawnResult, type SyncScheduler, YieldEffect, __resetPortableFSForTests, __resetPortableHasherForTests, buildAstPath, cachedFn, createAsyncScheduler, createCanonicalId, createCanonicalTracker, createOccurrenceTracker, createPathTracker, createPortableFS, createPortableHasher, createSchedulerError, createSyncScheduler, defineSchemaFor, generateId, getPortableFS, getPortableHasher, isExternalSpecifier, isRelativeSpecifier, normalizePath, once, parseCanonicalId, resetPortableForTests, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences, runtime, spawn };
+export { AliasResolver, type AsyncScheduler, CanonicalId, CanonicalIdSchema, CanonicalIdValidationResult, CanonicalPathTracker, CreateCanonicalIdOptions, DeferEffect, Effect, type EffectGenerator, type EffectGeneratorFn, type EffectResult, Effects, HashAlgorithm, JsExtensionInfo, MODULE_EXTENSION_CANDIDATES, ParallelEffect, PortableFS, PortableHasher, PureEffect, type SchedulerError, SchemaFor, ScopeFrame, ScopeHandle, ShapeFor, type SyncScheduler, TsconfigPathsConfig, TsconfigReadError, YieldEffect, __resetPortableFSForTests, __resetPortableHasherForTests, buildAstPath, cachedFn, createAliasResolver, createAsyncScheduler, createCanonicalId, createCanonicalTracker, createOccurrenceTracker, createPathTracker, createPortableFS, createPortableHasher, createSchedulerError, createSyncScheduler, defineSchemaFor, getPortableFS, getPortableHasher, isExternalSpecifier, isRelativeCanonicalId, isRelativeSpecifier, normalizePath, parseCanonicalId, parseJsExtension, readTsconfigPaths, resetPortableForTests, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences, runtime, validateCanonicalId };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { a as getPortableHasher, c as getPortableFS, d as runtime, i as createPortableHasher, l as once, n as generateId, o as __resetPortableFSForTests, r as __resetPortableHasherForTests, s as createPortableFS, t as spawn, u as resetPortableForTests } from "./portable-BT3ahkQN.mjs";
-import { a as resolveRelativeImportWithExistenceCheck, i as normalizePath, n as isExternalSpecifier, o as resolveRelativeImportWithReferences, r as isRelativeSpecifier, s as cachedFn, t as MODULE_EXTENSION_CANDIDATES } from "./utils-DLEgAn7q.mjs";
-import { a as CanonicalIdSchema, i as createPathTracker, n as createCanonicalTracker, o as createCanonicalId, r as createOccurrenceTracker, s as parseCanonicalId, t as buildAstPath } from "./canonical-id-BJahCcrS.mjs";
+import { a as getPortableHasher, c as getPortableFS, i as createPortableHasher, n as runtime, o as __resetPortableFSForTests, r as __resetPortableHasherForTests, s as createPortableFS, t as resetPortableForTests } from "./portable-BFrcBOaX.mjs";
+import { a as isExternalSpecifier, c as parseJsExtension, i as MODULE_EXTENSION_CANDIDATES, l as resolveRelativeImportWithExistenceCheck, n as cachedFn, o as isRelativeSpecifier, r as createAliasResolver, s as normalizePath, t as readTsconfigPaths, u as resolveRelativeImportWithReferences } from "./utils-ZCE_eqCf.mjs";
+import { a as CanonicalIdSchema, c as parseCanonicalId, i as createPathTracker, l as validateCanonicalId, n as createCanonicalTracker, o as createCanonicalId, r as createOccurrenceTracker, s as isRelativeCanonicalId, t as buildAstPath } from "./canonical-id-9alor9gv.mjs";
 import { t as defineSchemaFor } from "./zod-DeSimXdI.mjs";
 import { err, ok } from "neverthrow";
 
@@ -257,5 +257,5 @@ const isSchedulerError = (error) => {
 };
 
 //#endregion
-export { CanonicalIdSchema, DeferEffect, Effect, Effects, MODULE_EXTENSION_CANDIDATES, ParallelEffect, PureEffect, YieldEffect, __resetPortableFSForTests, __resetPortableHasherForTests, buildAstPath, cachedFn, createAsyncScheduler, createCanonicalId, createCanonicalTracker, createOccurrenceTracker, createPathTracker, createPortableFS, createPortableHasher, createSchedulerError, createSyncScheduler, defineSchemaFor, generateId, getPortableFS, getPortableHasher, isExternalSpecifier, isRelativeSpecifier, normalizePath, once, parseCanonicalId, resetPortableForTests, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences, runtime, spawn };
+export { CanonicalIdSchema, DeferEffect, Effect, Effects, MODULE_EXTENSION_CANDIDATES, ParallelEffect, PureEffect, YieldEffect, __resetPortableFSForTests, __resetPortableHasherForTests, buildAstPath, cachedFn, createAliasResolver, createAsyncScheduler, createCanonicalId, createCanonicalTracker, createOccurrenceTracker, createPathTracker, createPortableFS, createPortableHasher, createSchedulerError, createSyncScheduler, defineSchemaFor, getPortableFS, getPortableHasher, isExternalSpecifier, isRelativeCanonicalId, isRelativeSpecifier, normalizePath, parseCanonicalId, parseJsExtension, readTsconfigPaths, resetPortableForTests, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences, runtime, validateCanonicalId };
 //# sourceMappingURL=index.mjs.map