@soda-gql/common 0.0.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-C8yyrGd7.d.cts","names":[],"sources":["../src/canonical-id/canonical-id.ts","../src/canonical-id/path-tracker.ts"],"sourcesContent":[],"mappings":";;;KAIY,WAAA;;AAAZ,CAAA;AAIa,cAAA,iBAA2F,EAAxE,GAAA,CAAE,OAAsE,CAA9D,WAA8D,CAAA;AAAA,cAG3F,iBAH2F,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,OAAA,EAAA,MAAA,EAAA,GAGlC,WAHkC;;;;ACiCxG;;;AAM0F,KA1B9E,UAAA,GA0B8E;;WAuBnD,WAAA,EAAA,MAAA;EAAW;EAiDrC,SAAA,IAAA,EAAA,UAkGZ,GAAA,OA/FG,GAAA,UAAA,GAAA,UA+FH,GAAA,QAAA,GAAA,YAAA;EAKY;EAiBA,SAAA,UAAA,EAiBZ,MAAA;AAKD,CAAA;;;;KApOY,WAAA;;;;;;;UAQK,oBAAA;;;;;;;;UAM8B;;MAA2C;;;;;oBAMtE;;;;;;;;;;;;;;;uCAiBmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiD1B;;;MAGT;;;;cAoGS;;;;;;cAiBA;;;;;;cAsBA,+BAAgC"}

package/dist/index-CcSB32XQ.d.ts

