@tyndall/shared 0.0.1

package/README.md

@@ -0,0 +1,29 @@
+# @tyndall/shared
+
+## Overview
+Shared utility package for hashing, file operations, timing, cache keys, and platform metadata.
+
+## Responsibilities
+- Provide deterministic hashing and stable serialization helpers
+- Provide safe file and cache utility primitives
+- Keep reusable cross-package helpers independent of framework layers
+- Provide shared logger primitives with severity filtering and readable level-based formatting
+
+## Public API Highlights
+- hash and normalizePath
+- readFileSafe and writeFileAtomic
+- computeCacheRootKey and resolveCacheRoot
+
+## Development
+- Build: bun run --filter @tyndall/shared build
+- Test (from workspace root): bun test
+
+## Documentation
+- Package specification: [spec.md](./spec.md)
+- Package architecture: [architecture.md](./architecture.md)
+- Package changes: [CHANGELOG.md](./CHANGELOG.md)
+
+## Maintenance Rules
+- Keep this document aligned with implemented package behavior.
+- Update spec.md and architecture.md whenever package contracts or design boundaries change.
+- Record user-visible package changes in CHANGELOG.md.

package/dist/cache-root.d.ts

@@ -0,0 +1,10 @@
+export interface CacheRootKeyInput {
+    projectId: string;
+    hyperVersion: string;
+    bunVersion: string;
+    uiAdapter: string;
+    osArch: string;
+}
+export declare const computeCacheRootKey: (input: CacheRootKeyInput) => string;
+export declare const resolveCacheRoot: (cacheDir: string, rootKey: string) => string;
+//# sourceMappingURL=cache-root.d.ts.map

package/dist/cache-root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-root.d.ts","sourceRoot":"","sources":["../src/cache-root.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,mBAAmB,GAAI,OAAO,iBAAiB,KAAG,MACjC,CAAC;AAE/B,eAAO,MAAM,gBAAgB,GAAI,UAAU,MAAM,EAAE,SAAS,MAAM,KAAG,MAC5C,CAAC"}

package/dist/cache-root.js

@@ -0,0 +1,4 @@
+import { join } from "node:path";
+import { hash, stableStringify } from "./hashing.js";
+export const computeCacheRootKey = (input) => hash(stableStringify(input));
+export const resolveCacheRoot = (cacheDir, rootKey) => join(cacheDir, rootKey);

package/dist/fs.d.ts

@@ -0,0 +1,7 @@
+export type WriteFileAtomicOptions = {
+    encoding?: BufferEncoding;
+    mode?: number;
+};
+export declare const readFileSafe: (filePath: string, encoding?: BufferEncoding) => Promise<string | Buffer | null>;
+export declare const writeFileAtomic: (filePath: string, data: string | Buffer | Uint8Array, options?: WriteFileAtomicOptions) => Promise<void>;
+//# sourceMappingURL=fs.d.ts.map

package/dist/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,UAAU,MAAM,EAChB,WAAW,cAAc,KACxB,OAAO,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,CAYhC,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,UAAU,MAAM,EAChB,MAAM,MAAM,GAAG,MAAM,GAAG,UAAU,EAClC,UAAS,sBAA2B,KACnC,OAAO,CAAC,IAAI,CAmBd,CAAC"}

package/dist/fs.js

