@kici-dev/shared 0.0.0 → 0.1.1

package/dist/request-context.d.ts

@@ -0,0 +1,42 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/** Trace context fields propagated through the request lifecycle. */
+export interface RequestContext {
+    /** Unique trace ID for a webhook event (UUIDv4). Always present once set. */
+    requestId: string;
+    /** Workflow run ID, set when a workflow run is created. */
+    runId?: string;
+    /** Job ID, set when processing a specific job. */
+    jobId?: string;
+    /** Routing key (e.g. "github:12345"), set when handling a webhook for a source. */
+    routingKey?: string;
+    /** OTel trace ID, set when telemetry is active. */
+    traceId?: string;
+    /** OTel span ID, set when telemetry is active. */
+    spanId?: string;
+}
+/**
+ * AsyncLocalStorage instance for propagating request context
+ * through async call chains without explicit parameter passing.
+ *
+ * Usage:
+ * ```ts
+ * requestContext.run({ requestId: crypto.randomUUID() }, async () => {
+ *   // All code in this callback (and its async descendants) can read the context
+ *   log.info('Processing webhook'); // auto-enriched with requestId
+ * });
+ * ```
+ */
+export declare const requestContext: AsyncLocalStorage<RequestContext>;
+/**
+ * Get the current request context, or an empty object if outside a `run()` scope.
+ * Safe to call anywhere -- never throws.
+ */
+export declare function getRequestContext(): Partial<RequestContext>;
+/**
+ * Merge additional fields into the current request context.
+ * No-op if called outside a `run()` scope.
+ *
+ * @param fields - Partial context fields to merge into the current store
+ */
+export declare function enrichRequestContext(fields: Partial<RequestContext>): void;
+//# sourceMappingURL=request-context.d.ts.map

package/dist/request-context.js

@@ -0,0 +1,37 @@
+import "./chunk-gOLHoazu.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/request-context.ts
+/**
+* AsyncLocalStorage instance for propagating request context
+* through async call chains without explicit parameter passing.
+*
+* Usage:
+* ```ts
+* requestContext.run({ requestId: crypto.randomUUID() }, async () => {
+*   // All code in this callback (and its async descendants) can read the context
+*   log.info('Processing webhook'); // auto-enriched with requestId
+* });
+* ```
+*/
+const requestContext = new AsyncLocalStorage();
+/**
+* Get the current request context, or an empty object if outside a `run()` scope.
+* Safe to call anywhere -- never throws.
+*/
+function getRequestContext() {
+	return requestContext.getStore() ?? {};
+}
+/**
+* Merge additional fields into the current request context.
+* No-op if called outside a `run()` scope.
+*
+* @param fields - Partial context fields to merge into the current store
+*/
+function enrichRequestContext(fields) {
+	const store = requestContext.getStore();
+	if (store) Object.assign(store, fields);
+}
+//#endregion
+export { enrichRequestContext, getRequestContext, requestContext };
+
+//# sourceMappingURL=request-context.js.map

package/dist/ring-buffer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Generic ring buffer with a configurable maximum size.
+ *
+ * When the buffer reaches its maximum size, adding a new item drops the oldest
+ * item (FIFO overflow). This prevents unbounded memory growth for buffered
+ * messages or log lines during temporary disconnections.
+ */
+export declare class RingBuffer<T> {
+    private buffer;
+    private readonly maxSize;
+    private _droppedCount;
+    constructor(options?: {
+        maxSize?: number;
+    });
+    /**
+     * Add an item to the buffer.
+     * Returns true if the item was added normally, false if the oldest item
+     * was dropped to make room (ring buffer overflow).
+     */
+    add(item: T): boolean;
+    /**
+     * Flush all buffered items in insertion order, clearing the buffer.
+     * Does NOT reset droppedCount -- caller must explicitly call resetDroppedCount() after processing.
+     */
+    flush(): T[];
+    /** Current number of buffered items. */
+    size(): number;
+    /** Number of items dropped due to overflow since last reset. */
+    get droppedCount(): number;
+    /** Reset the dropped count to 0. Call after processing overflow metrics. */
+    resetDroppedCount(): void;
+    /** Clear all buffered items without returning them. Also resets droppedCount. */
+    clear(): void;
+}
+//# sourceMappingURL=ring-buffer.d.ts.map

