@lostgradient/weft 0.19.0 → 0.21.0

package/dist/server/operations/get-task-detail.d.ts

@@ -0,0 +1,346 @@
+/**
+ * `weft.tasks.get` operation + REST binding (WFT-92).
+ *
+ * Reads the full durable ledger state for one `operationId` — the wire
+ * counterpart to `WeftServer.getTaskResult()`, which is same-process-only
+ * (`src/server/runtime/task-result-view.ts`). This operation exposes the
+ * complete dispatch envelope and current ledger state so an HTTP/JSON-RPC
+ * caller — an operator console, for instance — can render one task's
+ * authoritative state without reconstructing it from the bounded
+ * `weft.tasks.diagnostics` alerting shape, which deliberately collapses
+ * `leased`/`completing`/`cancelling` into one `inflight` value and carries
+ * no attempt identity, priority, headers, retry-availability, adoption, or
+ * retention evidence.
+ *
+ * **Excluded fields.** `attemptToken`, `workerSessionId`, and
+ * `executionIdentity` are never projected here, matching
+ * `TaskResultView`'s own documented exclusion list — they are worker
+ * ownership/session internals with no business being public. `headers`
+ * are summarized as key names only (`headerKeys`): interceptor headers can
+ * carry trace context or auth material, and this is a read surface, not a
+ * payload inspector. The task `input` value and a dead-lettered record's
+ * pending result `value` are omitted for the same "digest not value"
+ * reason `TaskResultView` omits a resolved result's value — the ledger
+ * proves which attempt won, it does not re-deliver payloads. `resultDigest`
+ * is only projected for `disposition: 'resolved'`: the `cancelled`
+ * (mid-attempt) and `retryExhausted` lineages store a synthetic
+ * `${disposition}:${operationId}:${attemptToken}` placeholder there instead
+ * of a real content hash (`task-ledger-transitions(-cancellation).ts`),
+ * which would otherwise leak the excluded `attemptToken` verbatim.
+ *
+ * **Read-only by design.** This issue deliberately does not add an HTTP
+ * path to `adoptTaskResultImpl`. WFT-24 describes adoption as "an explicit
+ * caller assertion" that a workflow incorporated a result — a browser
+ * operator clicking a button cannot honestly make that assertion. If an
+ * HTTP adoption path is ever wanted, it needs its own design discussion,
+ * not a bundled addition here.
+ *
+ * @module server/operations/get-task-detail
+ */
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+export { executionRequirementSchema, getTaskDetailOutputSchema, retryPolicySchema, type GetTaskDetailInput, type GetTaskDetailOutput, } from './get-task-detail-schema.ts';
+export declare const getTaskDetailOperation: import("../operation-catalog.ts").OperationDefinition<{
+    operationId: string;
+}, {
+    disposition: "resolved";
+    resultDigest: string;
+    resultStatus: "completed" | "failed";
+    state: "terminal";
+    terminalAt: number;
+    adopted: boolean;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    error?: string | undefined;
+    adoptedAt?: number | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    disposition: "cancelled";
+    cancellationReason: string;
+    state: "terminal";
+    terminalAt: number;
+    adopted: boolean;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    adoptedAt?: number | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    disposition: "retryExhausted";
+    error: string;
+    state: "terminal";
+    terminalAt: number;
+    adopted: boolean;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    adoptedAt?: number | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    state: "queued";
+    availableAt: number;
+    firstQueuedAt: number;
+    lastQueuedAt: number;
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    lastDispatchedAt?: number | undefined;
+    startedAt?: number | undefined;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    leaseDeadline: number;
+    firstQueuedAt: number;
+    lastQueuedAt: number;
+    startedAt: number;
+    lastHeartbeatAt: number;
+    state: "leased";
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    pendingStatus: "completed" | "failed";
+    resultDigest: string;
+    leaseDeadline: number;
+    firstQueuedAt: number;
+    lastQueuedAt: number;
+    startedAt: number;
+    lastHeartbeatAt: number;
+    state: "completing";
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    cancellationReason: string;
+    cancellationRequestedAt: number;
+    leaseDeadline: number;
+    firstQueuedAt: number;
+    lastQueuedAt: number;
+    startedAt: number;
+    lastHeartbeatAt: number;
+    state: "cancelling";
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+} | {
+    state: "deadLettered";
+    pendingStatus: "completed" | "failed";
+    resultDigest: string;
+    deadLetteredAt: number;
+    persistenceFailureReason: string;
+    retryCount: number;
+    requeueCount: number;
+    operationId: string;
+    workflowType: string;
+    activityName: string;
+    queue: string;
+    headerKeys: string[];
+    visibilityTimeoutMilliseconds: number;
+    createdAt: number;
+    attempt: number;
+    error?: string | undefined;
+    lastRequeueReason?: string | undefined;
+    workflowId?: string | undefined;
+    workflowExecutionToken?: string | undefined;
+    priority?: number | undefined;
+    retryPolicy?: {
+        maxAttempts: number;
+        initialBackoff: string | number;
+        backoffMultiplier: number;
+        maxBackoff: string | number;
+        nonRetryableErrors?: string[] | undefined;
+    } | undefined;
+    scheduleToCloseDeadline?: number | undefined;
+    executionRequirement?: {
+        deploymentName?: string | undefined;
+        buildId?: string | undefined;
+        artifactDigest?: string | undefined;
+        workflowRevision?: string | undefined;
+        activityContractHash?: string | undefined;
+    } | undefined;
+    fairShareKey?: string | undefined;
+    stickyWorkflowId?: string | undefined;
+}, unknown>;
+export declare const getTaskDetailRestBinding: UnknownRestBinding;