@@ -0,0 +1,37 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { randomUUID } from "node:crypto";
+export const readFileSafe = async (filePath, encoding) => {
+    try {
+        if (encoding) {
+            return await readFile(filePath, encoding);
+        }
+        return await readFile(filePath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+};
+export const writeFileAtomic = async (filePath, data, options = {}) => {
+    const dir = dirname(filePath);
+    await mkdir(dir, { recursive: true });
+    const tempPath = `${filePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+    await writeFile(tempPath, data, options);
+    try {
+        await rename(tempPath, filePath);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "EEXIST" || code === "EPERM") {
+            await rm(filePath, { force: true });
+            await rename(tempPath, filePath);
+        }
+        else {
+            await rm(tempPath, { force: true });
+            throw error;
+        }
+    }
+};

package/dist/hashing.d.ts

@@ -0,0 +1,9 @@
+export type HashInput = string | ArrayBuffer | Uint8Array;
+export declare const normalizeLineEndings: (value: string) => string;
+export declare const normalizePath: (value: string) => string;
+export declare const stableStringify: (value: unknown) => string;
+export declare const hash: (input: HashInput) => string;
+export declare const moduleContentHash: (content: string) => string;
+export declare const configHash: (config: unknown) => string;
+export declare const paramsKey: (params: unknown) => string;
+//# sourceMappingURL=hashing.d.ts.map

package/dist/hashing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashing.d.ts","sourceRoot":"","sources":["../src/hashing.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,UAAU,CAAC;AAiC1D,eAAO,MAAM,oBAAoB,GAAI,OAAO,MAAM,KAAG,MACtB,CAAC;AAEhC,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,KAAG,MAAmC,CAAC;AA4ClF,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,MACT,CAAC;AAEzC,eAAO,MAAM,IAAI,GAAI,OAAO,SAAS,KAAG,MAIvC,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,SAAS,MAAM,KAAG,MACf,CAAC;AAEtC,eAAO,MAAM,UAAU,GAAI,QAAQ,OAAO,KAAG,MAAuC,CAAC;AAErF,eAAO,MAAM,SAAS,GAAI,QAAQ,OAAO,KAAG,MAAiC,CAAC"}

package/dist/hashing.js

@@ -0,0 +1,65 @@
+import { createHash } from "node:crypto";
+const encoder = new TextEncoder();
+const isPlainObject = (value) => {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+};
+const toHashBuffer = (input) => {
+    if (typeof input === "string") {
+        return encoder.encode(input);
+    }
+    if (input instanceof ArrayBuffer) {
+        return new Uint8Array(input);
+    }
+    if (input instanceof Uint8Array) {
+        return input;
+    }
+    return encoder.encode(String(input));
+};
+export const normalizeLineEndings = (value) => value.replace(/\r\n?/g, "\n");
+export const normalizePath = (value) => value.replace(/\\/g, "/");
+const stableSortValue = (value) => {
+    if (value === null || typeof value !== "object") {
+        if (typeof value === "bigint") {
+            return value.toString();
+        }
+        if (typeof value === "undefined") {
+            return null;
+        }
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => stableSortValue(entry));
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (value instanceof Map) {
+        const entries = Array.from(value.entries()).sort(([a], [b]) => String(a).localeCompare(String(b)));
+        return entries.map(([key, val]) => [String(key), stableSortValue(val)]);
+    }
+    if (value instanceof Set) {
+        const entries = Array.from(value.values()).map((entry) => stableSortValue(entry));
+        return entries.sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
+    }
+    if (isPlainObject(value)) {
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            sorted[key] = stableSortValue(value[key]);
+        }
+        return sorted;
+    }
+    return JSON.parse(JSON.stringify(value));
+};
+export const stableStringify = (value) => JSON.stringify(stableSortValue(value));
+export const hash = (input) => {
+    const hashInstance = createHash("sha256");
+    hashInstance.update(toHashBuffer(input));
+    return hashInstance.digest("hex");
+};
+export const moduleContentHash = (content) => hash(normalizeLineEndings(content));
+export const configHash = (config) => hash(stableStringify(config));
+export const paramsKey = (params) => stableStringify(params);

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { hash, moduleContentHash, configHash, paramsKey, normalizeLineEndings, normalizePath, stableStringify, } from "./hashing.js";
+export type { HashInput } from "./hashing.js";
+export { createLogger } from "./logger.js";
+export type { Logger, LoggerOptions, LogLevel } from "./logger.js";
+export { readFileSafe, writeFileAtomic } from "./fs.js";
+export type { WriteFileAtomicOptions } from "./fs.js";
+export { measure } from "./timing.js";
+export type { MeasureResult } from "./timing.js";
+export { computeCacheRootKey, resolveCacheRoot } from "./cache-root.js";
+export type { CacheRootKeyInput } from "./cache-root.js";
+export { getBunVersion, getOsArch } from "./runtime-info.js";
+export { buildModuleGraphSnapshot, computeGraphKey, readModuleGraphCache, writeModuleGraphCache, DEFAULT_IMPORT_EXTENSIONS, } from "./module-graph.js";
+export type { ModuleGraphSnapshot, ModuleGraphCache } from "./module-graph.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EACJ,iBAAiB,EACjB,UAAU,EACV,SAAS,EACT,oBAAoB,EACpB,aAAa,EACb,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEnE,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AACxD,YAAY,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEtD,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACtC,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxE,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,EACL,wBAAwB,EACxB,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export { hash, moduleContentHash, configHash, paramsKey, normalizeLineEndings, normalizePath, stableStringify, } from "./hashing.js";
+export { createLogger } from "./logger.js";
+export { readFileSafe, writeFileAtomic } from "./fs.js";
+export { measure } from "./timing.js";
+export { computeCacheRootKey, resolveCacheRoot } from "./cache-root.js";
+export { getBunVersion, getOsArch } from "./runtime-info.js";
+export { buildModuleGraphSnapshot, computeGraphKey, readModuleGraphCache, writeModuleGraphCache, DEFAULT_IMPORT_EXTENSIONS, } from "./module-graph.js";

package/dist/logger.d.ts

@@ -0,0 +1,21 @@
+export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal";
+export interface LoggerOptions {
+    level?: LogLevel;
+    json?: boolean;
+    prefix?: string;
+    color?: boolean;
+    meta?: Record<string, unknown>;
+    sink?: (level: LogLevel, line: string) => void;
+    time?: () => string;
+}
+export interface Logger {
+    level: LogLevel;
+    child: (meta: Record<string, unknown>) => Logger;
+    debug: (message: string, meta?: Record<string, unknown>) => void;
+    info: (message: string, meta?: Record<string, unknown>) => void;
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+    error: (message: string, meta?: Record<string, unknown>) => void;
+    fatal: (message: string, meta?: Record<string, unknown>) => void;
+}
+export declare const createLogger: (options?: LoggerOptions) => Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAErE,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/C,IAAI,CAAC,EAAE,MAAM,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,QAAQ,CAAC;IAChB,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC;IACjD,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACjE,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAChE,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAChE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACjE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;CAClE;AAoFD,eAAO,MAAM,YAAY,GAAI,UAAS,aAAkB,KAAG,MA0C1D,CAAC"}

package/dist/logger.js

@@ -0,0 +1,103 @@
+const levelOrder = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+    fatal: 50,
+};
+const defaultTime = () => new Date().toISOString();
+const ANSI = {
+    reset: "\u001b[0m",
+    gray: "\u001b[90m",
+    cyan: "\u001b[36m",
+    yellow: "\u001b[33m",
+    red: "\u001b[31m",
+    fatal: "\u001b[97;41m",
+};
+const levelColor = {
+    debug: ANSI.gray,
+    info: ANSI.cyan,
+    warn: ANSI.yellow,
+    error: ANSI.red,
+    fatal: ANSI.fatal,
+};
+const defaultSink = (level, line) => {
+    if (level === "fatal" || level === "error") {
+        console.error(line);
+        return;
+    }
+    if (level === "warn") {
+        console.warn(line);
+        return;
+    }
+    console.log(line);
+};
+const shouldUseColor = () => {
+    if (process.env.NO_COLOR) {
+        return false;
+    }
+    if (process.env.CI) {
+        return false;
+    }
+    return Boolean(process.stdout.isTTY);
+};
+const colorizeLevel = (level, label, enabled) => {
+    if (!enabled) {
+        return label;
+    }
+    const color = levelColor[level];
+    return `${color}${label}${ANSI.reset}`;
+};
+const formatLine = (level, message, meta, options) => {
+    const payload = {
+        level,
+        msg: message,
+        time: options.time(),
+        ...meta,
+    };
+    if (options.json) {
+        return JSON.stringify(payload);
+    }
+    const prefix = options.prefix ? `[${options.prefix}] ` : "";
+    const levelLabel = colorizeLevel(level, level.toUpperCase(), options.color);
+    const metaKeys = Object.keys(meta);
+    if (metaKeys.length === 0) {
+        return `${prefix}${levelLabel}: ${message}`;
+    }
+    return `${prefix}${levelLabel}: ${message} ${JSON.stringify(meta)}`;
+};
+export const createLogger = (options = {}) => {
+    const baseOptions = {
+        level: options.level ?? "info",
+        json: options.json ?? false,
+        prefix: options.prefix ?? "",
+        color: options.color ?? shouldUseColor(),
+        meta: options.meta ?? {},
+        sink: options.sink ?? defaultSink,
+        time: options.time ?? defaultTime,
+    };
+    const makeLogger = (meta) => {
+        const log = (level, message, extra) => {
+            if (levelOrder[level] < levelOrder[baseOptions.level]) {
+                return;
+            }
+            const line = formatLine(level, message, { ...meta, ...(extra ?? {}) }, {
+                json: baseOptions.json,
+                prefix: baseOptions.prefix,
+                color: baseOptions.color,
+                time: baseOptions.time,
+            });
+            baseOptions.sink(level, line);
+        };
+        return {
+            level: baseOptions.level,
+            child: (childMeta) => makeLogger({ ...meta, ...childMeta }),
+            debug: (message, extra) => log("debug", message, extra),
+            info: (message, extra) => log("info", message, extra),
+            warn: (message, extra) => log("warn", message, extra),
+            error: (message, extra) => log("error", message, extra),
+            fatal: (message, extra) => log("fatal", message, extra),
+        };
+    };
+    return makeLogger(baseOptions.meta);
+};

package/dist/module-graph.d.ts

@@ -0,0 +1,26 @@
+export type ModuleGraphSnapshot = {
+    moduleGraph: Record<string, string[]>;
+    routeToModules: Record<string, string[]>;
+    moduleToRoutes: Record<string, string[]>;
+};
+export declare const DEFAULT_IMPORT_EXTENSIONS: string[];
+type RouteEntry = {
+    id: string;
+    filePath: string;
+};
+export declare const buildModuleGraphSnapshot: (routes: RouteEntry[], options?: {
+    extensions?: string[];
+}) => ModuleGraphSnapshot;
+export type ModuleGraphCache = ModuleGraphSnapshot & {
+    graphKey: string;
+    generatedAt: number;
+};
+export declare const readModuleGraphCache: (cacheDir: string, graphKey: string) => Promise<ModuleGraphSnapshot | null>;
+export declare const writeModuleGraphCache: (cacheDir: string, graphKey: string, snapshot: ModuleGraphSnapshot) => Promise<void>;
+export declare const computeGraphKey: (input: {
+    lockfileHash: string;
+    tsconfigHash: string;
+    bundlerOptionsHash: string;
+}) => string;
+export {};
+//# sourceMappingURL=module-graph.d.ts.map

package/dist/module-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-graph.d.ts","sourceRoot":"","sources":["../src/module-graph.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACtC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACzC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CAC1C,CAAC;AAEF,eAAO,MAAM,yBAAyB,UASrC,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAsIF,eAAO,MAAM,wBAAwB,GACnC,QAAQ,UAAU,EAAE,EACpB,UAAS;IAAE,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAO,KACtC,mBA6BF,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,mBAAmB,GAAG;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAkDF,eAAO,MAAM,oBAAoB,GAC/B,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAiBpC,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,UAAU,MAAM,EAChB,UAAU,MAAM,EAChB,UAAU,mBAAmB,KAC5B,OAAO,CAAC,IAAI,CA0Cd,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,OAAO;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,KAAG,MAAsC,CAAC"}

package/dist/module-graph.js

@@ -0,0 +1,231 @@
+import { readFileSync, statSync } from "node:fs";
+import { dirname, extname, join, resolve } from "node:path";
+import { hash, normalizePath, stableStringify } from "./hashing.js";
+import { readFileSafe, writeFileAtomic } from "./fs.js";
+export const DEFAULT_IMPORT_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts",
+];
+const extractImportSpecifiers = (source) => {
+    const specifiers = [];
+    const regex = /(?:import|export)\s+[^'"]*?from\s*['"]([^'"]+)['"]|import\s*['"]([^'"]+)['"]|import\(\s*['"]([^'"]+)['"]\s*\)|require\(\s*['"]([^'"]+)['"]\s*\)/g;
+    let match;
+    while ((match = regex.exec(source)) !== null) {
+        const specifier = match[1] ?? match[2] ?? match[3] ?? match[4];
+        if (specifier) {
+            specifiers.push(specifier);
+        }
+    }
+    return specifiers;
+};
+const resolveModulePath = (baseDir, specifier, extensions) => {
+    const candidate = resolve(baseDir, specifier);
+    const extension = extname(candidate);
+    const tryFile = (filePath) => {
+        try {
+            const stats = statSync(filePath);
+            if (stats.isFile()) {
+                return filePath;
+            }
+            if (stats.isDirectory()) {
+                for (const ext of extensions) {
+                    const indexPath = join(filePath, `index${ext}`);
+                    try {
+                        const indexStats = statSync(indexPath);
+                        if (indexStats.isFile()) {
+                            return indexPath;
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    };
+    if (extension) {
+        return tryFile(candidate);
+    }
+    for (const ext of extensions) {
+        const resolved = tryFile(`${candidate}${ext}`);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return tryFile(candidate);
+};
+const buildModuleGraph = (entryPaths, extensions) => {
+    const graph = {};
+    const visited = new Set();
+    const stack = entryPaths.map((entry) => normalizePath(resolve(entry)));
+    while (stack.length > 0) {
+        const modulePath = stack.pop();
+        if (!modulePath || visited.has(modulePath)) {
+            continue;
+        }
+        visited.add(modulePath);
+        let deps = [];
+        try {
+            const source = readFileSync(modulePath, "utf-8");
+            const specifiers = extractImportSpecifiers(source);
+            const baseDir = dirname(modulePath);
+            for (const specifier of specifiers) {
+                if (!specifier.startsWith(".")) {
+                    continue;
+                }
+                const resolved = resolveModulePath(baseDir, specifier, extensions);
+                if (!resolved) {
+                    continue;
+                }
+                const normalized = normalizePath(resolved);
+                deps.push(normalized);
+                if (!visited.has(normalized)) {
+                    stack.push(normalized);
+                }
+            }
+        }
+        catch {
+            deps = [];
+        }
+        const uniqueDeps = Array.from(new Set(deps)).sort((a, b) => a.localeCompare(b));
+        graph[modulePath] = uniqueDeps;
+    }
+    return graph;
+};
+const collectTransitiveModules = (entry, graph) => {
+    const normalizedEntry = normalizePath(resolve(entry));
+    const visited = new Set();
+    const stack = [normalizedEntry];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current || visited.has(current)) {
+            continue;
+        }
+        visited.add(current);
+        const deps = graph[current] ?? [];
+        for (const dep of deps) {
+            if (!visited.has(dep)) {
+                stack.push(dep);
+            }
+        }
+    }
+    return Array.from(visited).sort((a, b) => a.localeCompare(b));
+};
+export const buildModuleGraphSnapshot = (routes, options = {}) => {
+    const extensions = options.extensions ?? DEFAULT_IMPORT_EXTENSIONS;
+    const entryPaths = Array.from(new Set(routes.map((route) => normalizePath(resolve(route.filePath)))));
+    const moduleGraph = buildModuleGraph(entryPaths, extensions);
+    const routeToModules = {};
+    const moduleToRoutes = new Map();
+    for (const route of routes) {
+        const modules = collectTransitiveModules(route.filePath, moduleGraph);
+        routeToModules[route.id] = modules;
+        for (const modulePath of modules) {
+            const routesForModule = moduleToRoutes.get(modulePath) ?? new Set();
+            routesForModule.add(route.id);
+            moduleToRoutes.set(modulePath, routesForModule);
+        }
+    }
+    const moduleToRoutesRecord = {};
+    for (const [modulePath, routeIds] of moduleToRoutes.entries()) {
+        moduleToRoutesRecord[modulePath] = Array.from(routeIds).sort((a, b) => a.localeCompare(b));
+    }
+    return {
+        moduleGraph,
+        routeToModules,
+        moduleToRoutes: moduleToRoutesRecord,
+    };
+};
+const GRAPH_DIR = "graph";
+const MODULE_GRAPH_FILE = "moduleGraph.json";
+const ROUTE_TO_MODULES_FILE = "routeToModules.json";
+const MODULE_TO_ROUTES_FILE = "moduleToRoutes.json";
+const normalizeRecord = (record) => {
+    const normalized = {};
+    const keys = Object.keys(record).sort((a, b) => a.localeCompare(b));
+    for (const key of keys) {
+        normalized[key] = [...record[key]].sort((a, b) => a.localeCompare(b));
+    }
+    return normalized;
+};
+const ensureCachePayload = (graphKey, snapshot) => ({
+    graphKey,
+    generatedAt: Date.now(),
+    moduleGraph: normalizeRecord(snapshot.moduleGraph),
+    routeToModules: normalizeRecord(snapshot.routeToModules),
+    moduleToRoutes: normalizeRecord(snapshot.moduleToRoutes),
+});
+const parseCacheFile = (raw, expectedGraphKey, field) => {
+    if (!raw) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw.toString());
+        if (parsed.graphKey !== expectedGraphKey) {
+            return null;
+        }
+        const value = parsed[field];
+        if (!value || typeof value !== "object") {
+            return null;
+        }
+        return value;
+    }
+    catch {
+        return null;
+    }
+};
+export const readModuleGraphCache = async (cacheDir, graphKey) => {
+    const graphDir = join(cacheDir, GRAPH_DIR);
+    const [moduleGraphRaw, routeToModulesRaw, moduleToRoutesRaw] = await Promise.all([
+        readFileSafe(join(graphDir, MODULE_GRAPH_FILE)),
+        readFileSafe(join(graphDir, ROUTE_TO_MODULES_FILE)),
+        readFileSafe(join(graphDir, MODULE_TO_ROUTES_FILE)),
+    ]);
+    const moduleGraph = parseCacheFile(moduleGraphRaw, graphKey, "moduleGraph");
+    const routeToModules = parseCacheFile(routeToModulesRaw, graphKey, "routeToModules");
+    const moduleToRoutes = parseCacheFile(moduleToRoutesRaw, graphKey, "moduleToRoutes");
+    if (!moduleGraph || !routeToModules || !moduleToRoutes) {
+        return null;
+    }
+    return { moduleGraph, routeToModules, moduleToRoutes };
+};
+export const writeModuleGraphCache = async (cacheDir, graphKey, snapshot) => {
+    const graphDir = join(cacheDir, GRAPH_DIR);
+    const payload = ensureCachePayload(graphKey, snapshot);
+    const moduleGraphPayload = JSON.stringify({
+        graphKey: payload.graphKey,
+        generatedAt: payload.generatedAt,
+        moduleGraph: payload.moduleGraph,
+    }, null, 2);
+    const routeToModulesPayload = JSON.stringify({
+        graphKey: payload.graphKey,
+        generatedAt: payload.generatedAt,
+        routeToModules: payload.routeToModules,
+    }, null, 2);
+    const moduleToRoutesPayload = JSON.stringify({
+        graphKey: payload.graphKey,
+        generatedAt: payload.generatedAt,
+        moduleToRoutes: payload.moduleToRoutes,
+    }, null, 2);
+    // Important: use atomic writes to avoid partially written cache files.
+    await Promise.all([
+        writeFileAtomic(join(graphDir, MODULE_GRAPH_FILE), moduleGraphPayload, { encoding: "utf-8" }),
+        writeFileAtomic(join(graphDir, ROUTE_TO_MODULES_FILE), routeToModulesPayload, {
+            encoding: "utf-8",
+        }),
+        writeFileAtomic(join(graphDir, MODULE_TO_ROUTES_FILE), moduleToRoutesPayload, {
+            encoding: "utf-8",
+        }),
+    ]);
+};
+export const computeGraphKey = (input) => hash(stableStringify(input));

package/dist/runtime-info.d.ts

@@ -0,0 +1,3 @@
+export declare const getBunVersion: () => string;
+export declare const getOsArch: () => string;
+//# sourceMappingURL=runtime-info.d.ts.map

package/dist/runtime-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-info.d.ts","sourceRoot":"","sources":["../src/runtime-info.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,QAAO,MAGhC,CAAC;AAEF,eAAO,MAAM,SAAS,QAAO,MAA+C,CAAC"}

package/dist/runtime-info.js

@@ -0,0 +1,5 @@
+export const getBunVersion = () => {
+    const versions = process.versions;
+    return versions.bun ?? versions.node ?? process.version;
+};
+export const getOsArch = () => `${process.platform}-${process.arch}`;

package/dist/timing.d.ts

@@ -0,0 +1,7 @@
+export type MeasureResult<T> = {
+    name: string;
+    durationMs: number;
+    result: T;
+};
+export declare const measure: <T>(name: string, fn: () => T | Promise<T>) => MeasureResult<T> | Promise<MeasureResult<T>>;
+//# sourceMappingURL=timing.d.ts.map

package/dist/timing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.d.ts","sourceRoot":"","sources":["../src/timing.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,CAAC,CAAC;CACX,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,CAAC,EACvB,MAAM,MAAM,EACZ,IAAI,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,KACvB,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAa7C,CAAC"}

package/dist/timing.js

@@ -0,0 +1,14 @@
+import { performance } from "node:perf_hooks";
+export const measure = (name, fn) => {
+    const start = performance.now();
+    const finish = (result) => ({
+        name,
+        durationMs: performance.now() - start,
+        result,
+    });
+    const value = fn();
+    if (value instanceof Promise) {
+        return value.then((result) => finish(result));
+    }
+    return finish(value);
+};

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@tyndall/shared",
+  "version": "0.0.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}