package/dist/ring-buffer.js

@@ -0,0 +1,62 @@
+import "./chunk-gOLHoazu.js";
+//#region src/ring-buffer.ts
+/**
+* Generic ring buffer with a configurable maximum size.
+*
+* When the buffer reaches its maximum size, adding a new item drops the oldest
+* item (FIFO overflow). This prevents unbounded memory growth for buffered
+* messages or log lines during temporary disconnections.
+*/
+var RingBuffer = class {
+	buffer = [];
+	maxSize;
+	_droppedCount = 0;
+	constructor(options) {
+		this.maxSize = options?.maxSize ?? 1e4;
+	}
+	/**
+	* Add an item to the buffer.
+	* Returns true if the item was added normally, false if the oldest item
+	* was dropped to make room (ring buffer overflow).
+	*/
+	add(item) {
+		if (this.buffer.length >= this.maxSize) {
+			this.buffer.shift();
+			this.buffer.push(item);
+			this._droppedCount++;
+			return false;
+		}
+		this.buffer.push(item);
+		return true;
+	}
+	/**
+	* Flush all buffered items in insertion order, clearing the buffer.
+	* Does NOT reset droppedCount -- caller must explicitly call resetDroppedCount() after processing.
+	*/
+	flush() {
+		const items = this.buffer;
+		this.buffer = [];
+		return items;
+	}
+	/** Current number of buffered items. */
+	size() {
+		return this.buffer.length;
+	}
+	/** Number of items dropped due to overflow since last reset. */
+	get droppedCount() {
+		return this._droppedCount;
+	}
+	/** Reset the dropped count to 0. Call after processing overflow metrics. */
+	resetDroppedCount() {
+		this._droppedCount = 0;
+	}
+	/** Clear all buffered items without returning them. Also resets droppedCount. */
+	clear() {
+		this.buffer = [];
+		this._droppedCount = 0;
+	}
+};
+//#endregion
+export { RingBuffer };
+
+//# sourceMappingURL=ring-buffer.js.map

package/dist/ring-buffer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ring-buffer.test.d.ts.map

package/dist/routes/health.d.ts

@@ -0,0 +1,26 @@
+import { Hono } from 'hono';
+export interface HealthRoutesDeps {
+    /**
+     * Optional extra fields to include in the liveness response.
+     * Called on every `/health` request.
+     */
+    livenessInfo?: () => Record<string, unknown>;
+    /**
+     * Optional readiness checks. Each key is a check name, each value
+     * indicates whether that check passed.
+     * Called on every `/ready` request.
+     * If omitted, the service is always considered ready.
+     */
+    readinessCheck?: () => Promise<Record<string, boolean>>;
+}
+/**
+ * Create health and readiness routes.
+ *
+ * - GET /health - Liveness probe (always 200)
+ * - GET /ready  - Readiness probe (200 if all checks pass, 503 if any fail)
+ *
+ * @param deps - Optional liveness info provider and readiness check function
+ * @returns Hono app with /health and /ready endpoints
+ */
+export declare function createHealthRoutes(deps?: HealthRoutesDeps): Hono;
+//# sourceMappingURL=health.d.ts.map

package/dist/routes/health.js

@@ -0,0 +1,45 @@
+import "../chunk-gOLHoazu.js";
+import { Hono } from "hono";
+//#region src/routes/health.ts
+/**
+* Create health and readiness routes.
+*
+* - GET /health - Liveness probe (always 200)
+* - GET /ready  - Readiness probe (200 if all checks pass, 503 if any fail)
+*
+* @param deps - Optional liveness info provider and readiness check function
+* @returns Hono app with /health and /ready endpoints
+*/
+function createHealthRoutes(deps = {}) {
+	const app = new Hono();
+	/**
+	* Liveness probe - always returns 200.
+	* Includes timestamp, uptime, and any extra info from livenessInfo().
+	*/
+	app.get("/health", (c) => {
+		const extra = deps.livenessInfo?.() ?? {};
+		return c.json({
+			status: "ok",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			uptime: process.uptime(),
+			...extra
+		});
+	});
+	/**
+	* Readiness probe - returns 200 when all checks pass, 503 otherwise.
+	* If no readiness check is provided, always returns 200.
+	*/
+	app.get("/ready", async (c) => {
+		const checks = deps.readinessCheck ? await deps.readinessCheck() : {};
+		const ready = Object.values(checks).every((v) => v);
+		return c.json({
+			status: ready ? "ready" : "not ready",
+			checks
+		}, ready ? 200 : 503);
+	});
+	return app;
+}
+//#endregion
+export { createHealthRoutes };
+
+//# sourceMappingURL=health.js.map