package/dist/server/operations/get-task-detail.js

@@ -0,0 +1,215 @@
+import { raiseFault } from "../operation-catalog/raise-fault.js";
+import { defineOperation } from "../operation-registry.js";
+import {
+  decodeRemoteTaskRecord,
+  taskLedgerKey
+} from "../task-ledger.js";
+import {
+  executionRequirementSchema,
+  getTaskDetailInput,
+  getTaskDetailOutputSchema,
+  retryPolicySchema
+} from "./get-task-detail-schema.js";
+export {
+  executionRequirementSchema,
+  getTaskDetailOutputSchema,
+  retryPolicySchema
+} from "./get-task-detail-schema.js";
+function projectRetryPolicy(retryPolicy) {
+  return {
+    maxAttempts: retryPolicy.maxAttempts,
+    initialBackoff: retryPolicy.initialBackoff,
+    backoffMultiplier: retryPolicy.backoffMultiplier,
+    maxBackoff: retryPolicy.maxBackoff,
+    ...retryPolicy.nonRetryableErrors !== void 0 ? { nonRetryableErrors: retryPolicy.nonRetryableErrors } : {}
+  };
+}
+function projectExecutionRequirement(executionRequirement) {
+  return {
+    ...executionRequirement.deploymentName !== void 0 ? { deploymentName: executionRequirement.deploymentName } : {},
+    ...executionRequirement.buildId !== void 0 ? { buildId: executionRequirement.buildId } : {},
+    ...executionRequirement.artifactDigest !== void 0 ? { artifactDigest: executionRequirement.artifactDigest } : {},
+    ...executionRequirement.workflowRevision !== void 0 ? { workflowRevision: executionRequirement.workflowRevision } : {},
+    ...executionRequirement.activityContractHash !== void 0 ? { activityContractHash: executionRequirement.activityContractHash } : {}
+  };
+}
+function baseEnvelopeFields(record) {
+  return {
+    operationId: record.operationId,
+    ...record.workflowId !== void 0 ? { workflowId: record.workflowId } : {},
+    ...record.workflowExecutionToken !== void 0 ? { workflowExecutionToken: record.workflowExecutionToken } : {},
+    workflowType: record.workflowType,
+    activityName: record.activityName,
+    queue: record.queue,
+    ...record.priority !== void 0 ? { priority: record.priority } : {},
+    headerKeys: Object.keys(record.headers),
+    visibilityTimeoutMilliseconds: record.visibilityTimeoutMilliseconds,
+    ...record.retryPolicy !== void 0 ? { retryPolicy: projectRetryPolicy(record.retryPolicy) } : {},
+    ...record.scheduleToCloseDeadline !== void 0 ? { scheduleToCloseDeadline: record.scheduleToCloseDeadline } : {},
+    ...record.executionRequirement !== void 0 ? { executionRequirement: projectExecutionRequirement(record.executionRequirement) } : {},
+    ...record.fairShareKey !== void 0 ? { fairShareKey: record.fairShareKey } : {},
+    ...record.stickyWorkflowId !== void 0 ? { stickyWorkflowId: record.stickyWorkflowId } : {},
+    createdAt: record.createdAt,
+    attempt: record.attempt
+  };
+}
+function attemptFields(record) {
+  return {
+    retryCount: record.retryCount,
+    requeueCount: record.requeueCount,
+    ...record.lastRequeueReason !== void 0 ? { lastRequeueReason: record.lastRequeueReason } : {}
+  };
+}
+function leaseHolderFields(record) {
+  return {
+    leaseDeadline: record.leaseDeadline,
+    firstQueuedAt: record.firstQueuedAt,
+    lastQueuedAt: record.lastQueuedAt,
+    startedAt: record.startedAt,
+    lastHeartbeatAt: record.lastHeartbeatAt
+  };
+}
+function projectQueued(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    state: "queued",
+    availableAt: record.availableAt,
+    firstQueuedAt: record.firstQueuedAt,
+    lastQueuedAt: record.lastQueuedAt,
+    ...record.lastDispatchedAt !== void 0 ? { lastDispatchedAt: record.lastDispatchedAt } : {},
+    ...record.startedAt !== void 0 ? { startedAt: record.startedAt } : {}
+  };
+}
+function projectLeased(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    ...leaseHolderFields(record),
+    state: "leased"
+  };
+}
+function projectCompleting(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    ...leaseHolderFields(record),
+    state: "completing",
+    pendingStatus: record.pendingStatus,
+    resultDigest: record.pendingResultDigest
+  };
+}
+function projectCancelling(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    ...leaseHolderFields(record),
+    state: "cancelling",
+    cancellationReason: record.cancellationReason,
+    cancellationRequestedAt: record.cancellationRequestedAt
+  };
+}
+function terminalDispositionFields(record) {
+  if (record.disposition === "resolved")
+    return {
+      disposition: "resolved",
+      resultDigest: record.resultDigest,
+      resultStatus: record.status,
+      ...record.error !== void 0 ? { error: record.error } : {}
+    };
+  if (record.disposition === "cancelled")
+    return {
+      disposition: "cancelled",
+      cancellationReason: record.cancellationReason
+    };
+  return {
+    disposition: "retryExhausted",
+    error: record.error
+  };
+}
+function projectTerminal(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    state: "terminal",
+    terminalAt: record.terminalAt,
+    adopted: record.adopted,
+    ...record.adoptedAt !== void 0 ? { adoptedAt: record.adoptedAt } : {},
+    ...terminalDispositionFields(record)
+  };
+}
+function projectDeadLettered(record) {
+  return {
+    ...baseEnvelopeFields(record),
+    ...attemptFields(record),
+    state: "deadLettered",
+    pendingStatus: record.pendingStatus,
+    resultDigest: record.pendingResultDigest,
+    deadLetteredAt: record.deadLetteredAt,
+    persistenceFailureReason: record.persistenceFailureReason,
+    ...record.error !== void 0 ? { error: record.error } : {}
+  };
+}
+function projectTaskDetail(record) {
+  switch (record.state) {
+    case "queued":
+      return projectQueued(record);
+    case "leased":
+      return projectLeased(record);
+    case "completing":
+      return projectCompleting(record);
+    case "cancelling":
+      return projectCancelling(record);
+    case "terminal":
+      return projectTerminal(record);
+    case "deadLettered":
+      return projectDeadLettered(record);
+    default:
+      return record;
+  }
+}
+export const getTaskDetailOperation = defineOperation({
+  name: "weft.tasks.get",
+  mcpExposable: !1,
+  summary: "Get one task's full durable ledger state",
+  destructive: !1,
+  tags: ["Observability"],
+  inputSchema: getTaskDetailInput,
+  outputSchema: getTaskDetailOutputSchema,
+  access: {
+    kind: "scoped",
+    scopes: { kind: "anyOf", scopes: ["system:read"] }
+  },
+  producibleFaults: ["NotFound"],
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const raw = await engine.storage.get(taskLedgerKey(input.operationId));
+    if (raw === null)
+      raiseFault(getTaskDetailOperation, {
+        code: "NotFound",
+        message: `No task found for operation "${input.operationId}"`,
+        data: { resource: "task", identifier: input.operationId }
+      });
+    const decoded = decodeRemoteTaskRecord(raw);
+    if (decoded === null || decoded.operationId !== input.operationId)
+      raiseFault(getTaskDetailOperation, {
+        code: "EngineFailure",
+        message: `Task ledger record for operation "${input.operationId}" could not be decoded`,
+        data: {}
+      });
+    return projectTaskDetail(decoded);
+  }
+}), getTaskDetailRestBinding = {
+  method: "GET",
+  path: "/v1/tasks/detail/:operationId",
+  pathParamNames: ["operationId"],
+  operationName: "weft.tasks.get",
+  inputSources: {
+    operationId: { kind: "path", pathParam: "operationId" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    operationId: pathParams.operationId ?? ""
+  }),
+  success: { kind: "json", status: 200 }
+};