@@ -0,0 +1,60 @@
+//#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 by precedence: TypeScript, then JavaScript.
+ */
+declare const MODULE_EXTENSION_CANDIDATES: readonly [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+/**
+ * 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 { MODULE_EXTENSION_CANDIDATES, cachedFn, isExternalSpecifier, isRelativeSpecifier, normalizePath, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences };
+//# sourceMappingURL=index-CcSB32XQ.d.ts.map

package/dist/index-CcSB32XQ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CcSB32XQ.d.ts","names":[],"sources":["../src/utils/cached-fn.ts","../src/utils/path.ts"],"sourcesContent":[],"mappings":";cAAa,wBAAyB;EAAzB,EAAA,GAAA;EASZ,KAAA,EAAA,EAAA,IAAA;;;;;AATD;;;cCOa;;;;;AAAA,cAMA,aANqG,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GAAA,MAAA;AAMlH;AAUA;;;;;AAyCA;;AAAuD,cAzC1C,uCAyC0C,EAAA,CAAA;EAAA,QAAA;EAAA;CAAA,EAAA;UAAA,EAAA,MAAA;WAAA,EAAA,MAAA;YAO7B,GAAA,IAAA;;;;AA+B1B;AAKA;;;;cA3Ca;;;;;;;cAOC,YAAY,KAAK;;;;;cA+BlB;;;;cAKA"}

package/dist/index-D6Lx478n.d.ts

@@ -0,0 +1,124 @@
+import z$1 from "zod";
+
+//#region packages/common/src/canonical-id/canonical-id.d.ts
+type CanonicalId = string & {
+  readonly __brand: "CanonicalId";
+};
+declare const CanonicalIdSchema: z$1.ZodType<CanonicalId>;
+declare const createCanonicalId: (filePath: string, astPath: string) => CanonicalId;
+//#endregion
+//#region packages/common/src/canonical-id/path-tracker.d.ts
+
+/**
+ * Scope frame for tracking AST path segments
+ */
+type ScopeFrame = {
+  /** Name segment (e.g., "MyComponent", "useQuery", "arrow#1") */
+  readonly nameSegment: string;
+  /** Kind of scope */
+  readonly kind: "function" | "class" | "variable" | "property" | "method" | "expression";
+  /** Occurrence index for disambiguation */
+  readonly occurrence: number;
+};
+/**
+ * Opaque handle for scope tracking
+ */
+type ScopeHandle = {
+  readonly __brand: "ScopeHandle";
+  readonly depth: number;
+};
+/**
+ * Canonical path tracker interface
+ */
+interface CanonicalPathTracker {
+  /**
+   * Enter a new scope during traversal
+   * @param options Scope information
+   * @returns Handle to use when exiting the scope
+   */
+  enterScope(options: {
+    segment: string;
+    kind: ScopeFrame["kind"];
+    stableKey?: string;
+  }): ScopeHandle;
+  /**
+   * Exit a scope during traversal
+   * @param handle Handle returned from enterScope
+   */
+  exitScope(handle: ScopeHandle): void;
+  /**
+   * Register a definition discovered during traversal
+   * @returns Definition metadata including astPath and canonical ID information
+   */
+  registerDefinition(): {
+    astPath: string;
+    isTopLevel: boolean;
+    exportBinding?: string;
+  };
+  /**
+   * Resolve a canonical ID from an astPath
+   * @param astPath AST path string
+   * @returns Canonical ID
+   */
+  resolveCanonicalId(astPath: string): CanonicalId;
+  /**
+   * Register an export binding
+   * @param local Local variable name
+   * @param exported Exported name
+   */
+  registerExportBinding(local: string, exported: string): void;
+  /**
+   * Get current scope depth
+   * @returns Current depth (0 = top level)
+   */
+  currentDepth(): number;
+}
+/**
+ * Create a canonical path tracker
+ *
+ * @param options Configuration options
+ * @returns Tracker instance
+ *
+ * @example
+ * ```typescript
+ * // In a Babel plugin
+ * const tracker = createCanonicalTracker({ filePath: state.filename });
+ *
+ * const visitor = {
+ *   FunctionDeclaration: {
+ *     enter(path) {
+ *       const handle = tracker.enterScope({
+ *         segment: path.node.id.name,
+ *         kind: 'function'
+ *       });
+ *     },
+ *     exit(path) {
+ *       tracker.exitScope(handle);
+ *     }
+ *   }
+ * };
+ * ```
+ */
+declare const createCanonicalTracker: (options: {
+  filePath: string;
+  getExportName?: (localName: string) => string | undefined;
+}) => CanonicalPathTracker;
+/**
+ * Helper to create occurrence tracker (for backward compatibility)
+ */
+declare const createOccurrenceTracker: () => {
+  getNextOccurrence: (key: string) => number;
+};
+/**
+ * Helper to create path tracker (for backward compatibility)
+ */
+declare const createPathTracker: () => {
+  ensureUniquePath: (basePath: string) => string;
+};
+/**
+ * Build AST path from scope stack (for backward compatibility)
+ */
+declare const buildAstPath: (stack: readonly ScopeFrame[]) => string;
+//#endregion
+export { CanonicalId, CanonicalIdSchema, CanonicalPathTracker, ScopeFrame, ScopeHandle, buildAstPath, createCanonicalId, createCanonicalTracker, createOccurrenceTracker, createPathTracker };
+//# sourceMappingURL=index-D6Lx478n.d.ts.map

package/dist/index-D6Lx478n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-D6Lx478n.d.ts","names":[],"sources":["../src/canonical-id/canonical-id.ts","../src/canonical-id/path-tracker.ts"],"sourcesContent":[],"mappings":";;;KAIY,WAAA;;AAAZ,CAAA;AAIa,cAAA,iBAA2F,EAAxE,GAAA,CAAE,OAAsE,CAA9D,WAA8D,CAAA;AAAA,cAG3F,iBAH2F,EAAA,CAAA,QAAA,EAAA,MAAA,EAAA,OAAA,EAAA,MAAA,EAAA,GAGlC,WAHkC;;;;ACiCxG;;;AAM0F,KA1B9E,UAAA,GA0B8E;;WAuBnD,WAAA,EAAA,MAAA;EAAW;EAiDrC,SAAA,IAAA,EAAA,UAkGZ,GAAA,OAAA,GA/FG,UAAA,GAAA,UA+FH,GAAA,QAAA,GAAA,YAAA;EAKY;EAiBA,SAAA,UAAA,EAiBZ,MAAA;AAKD,CAAA;;;;KApOY,WAAA;;;;;;;UAQK,oBAAA;;;;;;;;UAM8B;;MAA2C;;;;;oBAMtE;;;;;;;;;;;;;;;uCAiBmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiD1B;;;MAGT;;;;cAoGS;;;;;;cAiBA;;;;;;cAsBA,+BAAgC"}

package/dist/index-DN4VW1v7.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+//#region packages/common/src/zod/schema-helper.d.ts
+type SchemaFor<TOutput> = z.ZodType<TOutput, any, any>;
+type ShapeFor<TOutput extends object> = { [K in keyof TOutput]-?: SchemaFor<TOutput[K]> };
+declare function defineSchemaFor<TOutput extends object>(): <TShape extends ShapeFor<NoInfer<TOutput>>>(shape: TShape & { [K in Exclude<keyof TShape, keyof TOutput>]: never }) => z.ZodObject<TShape & { [K in Exclude<keyof TShape, keyof TOutput>]: never } extends infer T ? { -readonly [P in keyof T]: T[P] } : never, z.core.$strict>;
+//#endregion
+export { SchemaFor, ShapeFor, defineSchemaFor };
+//# sourceMappingURL=index-DN4VW1v7.d.ts.map

package/dist/index-DN4VW1v7.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DN4VW1v7.d.ts","names":[],"sources":["../src/zod/schema-helper.ts"],"sourcesContent":[],"mappings":";;;KAGY,qBAAqB,CAAA,CAAE,QAAQ;KAE/B,2CAFA,MAEiD,OAFxC,KAEoD,SAFpD,CAE8D,OAF9D,CAEsE,CAFtE,CAAA,CAAA,EAAA;AAAsB,iBAI3B,eAJ2B,CAAA,gBAAA,MAAA,CAAA,CAAA,CAAA,EAAA,CAAA,eAKlB,QALkB,CAKT,OALS,CAKD,OALC,CAAA,CAAA,CAAA,CAAA,KAAA,EAKiB,MALjB,GAAA,QAKkC,OALlC,CAAA,MAKgD,MALhD,EAAA,MAK8D,OAL9D,CAAA,GAAA,KAAA,EAAA,EAAA,GAKgF,CAAA,CAAA,SALhF,CAKgF,MALhF,GAAA,QAK8B,OAL9B,CAAA,MAK8B,MAL9B,EAAA,MAK8B,OAL9B,CAAA,GAAA,KAAA,EAAA,SAAA,KAAA,EAAA,GAAA,kBAAA,MAK8B,CAL9B,GAK8B,CAL9B,CAK8B,CAL9B,CAAA,EAAA,GAAA,KAAA,EAK8B,CAAA,CAAA,IAAA,CAAA,OAL9B,CAAA"}

package/dist/index-Fi3RpHje.d.cts

@@ -0,0 +1,60 @@
+//#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 by precedence: TypeScript, then JavaScript.
+ */
+declare const MODULE_EXTENSION_CANDIDATES: readonly [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+/**
+ * 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 { MODULE_EXTENSION_CANDIDATES, cachedFn, isExternalSpecifier, isRelativeSpecifier, normalizePath, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences };
+//# sourceMappingURL=index-Fi3RpHje.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-Fi3RpHje.d.cts","names":[],"sources":["../src/utils/cached-fn.ts","../src/utils/path.ts"],"sourcesContent":[],"mappings":";cAAa,wBAAyB;EAAzB,EAAA,GAAA;EASZ,KAAA,EAAA,EAAA,IAAA;;;;;AATD;;;cCOa;;;;;AAAA,cAMA,aANqG,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GAAA,MAAA;AAMlH;AAUA;;;;;AAyCA;;AAAuD,cAzC1C,uCAyC0C,EAAA,CAAA;EAAA,QAAA;EAAA;CAAA,EAAA;UAAA,EAAA,MAAA;WAAA,EAAA,MAAA;YAO7B,GAAA,IAAA;;;;AA+B1B;AAKA;;;;cA3Ca;;;;;;;cAOC,YAAY,KAAK;;;;;cA+BlB;;;;cAKA"}

package/dist/index-LjtXZhxM.d.ts

@@ -0,0 +1,88 @@
+//#region packages/common/src/portable/fs.d.ts
+/**
+ * Portable filesystem API that works on both Bun and Node.js
+ */
+interface PortableFS {
+  readFile(path: string): Promise<string>;
+  writeFile(path: string, content: string): Promise<void>;
+  exists(path: string): Promise<boolean>;
+  stat(path: string): Promise<{
+    mtime: Date;
+    size: number;
+  }>;
+  rename(oldPath: string, newPath: string): Promise<void>;
+  mkdir(path: string, options?: {
+    recursive?: boolean;
+  }): Promise<void>;
+}
+declare function createPortableFS(): PortableFS;
+declare function getPortableFS(): PortableFS;
+/**
+ * Reset the filesystem singleton for testing
+ * @internal
+ */
+declare function __resetPortableFSForTests(): void;
+//#endregion
+//#region packages/common/src/portable/hash.d.ts
+/**
+ * Portable hashing API that works on both Bun and Node.js
+ */
+type HashAlgorithm = "sha256" | "xxhash";
+interface PortableHasher {
+  hash(content: string, algorithm?: HashAlgorithm): string;
+}
+declare function createPortableHasher(): PortableHasher;
+declare function getPortableHasher(): PortableHasher;
+/**
+ * Reset the hasher singleton for testing
+ * @internal
+ */
+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
+ */
+declare const runtime: {
+  readonly isBun: boolean;
+  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 { type HashAlgorithm, type PortableFS, type PortableHasher, type SpawnOptions, type SpawnResult, __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, generateId, getPortableFS, getPortableHasher, once, resetPortableForTests, runtime, spawn };
+//# sourceMappingURL=index-LjtXZhxM.d.ts.map

package/dist/index-LjtXZhxM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-LjtXZhxM.d.ts","names":[],"sources":["../src/portable/fs.ts","../src/portable/hash.ts","../src/portable/id.ts","../src/portable/runtime.ts","../src/portable/spawn.ts"],"sourcesContent":[],"mappings":";;AAMA;;AAC0B,UADT,UAAA,CACS;UACkB,CAAA,IAAA,EAAA,MAAA,CAAA,EADlB,OACkB,CAAA,MAAA,CAAA;WACpB,CAAA,IAAA,EAAA,MAAA,EAAA,OAAA,EAAA,MAAA,CAAA,EADoB,OACpB,CAAA,IAAA,CAAA;QACe,CAAA,IAAA,EAAA,MAAA,CAAA,EADf,OACe,CAAA,OAAA,CAAA;MAAjB,CAAA,IAAA,EAAA,MAAA,CAAA,EAAA,OAAA,CAAA;IACsB,KAAA,EADL,IACK;IACc,IAAA,EAAA,MAAA;EAAO,CAAA,CAAA;EAsBjD,MAAA,CAAA,OAAA,EAAA,MAAgB,EAAA,OAAI,EAAA,MAAA,CAAA,EAvBQ,OAuBE,CAAA,IAAA,CAAA;EA4F9B,KAAA,CAAA,IAAA,EAAA,MAAa,EAAA,QAAI,EAAA;IAWjB,SAAA,CAAA,EAAA,OAAA;MA7H0C;;iBAsB1C,gBAAA,CAAA,GAAoB;AC5BxB,iBDwHI,aAAA,CAAA,CCxHS,EDwHQ,UCxHR;AAEzB;AAWA;AAqCA;AAWA;iBDsEgB,yBAAA,CAAA;;;;AAnIhB;;AAC0B,KCDd,aAAA,GDCc,QAAA,GAAA,QAAA;AACkB,UCA3B,cAAA,CDA2B;MACpB,CAAA,OAAA,EAAA,MAAA,EAAA,SAAA,CAAA,ECAY,aDAZ,CAAA,EAAA,MAAA;;AACF,iBCSN,oBAAA,CAAA,CDTM,ECSkB,cDTlB;AACsB,iBC6C5B,iBAAA,CAAA,CD7C4B,EC6CP,cD7CO;;;AAuB5C;AA4FA;AAWgB,iBCtEA,6BAAA,CAAA,CDsEyB,EAAA,IAAA;;;;AAnIzC;;;;;;AAIsB,iBEAN,UAAA,CAAA,CFAM,EAAA,MAAA;;;;AAJtB;;AAC0B,cGHb,OHGa,EAAA;WACkB,KAAA,EAAA,OAAA;WACpB,MAAA,EAAA,OAAA;WACe,iBAAA,EAAA,OAAA;;;;;AAwBvB,iBGrBA,IHqBgB,CAAA,CAAA,CAAA,CAAA,EAAI,EAAA,GAAA,GGrBF,CHqBE,CAAA,EAAU,GAAA,GGrBF,CHqBE;AA4F9C;AAWA;;;iBG3GgB,qBAAA,CAAA;;;;AHxBhB;;AAC0B,UIDT,YAAA,CJCS;KACkB,EAAA,MAAA,EAAA;KACpB,CAAA,EAAA,MAAA;KACe,CAAA,EID/B,MJC+B,CAAA,MAAA,EAAA,MAAA,CAAA;;AACK,UIC3B,WAAA,CJD2B;QACc,EAAA,MAAA;EAAO,MAAA,EAAA,MAAA;EAsBjD,QAAA,EAAA,MAAA;AA4FhB;AAWgB,iBIvHM,KAAA,CJuHN,OAAyB,EIvHJ,YJuHI,CAAA,EIvHW,OJuHX,CIvHmB,WJuHnB,CAAA"}

package/dist/index.cjs

@@ -0,0 +1,30 @@
+const require_utils = require('./utils-NBAPoMgh.cjs');
+const require_canonical_id = require('./canonical-id-CE4Xjo2C.cjs');
+const require_portable = require('./portable-Bq_Qob6b.cjs');
+const require_zod = require('./zod-B1gOOwdX.cjs');
+
+exports.CanonicalIdSchema = require_canonical_id.CanonicalIdSchema;
+exports.MODULE_EXTENSION_CANDIDATES = require_utils.MODULE_EXTENSION_CANDIDATES;
+exports.__resetPortableFSForTests = require_portable.__resetPortableFSForTests;
+exports.__resetPortableHasherForTests = require_portable.__resetPortableHasherForTests;
+exports.buildAstPath = require_canonical_id.buildAstPath;
+exports.cachedFn = require_utils.cachedFn;
+exports.createCanonicalId = require_canonical_id.createCanonicalId;
+exports.createCanonicalTracker = require_canonical_id.createCanonicalTracker;
+exports.createOccurrenceTracker = require_canonical_id.createOccurrenceTracker;
+exports.createPathTracker = require_canonical_id.createPathTracker;
+exports.createPortableFS = require_portable.createPortableFS;
+exports.createPortableHasher = require_portable.createPortableHasher;
+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.isRelativeSpecifier = require_utils.isRelativeSpecifier;
+exports.normalizePath = require_utils.normalizePath;
+exports.once = require_portable.once;
+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;

package/dist/index.d.cts

@@ -0,0 +1,5 @@
+import { CanonicalId, CanonicalIdSchema, CanonicalPathTracker, ScopeFrame, ScopeHandle, buildAstPath, createCanonicalId, createCanonicalTracker, createOccurrenceTracker, createPathTracker } from "./index-C8yyrGd7.cjs";
+import { HashAlgorithm, PortableFS, PortableHasher, SpawnOptions, SpawnResult, __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, generateId, getPortableFS, getPortableHasher, once, resetPortableForTests, runtime, spawn } from "./index-C0n5gWc3.cjs";
+import { MODULE_EXTENSION_CANDIDATES, cachedFn, isExternalSpecifier, isRelativeSpecifier, normalizePath, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences } from "./index-Fi3RpHje.cjs";
+import { SchemaFor, ShapeFor, defineSchemaFor } from "./index-B_QJzQA2.cjs";
+export { CanonicalId, CanonicalIdSchema, CanonicalPathTracker, HashAlgorithm, MODULE_EXTENSION_CANDIDATES, PortableFS, PortableHasher, SchemaFor, ScopeFrame, ScopeHandle, ShapeFor, SpawnOptions, SpawnResult, __resetPortableFSForTests, __resetPortableHasherForTests, buildAstPath, cachedFn, createCanonicalId, createCanonicalTracker, createOccurrenceTracker, createPathTracker, createPortableFS, createPortableHasher, defineSchemaFor, generateId, getPortableFS, getPortableHasher, isExternalSpecifier, isRelativeSpecifier, normalizePath, once, resetPortableForTests, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences, runtime, spawn };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { CanonicalId, CanonicalIdSchema, CanonicalPathTracker, ScopeFrame, ScopeHandle, buildAstPath, createCanonicalId, createCanonicalTracker, createOccurrenceTracker, createPathTracker } from "./index-D6Lx478n.js";
+import { HashAlgorithm, PortableFS, PortableHasher, SpawnOptions, SpawnResult, __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, generateId, getPortableFS, getPortableHasher, once, resetPortableForTests, runtime, spawn } from "./index-LjtXZhxM.js";
+import { MODULE_EXTENSION_CANDIDATES, cachedFn, isExternalSpecifier, isRelativeSpecifier, normalizePath, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences } from "./index-CcSB32XQ.js";
+import { SchemaFor, ShapeFor, defineSchemaFor } from "./index-DN4VW1v7.js";
+export { CanonicalId, CanonicalIdSchema, CanonicalPathTracker, HashAlgorithm, MODULE_EXTENSION_CANDIDATES, PortableFS, PortableHasher, SchemaFor, ScopeFrame, ScopeHandle, ShapeFor, SpawnOptions, SpawnResult, __resetPortableFSForTests, __resetPortableHasherForTests, buildAstPath, cachedFn, createCanonicalId, createCanonicalTracker, createOccurrenceTracker, createPathTracker, createPortableFS, createPortableHasher, defineSchemaFor, generateId, getPortableFS, getPortableHasher, isExternalSpecifier, isRelativeSpecifier, normalizePath, once, resetPortableForTests, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences, runtime, spawn };

package/dist/index.js

@@ -0,0 +1,6 @@
+import { __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, generateId, getPortableFS, getPortableHasher, once, resetPortableForTests, runtime, spawn } from "./portable-BqSEwase.js";
+import { MODULE_EXTENSION_CANDIDATES, cachedFn, isExternalSpecifier, isRelativeSpecifier, normalizePath, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences } from "./utils-DxBnV8tL.js";
+import { CanonicalIdSchema, buildAstPath, createCanonicalId, createCanonicalTracker, createOccurrenceTracker, createPathTracker } from "./canonical-id-Bn6ZPdZl.js";
+import { defineSchemaFor } from "./zod-BPbnZc6i.js";
+
+export { CanonicalIdSchema, MODULE_EXTENSION_CANDIDATES, __resetPortableFSForTests, __resetPortableHasherForTests, buildAstPath, cachedFn, createCanonicalId, createCanonicalTracker, createOccurrenceTracker, createPathTracker, createPortableFS, createPortableHasher, defineSchemaFor, generateId, getPortableFS, getPortableHasher, isExternalSpecifier, isRelativeSpecifier, normalizePath, once, resetPortableForTests, resolveRelativeImportWithExistenceCheck, resolveRelativeImportWithReferences, runtime, spawn };

package/dist/portable/index.cjs

@@ -0,0 +1,13 @@
+const require_portable = require('../portable-Bq_Qob6b.cjs');
+
+exports.__resetPortableFSForTests = require_portable.__resetPortableFSForTests;
+exports.__resetPortableHasherForTests = require_portable.__resetPortableHasherForTests;
+exports.createPortableFS = require_portable.createPortableFS;
+exports.createPortableHasher = require_portable.createPortableHasher;
+exports.generateId = require_portable.generateId;
+exports.getPortableFS = require_portable.getPortableFS;
+exports.getPortableHasher = require_portable.getPortableHasher;
+exports.once = require_portable.once;
+exports.resetPortableForTests = require_portable.resetPortableForTests;
+exports.runtime = require_portable.runtime;
+exports.spawn = require_portable.spawn;

package/dist/portable/index.d.cts

@@ -0,0 +1,2 @@
+import { HashAlgorithm, PortableFS, PortableHasher, SpawnOptions, SpawnResult, __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, generateId, getPortableFS, getPortableHasher, once, resetPortableForTests, runtime, spawn } from "../index-C0n5gWc3.cjs";
+export { HashAlgorithm, PortableFS, PortableHasher, SpawnOptions, SpawnResult, __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, generateId, getPortableFS, getPortableHasher, once, resetPortableForTests, runtime, spawn };

package/dist/portable/index.d.ts

@@ -0,0 +1,2 @@
+import { HashAlgorithm, PortableFS, PortableHasher, SpawnOptions, SpawnResult, __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, generateId, getPortableFS, getPortableHasher, once, resetPortableForTests, runtime, spawn } from "../index-LjtXZhxM.js";
+export { HashAlgorithm, PortableFS, PortableHasher, SpawnOptions, SpawnResult, __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, generateId, getPortableFS, getPortableHasher, once, resetPortableForTests, runtime, spawn };

package/dist/portable/index.js

@@ -0,0 +1,3 @@
+import { __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, generateId, getPortableFS, getPortableHasher, once, resetPortableForTests, runtime, spawn } from "../portable-BqSEwase.js";
+
+export { __resetPortableFSForTests, __resetPortableHasherForTests, createPortableFS, createPortableHasher, generateId, getPortableFS, getPortableHasher, once, resetPortableForTests, runtime, spawn };