package/dist/routes/health.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=health.test.d.ts.map

package/dist/routes/metrics.d.ts

@@ -0,0 +1,20 @@
+import { Hono } from 'hono';
+export interface MetricsRoutesDeps {
+    /** Callback that returns the Prometheus metrics response. */
+    getMetrics: () => Promise<{
+        contentType: string;
+        body: string;
+    }>;
+}
+/**
+ * Create Prometheus metrics route.
+ *
+ * The caller provides a getMetrics callback that returns the content type
+ * and body. This decouples the route from any specific metrics library
+ * (prom-client, OTel PrometheusExporter, etc.).
+ *
+ * @param deps - Dependencies (metrics callback)
+ * @returns Hono app with /metrics endpoint
+ */
+export declare function createMetricsRoutes(deps: MetricsRoutesDeps): Hono;
+//# sourceMappingURL=metrics.d.ts.map

package/dist/routes/metrics.js

@@ -0,0 +1,38 @@
+import "../chunk-gOLHoazu.js";
+import { Hono } from "hono";
+//#region src/routes/metrics.ts
+/**
+* Create Prometheus metrics route.
+*
+* The caller provides a getMetrics callback that returns the content type
+* and body. This decouples the route from any specific metrics library
+* (prom-client, OTel PrometheusExporter, etc.).
+*
+* @param deps - Dependencies (metrics callback)
+* @returns Hono app with /metrics endpoint
+*/
+function createMetricsRoutes(deps) {
+	const app = new Hono();
+	app.get("/metrics", async (c) => {
+		const { contentType, body } = await deps.getMetrics();
+		const filteredBody = body.split("\n").filter((line) => !line.startsWith("# UNIT ") && line !== "# EOF").map((line) => {
+			if (line.startsWith("# TYPE ") || line.startsWith("# HELP ")) {
+				const prefix = line.startsWith("# TYPE ") ? "# TYPE " : "# HELP ";
+				const rest = line.slice(prefix.length);
+				const spaceIdx = rest.indexOf(" ");
+				if (spaceIdx > 0) return prefix + rest.slice(0, spaceIdx).replace(/\./g, "_") + rest.slice(spaceIdx);
+			} else if (line && !line.startsWith("#")) {
+				const match = line.match(/^([a-zA-Z_:.][a-zA-Z0-9_:.]*)/);
+				if (match && match[1].includes(".")) return line.replace(match[1], match[1].replace(/\./g, "_"));
+			}
+			return line;
+		}).join("\n");
+		const safeContentType = contentType.includes("openmetrics") ? "text/plain; version=0.0.4; charset=utf-8" : contentType;
+		return c.text(filteredBody, 200, { "Content-Type": safeContentType });
+	});
+	return app;
+}
+//#endregion
+export { createMetricsRoutes };
+
+//# sourceMappingURL=metrics.js.map

package/dist/s3-client.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Shared S3 client construction helper.
+ *
+ * Avoids duplicating the region/endpoint/forcePathStyle config pattern
+ * across S3LogStorage, S3CacheStorage, the cold-store framework, and any
+ * future S3 consumers.
+ *
+ * The exported `SharedS3Config` is the generic, TTL-free base config —
+ * domain-specific consumers extend it (e.g., adding `ttlMs` + discriminant
+ * for cache-storage variants).
+ */
+import { S3Client } from '@aws-sdk/client-s3';
+/**
+ * Generic S3-compatible configuration shared across KiCI consumers.
+ *
+ * Callers layer domain-specific fields on top (e.g. orchestrator's
+ * CacheStorageConfig adds `ttlMs`, cold-store's ColdStoreConfig adds
+ * table-level tuning).
+ */
+export interface SharedS3Config {
+    bucket: string;
+    prefix: string;
+    region?: string;
+    /** Custom endpoint URL for S3-compatible services (e.g., SeaweedFS, LocalStack) */
+    endpoint?: string;
+    /**
+     * Separate endpoint for pre-signed URLs (upload and download).
+     * When set, pre-signed URLs use this endpoint instead of `endpoint`.
+     * Useful when the server accesses S3 internally but clients need a
+     * different address (e.g., container-routable DNS name).
+     */
+    externalEndpoint?: string;
+    /** Use path-style access (required for most S3-compatible services). Default: false */
+    forcePathStyle?: boolean;
+}
+export interface CreateS3ClientOptions {
+    region?: string;
+    endpoint?: string;
+    forcePathStyle?: boolean;
+}
+export declare function createS3Client(options: CreateS3ClientOptions): S3Client;
+//# sourceMappingURL=s3-client.d.ts.map

