@compforge/harness-toolbox 0.4.8 → 0.5.0

package/dist/{chunk-vymm4g9h.js → chunk-kxpecgy7.js}

@@ -1,17 +1,21 @@
 import {
-  acquireConnection,
-  awaitWithSignal
-} from "./chunk-gm4swndx.js";
+  isConnectionNetworkError
+} from "./chunk-18gcp0ck.js";
 import {
   TimeoutError,
   ToolboxError
 } from "./chunk-rkt41za2.js";
-import {
-  isConnectionNetworkError
-} from "./chunk-h8fwx0k7.js";
 
 // src/opensearch/client.ts
+import { raceSignal } from "race-signal";
 import { Client, Connection, errors } from "@opensearch-project/opensearch";
+import { isIP } from "node:net";
+function openSearchServername(host) {
+  if (!host)
+    return;
+  const unwrapped = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+  return isIP(unwrapped) ? undefined : host;
+}
 function describeOpenSearchError(error) {
   const parts = [];
   const seen = new Set;
@@ -36,16 +40,30 @@ function isOpenSearchReadApi(search) {
 }
 
 class OpenSearchConnection extends Connection {
+  request(params, callback) {
+    let completed = false;
+    try {
+      return super.request(params, (error, response) => {
+        completed = true;
+        callback(error, response);
+      });
+    } catch (error) {
+      if (!completed)
+        this._openRequests--;
+      throw error;
+    }
+  }
   buildRequestObject(params) {
-    return { ...super.buildRequestObject(params), servername: this.ssl?.servername };
+    return { ...super.buildRequestObject(params), servername: openSearchServername(this.ssl?.servername) };
   }
 }
 function createClient(options) {
   return new Client({
     node: options.node,
     Connection: OpenSearchConnection,
+    headers: options.authority ? { host: options.authority } : undefined,
     auth: options.auth.username && options.auth.password ? { username: options.auth.username, password: options.auth.password } : undefined,
-    ssl: { rejectUnauthorized: false, servername: options.servername },
+    ssl: { rejectUnauthorized: false, servername: openSearchServername(options.servername) },
     requestTimeout: options.requestTimeoutMs ?? 60000,
     maxRetries: 0,
     agent: { keepAlive: !process.versions.bun }
@@ -55,26 +73,36 @@ function createClient(options) {
 class OpenSearchEngine {
   options;
   client;
+  #requests = new Set;
+  #closed = false;
   constructor(options, client) {
     this.options = options;
     this.client = client ?? createClient(options);
   }
+  #run(start) {
+    if (this.#closed)
+      throw new Error("OpenSearch engine is closed");
+    const request = start();
+    this.#requests.add(request);
+    request.then(() => this.#requests.delete(request), () => this.#requests.delete(request));
+    return request;
+  }
   async count(index, query) {
-    const response = await this.client.count({ index, body: { query } });
+    const response = await this.#run(() => this.client.count({ index, body: { query } }));
     return Number(response.body.count ?? 0);
   }
   async search(index, body) {
-    const response = await this.client.search({ index, body });
+    const response = await this.#run(() => this.client.search({ index, body }));
     return response.body;
   }
   async request(path, query) {
     if (!this.client.transport)
       throw new Error("OpenSearch client 不支持通用只读请求");
-    const response = await this.client.transport.request({
+    const response = await this.#run(() => this.client.transport.request({
       method: "GET",
       path,
       querystring: query
-    });
+    }));
     return response.body;
   }
   async ping(signal, timeoutMs = this.options.requestTimeoutMs ?? 60000) {
@@ -87,9 +115,10 @@ class OpenSearchEngine {
     const controller = new AbortController;
     const timer = setTimeout(() => controller.abort(new TimeoutError(`OpenSearch probe timed out after ${timeoutMs}ms`)), timeoutMs);
     const active = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+    let request;
     try {
-      const request = this.client.ping({}, { requestTimeout: timeoutMs });
-      const result = await awaitWithSignal(request, active, () => request.abort?.());
+      request = this.#run(() => this.client.ping({}, { requestTimeout: timeoutMs }));
+      const result = await raceSignal(request, active);
       log(`OpenSearch probe ok target=${target} elapsed_ms=${Date.now() - started}`);
       return result;
     } catch (error) {
@@ -97,13 +126,18 @@ class OpenSearchEngine {
       throw error;
     } finally {
       clearTimeout(timer);
+      if (active.aborted)
+        request?.abort?.();
     }
   }
   async close() {
+    this.#closed = true;
+    for (const request of this.#requests)
+      request.abort?.();
     const controller = new AbortController;
     const timer = setTimeout(() => controller.abort(new TimeoutError("OpenSearch close timed out after 2000ms")), 2000);
     try {
-      await awaitWithSignal(this.client.close(), controller.signal);
+      await raceSignal(this.client.close(), controller.signal);
     } catch (error) {
       this.options.onDiagnostic?.(`OpenSearch close failed ${describeOpenSearchError(error)}`);
       throw error;
@@ -123,27 +157,39 @@ function openSearchRetryReason(error) {
 }
 
 class OpenSearchClient {
-  source;
+  configuration;
+  transport;
   lifecycle;
   #controller = new AbortController;
   signal;
   #initialization;
   #disposal;
   #engine;
+  #node;
+  get node() {
+    return this.#node;
+  }
+  #cleanupErrors = [];
   #operations = new Set;
-  constructor(source, lifecycle = {}) {
-    this.source = source;
+  constructor(configuration, transport, lifecycle = {}) {
+    this.configuration = configuration;
+    this.transport = transport;
     this.lifecycle = lifecycle;
     this.signal = lifecycle.signal ? AbortSignal.any([lifecycle.signal, this.#controller.signal]) : this.#controller.signal;
   }
   initialize() {
     this.signal.throwIfAborted();
     return this.#initialization ??= (async () => {
-      const target = await awaitWithSignal(this.source.resolve(), this.signal);
+      const target = await raceSignal(typeof this.configuration === "function" ? this.configuration() : Promise.resolve(this.configuration), this.signal);
       this.signal.throwIfAborted();
-      const original = new URL(target.node);
+      const explicit = target.node.includes("://");
+      const preferred = target.preferredScheme ?? "http";
+      const original = new URL(explicit ? target.node : `${preferred}://${target.node}`);
+      if (!explicit && !original.port)
+        original.port = "9200";
+      const schemes = explicit ? [original.protocol] : preferred === "https" ? ["https:", "http:"] : ["http:", "https:"];
       try {
-        this.#engine = await acquireConnection(this.source.transports, {
+        this.#engine = await this.transport.acquire({
           name: "OpenSearch connection",
           signal: this.signal,
           connectTimeoutMs: target.connectTimeoutMs ?? target.requestTimeoutMs ?? 1e4,
@@ -155,23 +201,40 @@ class OpenSearchClient {
             this.lifecycle.onDiagnostic?.(`OpenSearch route start transport=${transport.name} target=${original.protocol}//${original.host} timeout_ms=${attempt.remainingMs()}`);
             const endpoint = await transport.connect({
               host: original.hostname,
-              port: Number(original.port || (original.protocol === "https:" ? 443 : 80)),
-              servername: target.servername ?? original.hostname
-            });
+              port: Number(original.port || (original.protocol === "https:" ? 443 : 80))
+            }, attempt);
             attempt.signal.throwIfAborted();
             const url = new URL(original);
             url.hostname = endpoint.host;
             url.port = String(endpoint.port);
-            const engine = new OpenSearchEngine({ ...target, onDiagnostic: this.lifecycle.onDiagnostic, node: url.toString(), servername: endpoint.servername ?? target.servername ?? original.hostname });
-            try {
-              await engine.ping(attempt.signal, attempt.remainingMs());
-              return { connection: engine, transport: transport.name };
-            } catch (error) {
+            for (const [index, scheme] of schemes.entries()) {
+              url.protocol = scheme;
+              const engine = new OpenSearchEngine({
+                ...target,
+                onDiagnostic: this.lifecycle.onDiagnostic,
+                node: url.toString(),
+                authority: original.host,
+                servername: target.servername ?? original.hostname
+              });
               try {
-                await engine.close();
-              } catch {}
-              throw error;
+                await engine.ping(attempt.signal, attempt.remainingMs());
+                const selected = new URL(original);
+                selected.protocol = scheme;
+                this.#node = selected.toString().replace(/\/$/, "");
+                return { connection: engine, transport: transport.name };
+              } catch (error) {
+                try {
+                  await engine.close();
+                } catch (cleanup) {
+                  this.#cleanupErrors.push(cleanup);
+                  throw new AggregateError([error, cleanup], "OpenSearch initialization and cleanup failed", { cause: error });
+                }
+                attempt.signal.throwIfAborted();
+                if (index === schemes.length - 1 || openSearchRetryReason(error) === undefined)
+                  throw error;
+              }
             }
+            throw new Error("OpenSearch has no protocol candidate");
           },
           close: (engine) => engine.close(),
           retryReason: openSearchRetryReason
@@ -220,21 +283,27 @@ class OpenSearchClient {
     return this.#disposal ??= (async () => {
       this.#controller.abort(new Error("OpenSearch client disposed"));
       await this.#initialization?.catch(() => {});
-      await Promise.allSettled(this.#operations);
       await this.#engine?.close();
+      await Promise.allSettled(this.#operations);
+      if (this.#cleanupErrors.length)
+        throw new AggregateError(this.#cleanupErrors, "OpenSearch cleanup failed");
     })();
   }
 }
-async function openOpenSearch(source, lifecycle = {}) {
-  const client = new OpenSearchClient(source, lifecycle);
+async function openOpenSearch(configuration, transport, lifecycle = {}) {
+  const client = new OpenSearchClient(configuration, transport, lifecycle);
   try {
     await client.initialize();
   } catch (error) {
-    await client.dispose();
+    try {
+      await client.dispose();
+    } catch (cleanup) {
+      throw new AggregateError([error, cleanup], "OpenSearch initialization and cleanup failed", { cause: error });
+    }
     throw error;
   }
   lifecycle.onDispose?.(() => client.dispose());
   return client;
 }
 
-export { describeOpenSearchError, isOpenSearchReadApi, OpenSearchEngine, OpenSearchClient, openOpenSearch };
+export { openSearchServername, describeOpenSearchError, isOpenSearchReadApi, OpenSearchEngine, OpenSearchClient, openOpenSearch };

package/dist/{chunk-nftzckdy.js → chunk-mvkxs8d0.js}

@@ -69,7 +69,14 @@ async function startPortForward(opts) {
   opts.signal?.addEventListener("abort", abort, { once: true });
   if (opts.signal?.aborted)
     abort();
-  proc.exited.then(() => opts.signal?.removeEventListener("abort", abort), () => opts.signal?.removeEventListener("abort", abort));
+  let alive = true;
+  proc.exited.then(() => {
+    alive = false;
+    opts.signal?.removeEventListener("abort", abort);
+  }, () => {
+    alive = false;
+    opts.signal?.removeEventListener("abort", abort);
+  });
   const decoder = new TextDecoder;
   const deadline = Date.now() + timeoutMs;
   let out = "";
@@ -105,7 +112,7 @@ async function startPortForward(opts) {
       log(`port-forward listening local=127.0.0.1:${m[1]} elapsed_ms=${Date.now() - started}`);
       return {
         ok: true,
-        value: { target, localPort: Number(m[1]), command: argv, stop }
+        value: { target, localPort: Number(m[1]), command: argv, stop, exited: proc.exited, isAlive: () => alive && !stopped }
       };
     }
   }
@@ -141,6 +148,14 @@ class PortForwardScope {
     for (const forward of this.#forwards.splice(0).reverse())
       forward.stop();
   }
+  async dispose() {
+    const forwards = [...this.#forwards];
+    this.stop();
+    const settled = await Promise.allSettled(forwards.map((forward) => forward.exited));
+    const errors = settled.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+    if (errors.length)
+      throw new AggregateError(errors, "Port-forward cleanup failed");
+  }
 }
 
 export { startPortForward, PortForwardScope };

package/dist/{chunk-f98qrpx1.js → chunk-njs48b51.js}

@@ -1,18 +1,18 @@
-import {
-  acquireConnection,
-  awaitWithSignal
-} from "./chunk-gm4swndx.js";
 import {
   discoverRedisTopology
 } from "./chunk-5tbzf9wd.js";
+import {
+  isConnectionNetworkError
+} from "./chunk-18gcp0ck.js";
+import {
+  Transport
+} from "./chunk-sb5qzv37.js";
 import {
   TimeoutError
 } from "./chunk-rkt41za2.js";
-import {
-  isConnectionNetworkError
-} from "./chunk-h8fwx0k7.js";
 
 // src/redis/client.ts
+import { raceSignal } from "race-signal";
 import { createClient, SocketClosedUnexpectedlyError, ConnectionTimeoutError } from "@redis/client";
 function stringValue(value) {
   if (Buffer.isBuffer(value))
@@ -96,7 +96,7 @@ class RedisConnection {
         client.destroy();
     };
     try {
-      await awaitWithSignal(client.connect(), signal, close);
+      await raceSignal(client.connect(), signal);
       signal.throwIfAborted();
       return new RedisConnection(endpoint, client, config.timeoutMs, () => lastError, config.signal);
     } catch (error) {
@@ -119,12 +119,14 @@ class RedisConnection {
     const timer = setTimeout(() => timeout.abort(new TimeoutError(`Redis ${operationName} timed out after ${this.timeoutMs}ms (${this.endpoint.host}:${this.endpoint.port})`)), this.timeoutMs);
     const signal = this.signal ? AbortSignal.any([this.signal, timeout.signal]) : timeout.signal;
     try {
-      return await awaitWithSignal(Promise.resolve().then(() => {
+      return await raceSignal(Promise.resolve().then(() => {
         signal.throwIfAborted();
         return operation();
-      }), signal, () => this.close());
+      }), signal);
     } finally {
       clearTimeout(timer);
+      if (signal.aborted)
+        this.close();
     }
   }
   ping() {
@@ -171,19 +173,17 @@ class RedisAccess {
   #connections = new Map;
   #controller = new AbortController;
   #signal;
-  #transports;
+  #transport;
   #closing;
   constructor(transports, baseConfig, connectionFactory = RedisConnection.connect, lifecycle = {}) {
     this.baseConfig = baseConfig;
     this.connectionFactory = connectionFactory;
     this.lifecycle = lifecycle;
-    this.#transports = Array.isArray(transports) ? transports : [transports];
-    if (!this.#transports.length)
-      throw new Error("Redis requires a TCP transport");
+    this.#transport = transports instanceof Transport ? transports : new Transport(Array.isArray(transports) ? transports : [transports]);
     for (const value of [
       baseConfig.timeoutMs,
       baseConfig.connectTimeoutMs ?? baseConfig.timeoutMs,
-      baseConfig.acquireTimeoutMs ?? (baseConfig.connectTimeoutMs ?? baseConfig.timeoutMs) * this.#transports.length
+      baseConfig.acquireTimeoutMs ?? (baseConfig.connectTimeoutMs ?? baseConfig.timeoutMs)
     ]) {
       if (!Number.isFinite(value) || value <= 0)
         throw new Error("Redis timeouts must be positive milliseconds");
@@ -214,14 +214,16 @@ class RedisAccess {
     return pending;
   }
   #open(endpoint, database, credentials) {
-    return acquireConnection(this.#transports, {
+    return this.#transport.acquire({
       name: "Redis connection",
       signal: this.#signal,
       connectTimeoutMs: this.baseConfig.connectTimeoutMs ?? this.baseConfig.timeoutMs,
       acquireTimeoutMs: this.baseConfig.acquireTimeoutMs,
       onRoute: this.lifecycle.onRoute,
       open: async (transport, attempt) => {
-        const mapped = await transport.connect(endpoint);
+        if (transport.kind !== "tcp")
+          throw new Error("Redis requires a TCP transport");
+        const mapped = await transport.connect(endpoint, attempt);
         const connection = await this.connectionFactory(endpoint, mapped, {
           ...this.baseConfig,
           ...credentials,
@@ -263,7 +265,8 @@ class RedisAccess {
 }
 
 class RedisClient {
-  source;
+  configuration;
+  transport;
   lifecycle;
   #controller = new AbortController;
   signal;
@@ -271,22 +274,20 @@ class RedisClient {
   #disposal;
   #access;
   #target;
-  constructor(source, lifecycle = {}) {
-    this.source = source;
+  constructor(configuration, transport, lifecycle = {}) {
+    this.configuration = configuration;
+    this.transport = transport;
     this.lifecycle = lifecycle;
     this.signal = lifecycle.signal ? AbortSignal.any([lifecycle.signal, this.#controller.signal]) : this.#controller.signal;
   }
   initialize() {
     this.signal.throwIfAborted();
     return this.#initialization ??= (async () => {
-      this.#target = await awaitWithSignal(this.source.resolve(), this.signal);
+      this.#target = await raceSignal(typeof this.configuration === "function" ? this.configuration() : Promise.resolve(this.configuration), this.signal);
       this.signal.throwIfAborted();
-      if (!this.source.transports.length || this.source.transports.some((transport) => transport.kind !== "tcp")) {
-        throw new Error("Redis requires TCP transports");
-      }
       if (this.#target.clusterType === "cluster" && this.#target.database !== 0)
         throw new Error("Redis Cluster requires database 0");
-      this.#access = new RedisAccess(this.source.transports, this.#target, undefined, { ...this.lifecycle, signal: this.signal });
+      this.#access = new RedisAccess(this.transport, this.#target, undefined, { ...this.lifecycle, signal: this.signal });
     })();
   }
   get access() {
@@ -311,8 +312,8 @@ class RedisClient {
     })();
   }
 }
-async function openRedis(source, lifecycle = {}) {
-  const client = new RedisClient(source, lifecycle);
+async function openRedis(configuration, transport, lifecycle = {}) {
+  const client = new RedisClient(configuration, transport, lifecycle);
   try {
     await client.initialize();
   } catch (error) {

package/dist/chunk-sb5qzv37.js

@@ -0,0 +1,62 @@
+import {
+  acquireConnection
+} from "./chunk-43mcyrh4.js";
+
+// src/transport/lifecycle.ts
+class Transport {
+  candidates;
+  #controller = new AbortController;
+  resourceSignal = this.#controller.signal;
+  signal;
+  #pending = new Set;
+  #cleanupErrors = [];
+  #disposal;
+  constructor(candidates = [], signal) {
+    this.candidates = candidates;
+    this.signal = signal ? AbortSignal.any([signal, this.#controller.signal]) : this.#controller.signal;
+  }
+  paths() {
+    return this.candidates;
+  }
+  async initialize() {
+    this.signal.throwIfAborted();
+  }
+  acquire(options) {
+    this.signal.throwIfAborted();
+    const signal = options.signal ? AbortSignal.any([options.signal, this.signal]) : this.signal;
+    return acquireConnection(this.paths(), {
+      ...options,
+      signal,
+      onPending: (pending) => {
+        this.#pending.add(pending);
+        pending.then(() => this.#pending.delete(pending), () => this.#pending.delete(pending));
+      },
+      close: async (connection) => {
+        try {
+          await options.close(connection);
+        } catch (error) {
+          this.#cleanupErrors.push(error);
+          throw error;
+        }
+      }
+    });
+  }
+  async close() {}
+  dispose() {
+    return this.#disposal ??= (async () => {
+      this.#controller.abort(new Error("Transport disposed"));
+      const errors = [];
+      try {
+        await this.close();
+      } catch (error) {
+        errors.push(error);
+      }
+      await Promise.allSettled([...this.#pending]);
+      errors.push(...this.#cleanupErrors);
+      if (errors.length)
+        throw new AggregateError(errors, "Transport cleanup failed");
+    })();
+  }
+}
+
+export { Transport };

package/dist/{chunk-dx6yvj81.js → chunk-xhfbark7.js}

@@ -2,7 +2,7 @@ import {
   BoundedFileClient,
   fileClientOptions,
   filePaths
-} from "./chunk-ww11q58v.js";
+} from "./chunk-rncagjbc.js";
 import {
   FileError
 } from "./chunk-rkt41za2.js";

package/dist/{chunk-m391jmpw.js → chunk-ze1hng62.js}

@@ -1,21 +1,21 @@
+import {
+  KubernetesResourceTransport
+} from "./chunk-5w85c7cs.js";
 import {
   resolveWorkload
 } from "./chunk-ae84rzq5.js";
-import {
-  ServicePortForwarder
-} from "./chunk-1ts7pswj.js";
-import {
-  KubernetesResourceTransport
-} from "./chunk-x0yhfg29.js";
 import {
   KubernetesExecTransport
-} from "./chunk-r3rnsvwv.js";
+} from "./chunk-xeft7af0.js";
 import {
-  KubernetesError
-} from "./chunk-rkt41za2.js";
+  ServicePortForwarder
+} from "./chunk-0d8vs5q8.js";
 import {
   KubectlExecutor
 } from "./chunk-rq5fc007.js";
+import {
+  KubernetesError
+} from "./chunk-rkt41za2.js";
 
 // src/kubernetes/client.ts
 class KubernetesClient {

package/dist/connection/acquire.d.ts

@@ -1,12 +1,10 @@
 import type { ClientLifecycle } from "../datasource";
-/** Stop waiting without leaving rejected preparation promises unobserved. */
-export declare function awaitWithSignal<T>(pending: Promise<T>, signal: AbortSignal, cancel?: () => void): Promise<T>;
 export interface ConnectionAttempt {
     readonly signal: AbortSignal;
     /** Remaining mapping + handshake budget, not a fresh timeout for each phase. */
     remainingMs(): number;
 }
-interface Acquisition<R, C> {
+export interface Acquisition<R, C> {
     name: string;
     connectTimeoutMs: number;
     acquireTimeoutMs?: number;
@@ -19,6 +17,8 @@ interface Acquisition<R, C> {
     /** Undefined means terminal; authentication and protocol errors must not change route. */
     retryReason(error: unknown): string | undefined;
     onRoute?: ClientLifecycle["onRoute"];
+    /** Owner tracks late completion through its rollback, not only the initial open promise. */
+    onPending?: (pending: Promise<unknown>) => void;
 }
 /**
  * @spec One acquisition owns ordered attempts and a deadline covering mapping and handshake.
@@ -31,4 +31,3 @@ interface Acquisition<R, C> {
 export declare function acquireConnection<R extends {
     readonly name: string;
 }, C>(routes: readonly R[], options: Acquisition<R, C>): Promise<C>;
-export {};

package/dist/connection/acquire.js

@@ -1,9 +1,7 @@
 import {
-  acquireConnection,
-  awaitWithSignal
-} from "../chunk-gm4swndx.js";
+  acquireConnection
+} from "../chunk-43mcyrh4.js";
 import"../chunk-rkt41za2.js";
 export {
-  awaitWithSignal,
   acquireConnection
 };

package/dist/datasource.d.ts

@@ -1,11 +1,5 @@
 export { clientKey, ClientManager, EnvironmentContext, type Client, type ClientProvider, type DataSource, type ServiceDataSource } from "@compforge/harness-common";
-import type { Transport } from "./transport";
 export { ToolboxError, KubernetesError, type ErrorKind } from "./errors";
-/** Resolution owns configuration semantics; transports preserve the resolved target and identity. */
-export interface ConnectionSource<Target> {
-    resolve(): Promise<Target>;
-    readonly transports: readonly Transport[];
-}
 export interface ClientLifecycle {
     signal?: AbortSignal;
     onDispose?: (dispose: () => Promise<void>) => void;

package/dist/file/client.js

@@ -2,9 +2,9 @@ import {
   BoundedFileClient,
   fileClientOptions,
   filePaths
-} from "../chunk-ww11q58v.js";
-import"../chunk-rkt41za2.js";
+} from "../chunk-rncagjbc.js";
 import"../chunk-v3hxvnrc.js";
+import"../chunk-rkt41za2.js";
 export {
   filePaths,
   fileClientOptions,

package/dist/file/index.js

@@ -1,16 +1,16 @@
 import {
   PodFileClient,
   PodFileDataSource
-} from "../chunk-dx6yvj81.js";
+} from "../chunk-xhfbark7.js";
 import {
   LocalFileClient,
   LocalFileDataSource
-} from "../chunk-f3vq900j.js";
-import"../chunk-ww11q58v.js";
+} from "../chunk-92aacbwh.js";
+import"../chunk-rncagjbc.js";
+import"../chunk-v3hxvnrc.js";
 import {
   FileError
 } from "../chunk-rkt41za2.js";
-import"../chunk-v3hxvnrc.js";
 
 // src/file/index.ts
 import { FileDataSource } from "@compforge/harness-common";

package/dist/file/local.js

@@ -1,10 +1,10 @@
 import {
   LocalFileClient,
   LocalFileDataSource
-} from "../chunk-f3vq900j.js";
-import"../chunk-ww11q58v.js";
-import"../chunk-rkt41za2.js";
+} from "../chunk-92aacbwh.js";
+import"../chunk-rncagjbc.js";
 import"../chunk-v3hxvnrc.js";
+import"../chunk-rkt41za2.js";
 export {
   LocalFileDataSource,
   LocalFileClient

package/dist/file/pod.js

@@ -1,10 +1,10 @@
 import {
   PodFileClient,
   PodFileDataSource
-} from "../chunk-dx6yvj81.js";
-import"../chunk-ww11q58v.js";
-import"../chunk-rkt41za2.js";
+} from "../chunk-xhfbark7.js";
+import"../chunk-rncagjbc.js";
 import"../chunk-v3hxvnrc.js";
+import"../chunk-rkt41za2.js";
 export {
   PodFileDataSource,
   PodFileClient