package/dist/server/operations/static-registrations.js

@@ -41,6 +41,7 @@ import { getReviewOperation, getReviewRestBinding } from "./get-review.js";
 import { getScheduleOperation, getScheduleRestBinding } from "./get-schedule.js";
 import { getStreamChunksOperation, getStreamChunksRestBinding } from "./get-stream-chunks.js";
 import { getSystemLeaseOperation, getSystemLeaseRestBinding } from "./get-system-lease.js";
+import { getTaskDetailOperation, getTaskDetailRestBinding } from "./get-task-detail.js";
 import {
   clearTaskDeadLetterOperation,
   clearTaskDeadLetterRestBinding,
@@ -170,6 +171,7 @@ export const STATIC_REST_BINDINGS = [
   fleetEventsSseRestBinding,
   getTaskDiagnosticsRestBinding,
   clearTaskDeadLetterRestBinding,
+  getTaskDetailRestBinding,
   listSchedulesRestBinding,
   getScheduleRestBinding,
   replayWorkflowRestBinding,
@@ -233,6 +235,7 @@ export const STATIC_REST_BINDINGS = [
   workflowEventsSubscriptionOperation,
   fleetEventsSubscriptionOperation,
   clearTaskDeadLetterOperation,
+  getTaskDetailOperation,
   listSchedulesOperation,
   listAlertsOperation,
   getPrincipalOperation,

package/dist/storage/auto.js

@@ -1,2 +1,2 @@
 // @bun
-var Z=import.meta.require,I=(z,C,J)=>{if(C!=null){if(typeof C!=="object"&&typeof C!=="function")throw TypeError('Object expected to be assigned to "using" declaration');let K;if(J)K=C[Symbol.asyncDispose];if(K===void 0)K=C[Symbol.dispose];if(typeof K!=="function")throw TypeError("Object not disposable");z.push([J,K,C])}else if(J)z.push([J]);return C},L=(z,C,J)=>{let K=(V)=>C=J?new SuppressedError(V,C,"An error was suppressed during disposal"):(J=!0,V),Y=(V)=>{while(V=z.pop())try{var A=V[1]&&V[1].call(V[2]);if(V[0])return Promise.resolve(A).then(Y,(q)=>(K(q),Y()))}catch(q){K(q)}if(J)throw C};return Y()};function F(z){return{hasBun:typeof z.Bun<"u",hasIndexedDB:typeof z.indexedDB<"u",hasNode:z.process!==void 0&&typeof z.process.versions?.node==="string",hasWebExtensionStorage:z.browser?.storage!==void 0||z.chrome?.storage!==void 0}}async function P(z){let{createHash:C}=await import("crypto"),J=z.process?.cwd?.()??"weft-default";return C("sha256").update(J).digest("hex").slice(0,16)}async function X(z){let[{mkdirSync:C},{tmpdir:J},K]=await Promise.all([import("fs"),import("os"),import("path")]),Y=z.process?.env?.WEFT_DEFAULT_STORAGE_PATH,V=Y!==void 0&&Y.length>0?Y:K.join(J(),"weft-default",`${await P(z)}.db`);return C(K.dirname(V),{recursive:!0}),V}function H(z,C){if(C==="Bun")return typeof z.Bun;if(C==="browser.storage")return typeof(z.browser?.storage??z.chrome?.storage);return typeof z.process}function j(z,C){return import.meta.url.endsWith(".ts")?z:C}async function $(z){return await import(z)}function k(z){if(z.browser?.storage!==void 0)return z.browser;if(z.chrome?.storage!==void 0)return z.chrome;return{}}function Q(z){let{indexedDB:C,IDBKeyRange:J}=z;if(C===void 0||J===void 0)throw Error("resolveDefaultStorage: IndexedDB resolution requires both indexedDB and IDBKeyRange.");return{indexedDB:C,IDBKeyRange:J}}function U(z){let C=typeof z.indexedDB,J=typeof z.IDBKeyRange;return`typeof indexedDB=${C}, typeof IDBKeyRange=${J}`}var W=j("./bun-sql.ts","./bun-sql.js"),B=j("./node-sqlite.ts","./node-sqlite.js"),N=j("./indexeddb.ts","./indexeddb.js"),w=j("./web-extension.ts","./web-extension.js");async function T(z=globalThis){let C=F(z);if(C.hasBun){let{BunSQLiteStorage:J}=await $(W);return new J(await X(z))}if(C.hasNode){let{NodeSQLiteStorage:J}=await $(B);return new J(await X(z))}if(C.hasWebExtensionStorage){let{WebExtensionStorage:J}=await $(w);return new J({},k(z))}if(C.hasIndexedDB){let{IndexedDBStorage:J}=await $(N);return new J("weft",Q(z))}throw Error(`resolveDefaultStorage: requires Bun, Node, WebExtension storage, or IndexedDB. Detected: typeof Bun=${H(z,"Bun")}, typeof process=${H(z,"process")}, typeof browser.storage=${H(z,"browser.storage")}, ${U(z)}.`)}export{T as resolveDefaultStorage};
+var K=import.meta.require;function X(z){return{hasBun:typeof z.Bun<"u",hasIndexedDB:typeof z.indexedDB<"u",hasNode:z.process!==void 0&&typeof z.process.versions?.node==="string",hasWebExtensionStorage:z.browser?.storage!==void 0||z.chrome?.storage!==void 0}}async function A(z){let{createHash:C}=await import("crypto"),J=z.process?.cwd?.()??"weft-default";return C("sha256").update(J).digest("hex").slice(0,16)}async function H(z){let[{mkdirSync:C},{tmpdir:J},j]=await Promise.all([import("fs"),import("os"),import("path")]),Z=z.process?.env?.WEFT_DEFAULT_STORAGE_PATH,q=Z!==void 0&&Z.length>0?Z:j.join(J(),"weft-default",`${await A(z)}.db`);return C(j.dirname(q),{recursive:!0}),q}function $(z,C){if(C==="Bun")return typeof z.Bun;if(C==="browser.storage")return typeof(z.browser?.storage??z.chrome?.storage);return typeof z.process}function Y(z,C){return import.meta.url.endsWith(".ts")?z:C}async function V(z){return await import(z)}function F(z){if(z.browser?.storage!==void 0)return z.browser;if(z.chrome?.storage!==void 0)return z.chrome;return{}}function P(z){let{indexedDB:C,IDBKeyRange:J}=z;if(C===void 0||J===void 0)throw Error("resolveDefaultStorage: IndexedDB resolution requires both indexedDB and IDBKeyRange.");return{indexedDB:C,IDBKeyRange:J}}function k(z){let C=typeof z.indexedDB,J=typeof z.IDBKeyRange;return`typeof indexedDB=${C}, typeof IDBKeyRange=${J}`}var Q=Y("./bun-sql.ts","./bun-sql.js"),U=Y("./node-sqlite.ts","./node-sqlite.js"),W=Y("./indexeddb.ts","./indexeddb.js"),B=Y("./web-extension.ts","./web-extension.js");async function w(z=globalThis){let C=X(z);if(C.hasBun){let{BunSQLiteStorage:J}=await V(Q);return new J(await H(z))}if(C.hasNode){let{NodeSQLiteStorage:J}=await V(U);return new J(await H(z))}if(C.hasWebExtensionStorage){let{WebExtensionStorage:J}=await V(B);return new J({},F(z))}if(C.hasIndexedDB){let{IndexedDBStorage:J}=await V(W);return new J("weft",P(z))}throw Error(`resolveDefaultStorage: requires Bun, Node, WebExtension storage, or IndexedDB. Detected: typeof Bun=${$(z,"Bun")}, typeof process=${$(z,"process")}, typeof browser.storage=${$(z,"browser.storage")}, ${k(z)}.`)}export{w as resolveDefaultStorage};