package/dist/s3-client.js

@@ -0,0 +1,25 @@
+import "./chunk-gOLHoazu.js";
+import { S3Client } from "@aws-sdk/client-s3";
+//#region src/s3-client.ts
+/**
+* Shared S3 client construction helper.
+*
+* Avoids duplicating the region/endpoint/forcePathStyle config pattern
+* across S3LogStorage, S3CacheStorage, the cold-store framework, and any
+* future S3 consumers.
+*
+* The exported `SharedS3Config` is the generic, TTL-free base config —
+* domain-specific consumers extend it (e.g., adding `ttlMs` + discriminant
+* for cache-storage variants).
+*/
+function createS3Client(options) {
+	const config = {};
+	if (options.region) config.region = options.region;
+	if (options.endpoint) config.endpoint = options.endpoint;
+	if (options.forcePathStyle !== void 0) config.forcePathStyle = options.forcePathStyle;
+	return new S3Client(config);
+}
+//#endregion
+export { createS3Client };
+
+//# sourceMappingURL=s3-client.js.map

package/dist/telemetry/index.d.ts

@@ -0,0 +1,3 @@
+export { initTelemetry, getPrometheusExporter, type TelemetryConfig } from './init.js';
+export { createMeter } from './metrics.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/telemetry/index.js

@@ -0,0 +1,4 @@
+import "../chunk-gOLHoazu.js";
+import { getPrometheusExporter, initTelemetry } from "./init.js";
+import { createMeter } from "./metrics.js";
+export { createMeter, getPrometheusExporter, initTelemetry };

package/dist/telemetry/init.d.ts

@@ -0,0 +1,20 @@
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { PrometheusExporter } from '@opentelemetry/exporter-prometheus';
+export interface TelemetryConfig {
+    serviceName: string;
+    serviceVersion?: string;
+    /** OTLP endpoint URL. If not set, OTLP trace export is disabled. */
+    otlpEndpoint?: string;
+    /** Metric prefix to match existing prom-client metrics (e.g., 'kici_', 'kici_orch_') */
+    metricPrefix?: string;
+}
+/**
+ * Initialize the OpenTelemetry SDK with Prometheus metrics and optional OTLP trace export.
+ *
+ * Call once at service startup. The Prometheus exporter is configured with
+ * preventServerStart: true -- metrics are served via the existing /metrics route.
+ */
+export declare function initTelemetry(config: TelemetryConfig): NodeSDK;
+/** Get the PrometheusExporter instance created by initTelemetry(). */
+export declare function getPrometheusExporter(): PrometheusExporter | undefined;
+//# sourceMappingURL=init.d.ts.map

package/dist/telemetry/init.js

@@ -0,0 +1,42 @@
+import "../chunk-gOLHoazu.js";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { PrometheusExporter } from "@opentelemetry/exporter-prometheus";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+import { RuntimeNodeInstrumentation } from "@opentelemetry/instrumentation-runtime-node";
+//#region src/telemetry/init.ts
+let _prometheusExporter;
+/**
+* Initialize the OpenTelemetry SDK with Prometheus metrics and optional OTLP trace export.
+*
+* Call once at service startup. The Prometheus exporter is configured with
+* preventServerStart: true -- metrics are served via the existing /metrics route.
+*/
+function initTelemetry(config) {
+	const resource = resourceFromAttributes({
+		[ATTR_SERVICE_NAME]: config.serviceName,
+		[ATTR_SERVICE_VERSION]: config.serviceVersion ?? "0.0.0"
+	});
+	const prometheusExporter = new PrometheusExporter({
+		preventServerStart: true,
+		prefix: config.metricPrefix
+	});
+	_prometheusExporter = prometheusExporter;
+	const sdk = new NodeSDK({
+		resource,
+		metricReader: prometheusExporter,
+		traceExporter: config.otlpEndpoint ? new OTLPTraceExporter({ url: `${config.otlpEndpoint}/v1/traces` }) : void 0,
+		instrumentations: [new RuntimeNodeInstrumentation()]
+	});
+	sdk.start();
+	return sdk;
+}
+/** Get the PrometheusExporter instance created by initTelemetry(). */
+function getPrometheusExporter() {
+	return _prometheusExporter;
+}
+//#endregion
+export { getPrometheusExporter, initTelemetry };
+
+//# sourceMappingURL=init.js.map

package/dist/telemetry/init.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=init.test.d.ts.map

package/dist/telemetry/metrics.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Create an OTel Meter for a given service.
+ *
+ * @param serviceName - Name of the service (e.g., 'orchestrator')
+ * @returns An OTel Meter instance for creating instruments
+ */
+export declare function createMeter(serviceName: string): import("@opentelemetry/api").Meter;
+//# sourceMappingURL=metrics.d.ts.map

package/dist/telemetry/metrics.js

@@ -0,0 +1,16 @@
+import "../chunk-gOLHoazu.js";
+import { metrics } from "@opentelemetry/api";
+//#region src/telemetry/metrics.ts
+/**
+* Create an OTel Meter for a given service.
+*
+* @param serviceName - Name of the service (e.g., 'orchestrator')
+* @returns An OTel Meter instance for creating instruments
+*/
+function createMeter(serviceName) {
+	return metrics.getMeter(serviceName);
+}
+//#endregion
+export { createMeter };
+
+//# sourceMappingURL=metrics.js.map

package/dist/tool-check.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Startup validation for required external tools and binaries.
+ *
+ * Used by the orchestrator (scaler backends) and agent to verify that all
+ * required system tools are available before accepting work. Missing tools
+ * cause a clear fatal error at startup rather than cryptic runtime failures.
+ */
+/**
+ * A single tool requirement declaration.
+ *
+ * - `path-binary`: a binary that must be found on PATH (e.g., 'git', 'ip', 'bash')
+ * - `file-access`: an absolute path that must exist with the specified access mode
+ */
+export type ToolRequirement = {
+    type: 'path-binary';
+    name: string;
+    reason: string;
+} | {
+    type: 'file-access';
+    path: string;
+    mode: 'executable' | 'readable';
+    reason: string;
+};
+/**
+ * Validate a list of tool requirements.
+ *
+ * Deduplicates requirements, checks each one, and returns ALL errors
+ * (not fail-on-first) so the operator sees every missing tool at once.
+ *
+ * @returns Array of error messages. Empty array means all tools are available.
+ */
+export declare function validateRequiredTools(requirements: ToolRequirement[]): string[];
+//# sourceMappingURL=tool-check.d.ts.map

package/dist/tool-check.js

@@ -0,0 +1,60 @@
+import "./chunk-gOLHoazu.js";
+import { execFileSync } from "node:child_process";
+import { accessSync, constants } from "node:fs";
+//#region src/tool-check.ts
+/**
+* Startup validation for required external tools and binaries.
+*
+* Used by the orchestrator (scaler backends) and agent to verify that all
+* required system tools are available before accepting work. Missing tools
+* cause a clear fatal error at startup rather than cryptic runtime failures.
+*/
+/**
+* Validate a list of tool requirements.
+*
+* Deduplicates requirements, checks each one, and returns ALL errors
+* (not fail-on-first) so the operator sees every missing tool at once.
+*
+* @returns Array of error messages. Empty array means all tools are available.
+*/
+function validateRequiredTools(requirements) {
+	const seen = /* @__PURE__ */ new Set();
+	const errors = [];
+	for (const req of requirements) {
+		const key = req.type === "path-binary" ? `path:${req.name}` : `file:${req.path}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		if (req.type === "path-binary") {
+			if (!isBinaryOnPath(req.name)) errors.push(`'${req.name}' not found on PATH — ${req.reason}`);
+		} else {
+			const mode = req.mode === "executable" ? constants.X_OK : constants.R_OK;
+			try {
+				accessSync(req.path, mode);
+			} catch {
+				const modeLabel = req.mode === "executable" ? "executable" : "readable";
+				errors.push(`'${req.path}' not ${modeLabel} — ${req.reason}`);
+			}
+		}
+	}
+	return errors;
+}
+/**
+* Check if a binary is available on PATH.
+* Uses `where` on Windows, `which` on Unix.
+*/
+function isBinaryOnPath(name) {
+	const cmd = process.platform === "win32" ? "where" : "which";
+	try {
+		execFileSync(cmd, [name], {
+			stdio: "pipe",
+			timeout: 5e3
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { validateRequiredTools };
+
+//# sourceMappingURL=tool-check.js.map

package/dist/tool-check.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tool-check.test.d.ts.map

package/dist/ts-loader-hook.d.ts

@@ -0,0 +1,26 @@
+type ResolveContext = {
+    parentURL?: string;
+    conditions: string[];
+    importAttributes: Record<string, string>;
+};
+type ResolveResult = {
+    url: string;
+    shortCircuit?: boolean;
+    format?: string | null;
+};
+type NextResolve = (specifier: string, context?: ResolveContext) => ResolveResult | Promise<ResolveResult>;
+type LoadContext = {
+    format?: string | null;
+    importAttributes: Record<string, string>;
+    conditions: string[];
+};
+type LoadResult = {
+    format: string;
+    source?: string | ArrayBuffer | Uint8Array;
+    shortCircuit?: boolean;
+};
+type NextLoad = (url: string, context?: LoadContext) => LoadResult | Promise<LoadResult>;
+export declare function resolve(specifier: string, context: ResolveContext, nextResolve: NextResolve): ResolveResult | Promise<ResolveResult>;
+export declare function load(url: string, context: LoadContext, nextLoad: NextLoad): Promise<LoadResult>;
+export {};
+//# sourceMappingURL=ts-loader-hook.d.ts.map

package/dist/ts-loader-hook.js

@@ -0,0 +1,48 @@
+import "./chunk-gOLHoazu.js";
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { transformSync } from "oxc-transform";
+//#region src/ts-loader-hook.ts
+function resolve(specifier, context, nextResolve) {
+	if (specifier.endsWith(".js") && (specifier.startsWith("./") || specifier.startsWith("../"))) try {
+		if (context.parentURL) {
+			if (!existsSync(fileURLToPath(new URL(specifier, context.parentURL)))) {
+				const tsSpecifier = specifier.slice(0, -3) + ".ts";
+				if (existsSync(fileURLToPath(new URL(tsSpecifier, context.parentURL)))) return nextResolve(tsSpecifier, context);
+			}
+		}
+	} catch {}
+	return nextResolve(specifier, context);
+}
+async function load(url, context, nextLoad) {
+	if (!url.startsWith("file:")) return nextLoad(url, context);
+	const bareUrl = url.split("?")[0].split("#")[0];
+	const isTs = bareUrl.endsWith(".ts");
+	const isTsx = bareUrl.endsWith(".tsx");
+	if (!isTs && !isTsx) return nextLoad(url, context);
+	const filePath = fileURLToPath(bareUrl);
+	const result = transformSync(filePath, await readFile(filePath, "utf8"), {
+		lang: isTsx ? "tsx" : "ts",
+		sourcemap: true,
+		typescript: { allowNamespaces: true }
+	});
+	if (result.errors.length) {
+		const msg = result.errors.map((e) => e.message).join("\n");
+		throw new Error(`oxc-transform failed for ${filePath}:\n${msg}`);
+	}
+	let code = result.code;
+	if (result.map) {
+		const b64 = Buffer.from(JSON.stringify(result.map)).toString("base64");
+		code += `\n//# sourceMappingURL=data:application/json;base64,${b64}\n`;
+	}
+	return {
+		format: "module",
+		source: code,
+		shortCircuit: true
+	};
+}
+//#endregion
+export { load, resolve };
+
+//# sourceMappingURL=ts-loader-hook.js.map