@ricsam/r5d-worker 0.0.93 → 0.0.95

package/dist/mjs/project-worktrees.mjs

@@ -4,6 +4,12 @@ import os from "node:os";
 import path from "node:path";
 import { gitCredentialUsernameConfigKey, gitTransportSecurityArgs, workerGitProcessEnvironment } from "./git-process-environment.mjs";
 import { validateManagedBranchName } from "./managed-paths.mjs";
+import {
+  canonicalizeLocalProjectMirrorRefs,
+  hashProjectMirrorRefs,
+  PROJECT_MIRROR_REF_PREFIX,
+  PROJECT_SERVER_SYNCED_REF_PREFIX
+} from "./project-mirror-refs-token.mjs";
 import { mirrorWorkingTree } from "./working-tree-mirror.mjs";
 const PROJECT_WORKTREE_SNAPSHOT_PREFIX = "r5d-project-worktrees-";
 const PROJECT_WORKTREE_SNAPSHOT_MANIFEST = "transaction.json";
@@ -11,6 +17,7 @@ const PROJECT_WORKTREE_SNAPSHOT_MANIFEST_VERSION = 1;
 const MAX_PROJECT_WORKTREE_SNAPSHOT_MANIFEST_BYTES = 64 * 1024;
 const PROJECT_WORKTREE_SNAPSHOT_OWNER_SESSION_ID = randomUUID();
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const PROJECT_GIT_TRANSPORT_TIMEOUT_MS = 3e4;
 const PROJECT_WORKTREE_SNAPSHOT_NAME = new RegExp(
   `^${PROJECT_WORKTREE_SNAPSHOT_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([1-9]\\d*)-([A-Za-z0-9]{6})$`
 );
@@ -80,7 +87,7 @@ function git(cwd, args, action) {
 function tryGit(cwd, args) {
   return gitResult(cwd, args).exitCode === 0;
 }
-async function gitResultAsync(cwd, args) {
+async function gitResultAsync(cwd, args, timeoutMs) {
   const subprocess = Bun.spawn(gitCommandArgs(args), {
     cwd,
     stdin: "ignore",
@@ -88,12 +95,22 @@ async function gitResultAsync(cwd, args) {
     stderr: "pipe",
     env: workerGitProcessEnvironment()
   });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(subprocess.stdout).text(),
-    new Response(subprocess.stderr).text(),
-    subprocess.exited
-  ]);
-  return { exitCode, stdout: stdout.trim(), stderr: stderr.trim() };
+  let timedOut = false;
+  const timeout = timeoutMs ? setTimeout(() => {
+    timedOut = true;
+    subprocess.kill("SIGKILL");
+  }, timeoutMs) : void 0;
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(subprocess.stdout).text(),
+      new Response(subprocess.stderr).text(),
+      subprocess.exited
+    ]);
+    if (timedOut) throw new Error(`Git transport timed out after ${timeoutMs}ms`);
+    return { exitCode, stdout: stdout.trim(), stderr: stderr.trim() };
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
 }
 async function gitAsync(cwd, args, action) {
   const result = await gitResultAsync(cwd, args);
@@ -808,25 +825,33 @@ async function configureRepository(input) {
   }
 }
 async function fetchProjectHeads(input) {
-  const originFetch = await gitResultAsync(input.primaryPath, [
-    ...gitTransportSecurityArgs(input.originUrl, input.credentialHelper, input.originCredentialUsername),
-    "fetch",
-    "--no-recurse-submodules",
-    "--prune",
-    "origin",
-    "+refs/heads/*:refs/remotes/origin/*"
-  ]);
+  const originFetch = await gitResultAsync(
+    input.primaryPath,
+    [
+      ...gitTransportSecurityArgs(input.originUrl, input.credentialHelper, input.originCredentialUsername),
+      "fetch",
+      "--no-recurse-submodules",
+      "--prune",
+      "origin",
+      "+refs/heads/*:refs/remotes/origin/*"
+    ],
+    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+  );
   if (originFetch.exitCode !== 0) {
     throw new Error(`Fetch project origin: ${originFetch.stderr || originFetch.stdout || `git exited ${originFetch.exitCode}`}`);
   }
-  const mirrorFetch = await gitResultAsync(input.primaryPath, [
-    ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.mirrorCredentialUsername),
-    "fetch",
-    "--no-recurse-submodules",
-    "--prune",
-    input.mirrorUrl,
-    "+refs/heads/*:refs/r5d/mirror/*"
-  ]);
+  const mirrorFetch = await gitResultAsync(
+    input.primaryPath,
+    [
+      ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.mirrorCredentialUsername),
+      "fetch",
+      "--no-recurse-submodules",
+      "--prune",
+      input.mirrorUrl,
+      "+refs/heads/*:refs/r5d/mirror/*"
+    ],
+    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+  );
   if (mirrorFetch.exitCode !== 0 && !/(couldn't find remote ref|does not have any commits|remote repository is empty|no such ref)/i.test(
     `${mirrorFetch.stderr}
 ${mirrorFetch.stdout}`
@@ -1205,19 +1230,24 @@ function removeProjectWorktrees(input) {
 }
 async function deleteProjectMirrorBranch(input) {
   validateManagedBranchName(input.branchName);
-  const deleted = await gitResultAsync(input.gitDirectory, [
-    ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
-    "push",
-    "--no-recurse-submodules",
-    input.mirrorUrl,
-    `:refs/heads/${input.branchName}`
-  ]);
+  const deleted = await gitResultAsync(
+    input.gitDirectory,
+    [
+      ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
+      "push",
+      "--no-recurse-submodules",
+      input.mirrorUrl,
+      `:refs/heads/${input.branchName}`
+    ],
+    PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+  );
   if (deleted.exitCode !== 0 && !/(remote ref does not exist|unable to delete|no such ref)/i.test(`${deleted.stderr}
 ${deleted.stdout}`)) {
     throw new Error(
       `Delete hidden project mirror for ${input.branchName}: ${deleted.stderr || deleted.stdout || `git exited ${deleted.exitCode}`}`
     );
   }
+  await gitResultAsync(input.gitDirectory, ["update-ref", "-d", `refs/r5d/mirror/${input.branchName}`]);
 }
 async function pushProjectMirrorHeads(input) {
   const results = [];
@@ -1231,21 +1261,51 @@ async function pushProjectMirrorHeads(input) {
     if (!await tryGitAsync(checkoutPath, ["cat-file", "-e", `${head}^{commit}`])) {
       throw new Error(`Exact publication head ${head} is unavailable for project branch ${branchName}`);
     }
+    if (!input.expectedMirrorHeads.has(branchName)) {
+      throw new Error(`Missing hidden-mirror lease for project branch ${branchName}`);
+    }
+    const expectedMirrorHead = input.expectedMirrorHeads.get(branchName) ?? null;
+    if (expectedMirrorHead !== null && !/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(expectedMirrorHead)) {
+      throw new Error(`Invalid hidden-mirror lease for project branch ${branchName}`);
+    }
+    const branchId = input.branchIds.get(branchName);
+    if (!branchId || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(branchId)) {
+      throw new Error(`Missing valid branch incarnation for project branch ${branchName}`);
+    }
+    if (expectedMirrorHead) {
+      const handoffPrefix = `refs/r5d/server-synced/${branchId}/`;
+      const markedCommits = (await gitAsync(
+        checkoutPath,
+        ["for-each-ref", "--format=%(objectname)", handoffPrefix],
+        `inspect synchronized server commits before publishing ${branchName}`
+      )).split(/\r?\n/).filter((value) => /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(value));
+      for (const markedCommit of markedCommits) {
+        const markerIsInLease = await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", markedCommit, expectedMirrorHead]);
+        if (markerIsInLease && !await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", markedCommit, head])) {
+          throw new Error(`Refusing to overwrite synchronized server commit history for project branch ${branchName}`);
+        }
+      }
+    }
     if (projectWorktreeOperationInProgress(checkoutPath)) {
       results.push({ branchName, head, pushed: false, reason: "git_operation_in_progress" });
       continue;
     }
-    await gitAsync(
+    const pushed = await gitResultAsync(
       checkoutPath,
       [
         ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
         "push",
         "--no-recurse-submodules",
+        `--force-with-lease=refs/heads/${branchName}:${expectedMirrorHead ?? ""}`,
         input.mirrorUrl,
-        `+${head}:refs/heads/${branchName}`
+        `${head}:refs/heads/${branchName}`
       ],
-      `push hidden project mirror for ${branchName}`
+      PROJECT_GIT_TRANSPORT_TIMEOUT_MS
     );
+    if (pushed.exitCode !== 0) {
+      throw new Error(`Push hidden project mirror for ${branchName}: ${pushed.stderr || pushed.stdout || `git exited ${pushed.exitCode}`}`);
+    }
+    await gitAsync(checkoutPath, ["update-ref", `refs/r5d/mirror/${branchName}`, head], `record pushed mirror tip ${branchName}`);
     results.push({ branchName, head, pushed: true });
   }
   return results;
@@ -1258,42 +1318,94 @@ function assertProjectMirrorHeadsPushed(results) {
 }
 async function observeProjectMirrorHeads(input) {
   const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
-  const fetch = await gitResultAsync(primaryPath, [
-    ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
-    "fetch",
-    "--no-recurse-submodules",
-    "--prune",
-    input.mirrorUrl,
-    "+refs/heads/*:refs/r5d/mirror/*"
-  ]);
-  if (fetch.exitCode !== 0)
-    throw new Error(`Refresh project head mirror: ${fetch.stderr || fetch.stdout || `git exited ${fetch.exitCode}`}`);
+  if (input.refreshRemote !== false) {
+    const fetch = await gitResultAsync(
+      primaryPath,
+      [
+        ...gitTransportSecurityArgs(input.mirrorUrl, input.credentialHelper, input.credentialUsername),
+        "fetch",
+        "--no-recurse-submodules",
+        "--prune",
+        input.mirrorUrl,
+        "+refs/heads/*:refs/r5d/mirror/*",
+        "+refs/r5d/server-synced/*:refs/r5d/server-synced/*"
+      ],
+      PROJECT_GIT_TRANSPORT_TIMEOUT_MS
+    );
+    if (fetch.exitCode !== 0)
+      throw new Error(`Refresh project head mirror: ${fetch.stderr || fetch.stdout || `git exited ${fetch.exitCode}`}`);
+  }
   const observations = [];
   for (const branchName of [...input.branchNames].sort()) {
     const checkoutPath = branchPath(input.projectRoot, branchName);
     const previousHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
     const mirrorRef = `refs/r5d/mirror/${branchName}`;
     const mirrorHead = await tryGitAsync(primaryPath, ["show-ref", "--verify", "--quiet", mirrorRef]) ? await gitAsync(primaryPath, ["rev-parse", mirrorRef], `resolve refreshed mirror head ${branchName}`) : null;
-    const shouldMove = Boolean(
-      mirrorHead && mirrorHead !== previousHead && (input.allowNonFastForward || await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", previousHead, mirrorHead]))
+    const branchId = input.branchIds?.get(branchName);
+    if (branchId && !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(branchId)) throw new Error(`Invalid branch id for ${branchName}`);
+    const handoffPrefix = branchId ? `refs/r5d/server-synced/${branchId}/` : null;
+    const handoffRows = handoffPrefix ? await gitAsync(
+      primaryPath,
+      ["for-each-ref", "--format=%(objectname) %(refname)", handoffPrefix],
+      `inspect synchronized server commits for ${branchName}`
+    ) : "";
+    const serverSyncedWorkspaceHeads = (await Promise.all(
+      handoffRows.split(/\r?\n/).map(async (row) => {
+        const separator = row.indexOf(" ");
+        if (separator < 0 || !mirrorHead) return null;
+        const markedCommit = row.slice(0, separator);
+        const ref = row.slice(separator + 1);
+        if (!/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(markedCommit) || !handoffPrefix || !ref.startsWith(handoffPrefix)) {
+          return null;
+        }
+        const markerIsIntegrated = markedCommit === mirrorHead || await tryGitAsync(primaryPath, ["merge-base", "--is-ancestor", markedCommit, mirrorHead]);
+        if (!markerIsIntegrated) return null;
+        const workspaceHead = ref.slice(handoffPrefix.length);
+        return /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(workspaceHead) ? workspaceHead : null;
+      })
+    )).filter((workspaceHead) => workspaceHead !== null).sort();
+    const fastForward = Boolean(
+      mirrorHead && mirrorHead !== previousHead && await tryGitAsync(checkoutPath, ["merge-base", "--is-ancestor", previousHead, mirrorHead])
     );
+    const serverSynced = Boolean(mirrorHead && mirrorHead !== previousHead && serverSyncedWorkspaceHeads.length > 0);
+    const shouldMove = Boolean(mirrorHead && mirrorHead !== previousHead && (input.allowNonFastForward || fastForward || serverSynced));
     observations.push({
       branchName,
       previousHead,
       mirrorHead,
-      mode: input.allowNonFastForward ? "reseed" : "fast_forward",
+      mode: input.allowNonFastForward ? "reseed" : serverSynced && !fastForward ? "server_synced" : "fast_forward",
+      serverSyncedWorkspaceHeads,
       shouldMove
     });
   }
   return observations;
 }
+async function computeLocalProjectMirrorRefsToken(input) {
+  const primaryPath = branchPath(input.projectRoot, input.primaryBranchName);
+  const rows = await gitAsync(
+    primaryPath,
+    ["for-each-ref", "--format=%(objectname) %(refname)", PROJECT_MIRROR_REF_PREFIX, PROJECT_SERVER_SYNCED_REF_PREFIX],
+    "list cached project mirror refs"
+  );
+  const refs = rows.split(/\r?\n/).filter(Boolean).map((row) => {
+    const separator = row.indexOf(" ");
+    const objectName = separator < 0 ? "" : row.slice(0, separator);
+    const refname = separator < 0 ? "" : row.slice(separator + 1);
+    if (!/^[0-9a-f]{40,64}$/.test(objectName) || refname.length === 0) {
+      throw new Error(`Invalid cached mirror ref listing row: ${row}`);
+    }
+    return { refname, objectName };
+  });
+  return hashProjectMirrorRefs(canonicalizeLocalProjectMirrorRefs(refs));
+}
 async function applyObservedProjectMirrorHeads(input) {
   const results = [];
   for (const observation of [...input.observations].sort((left, right) => left.branchName.localeCompare(right.branchName))) {
     const { branchName, mirrorHead } = observation;
     const checkoutPath = branchPath(input.projectRoot, branchName);
     const currentHead = await gitAsync(checkoutPath, ["rev-parse", "HEAD"], `resolve local project head ${branchName}`);
-    if (!observation.shouldMove || !mirrorHead || currentHead === mirrorHead || currentHead !== observation.previousHead) {
+    const serverSyncedCovered = observation.mode !== "server_synced" || (input.serverSyncedWorkspaceCovered ? await input.serverSyncedWorkspaceCovered(observation) : false);
+    if (!observation.shouldMove || !serverSyncedCovered || !mirrorHead || currentHead === mirrorHead || currentHead !== observation.previousHead) {
       results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
       continue;
     }
@@ -1305,14 +1417,14 @@ async function applyObservedProjectMirrorHeads(input) {
       results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
       continue;
     }
-    if (observation.mode === "reseed") {
+    if (observation.mode === "reseed" || observation.mode === "server_synced") {
       await preserveHead(checkoutPath);
       if (!mutationAllowed()) {
         results.push({ branchName, previousHead: currentHead, mirrorHead, moved: false });
         continue;
       }
     }
-    const action = observation.mode === "reseed" ? "reseed" : "fast-forward";
+    const action = observation.mode === "reseed" ? "reseed" : observation.mode === "server_synced" ? "adopt server commit" : "fast-forward";
     await gitAsync(checkoutPath, ["read-tree", "--reset", mirrorHead], `${action} project index ${branchName}`);
     await gitAsync(
       checkoutPath,
@@ -1367,6 +1479,7 @@ export {
   ProjectBranchCreationRollbackIncompleteError,
   applyObservedProjectMirrorHeads,
   assertProjectMirrorHeadsPushed,
+  computeLocalProjectMirrorRefsToken,
   createLinkedProjectBranch,
   createOrRetryLinkedProjectBranch,
   deleteLinkedProjectBranch,

package/dist/types/main.d.ts

@@ -125,6 +125,15 @@ type WorkerServerMessage = {
     confirmationReason?: string;
     resetToCanonical?: boolean;
     requiredAncestorHeads?: string[];
+} | {
+    /**
+     * Content-derived tokens naming each canonical project repository's
+     * observable ref state, keyed by project id. Replace-all: projects
+     * absent from a message have no advertised token and observation falls
+     * back to fetching. See `project-mirror-fetch-policy.ts`.
+     */
+    type: "project_mirror_refs_tokens";
+    tokens: Record<string, string>;
 } | {
     type: "create_project_branch";
     requestId: string;

package/dist/types/project-mirror-fetch-policy.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Decides whether a periodic observation must fetch a project's hidden mirror
+ * or may reuse the locally cached mirror refs. The server advertises a
+ * content-derived token per project (hash of the exact ref namespaces the
+ * observation fetch would transfer); when the advertised token equals the
+ * token the local refs already cover, the fetch would be a no-op.
+ *
+ * Skipping is fail-open: any missing or mismatched information fetches. The
+ * backstop bounds the damage of a server-side token bug (for example a token
+ * computed against the wrong repository path) to one interval; every
+ * git-transport writer is observed by the server's on-disk recompute, so the
+ * backstop is insurance against bugs, not against known unobserved writers.
+ */
+export declare const PROJECT_MIRROR_FETCH_BACKSTOP_MS: number;
+export type ProjectMirrorFetchDecision = {
+    fetch: true;
+    reason: "skipping_disabled" | "no_advertised_token" | "never_fetched" | "token_changed" | "backstop_elapsed";
+} | {
+    fetch: false;
+    reason: "token_match";
+};
+export declare function projectMirrorFetchDecision(input: {
+    advertisedToken: string | undefined;
+    fetchedToken: string | undefined;
+    lastFetchAtMs: number | undefined;
+    nowMs: number;
+    skippingEnabled: boolean;
+    backstopMs?: number;
+}): ProjectMirrorFetchDecision;

package/dist/types/project-mirror-refs-token.d.ts

@@ -0,0 +1,19 @@
+export declare const PROJECT_MIRROR_REF_PREFIX = "refs/r5d/mirror/";
+export declare const PROJECT_SERVER_SYNCED_REF_PREFIX = "refs/r5d/server-synced/";
+export type ProjectMirrorRef = {
+    refname: string;
+    objectName: string;
+};
+/**
+ * Hash a ref listing into a mirror-refs token. Both sides sort here rather
+ * than trusting git's listing order: renaming `refs/r5d/mirror/*` back to
+ * `refs/heads/*` changes sort neighborhoods.
+ */
+export declare function hashProjectMirrorRefs(refs: readonly ProjectMirrorRef[]): string;
+/**
+ * Rename locally fetched mirror refs into the namespaces the server hashes.
+ * Rows outside the two observed namespaces are dropped; the caller lists only
+ * those namespaces, so a dropped row means an unexpected listing, and dropping
+ * it can only make tokens differ — which fails open into a fetch.
+ */
+export declare function canonicalizeLocalProjectMirrorRefs(refs: readonly ProjectMirrorRef[]): ProjectMirrorRef[];

package/dist/types/project-worktrees.d.ts

@@ -175,6 +175,10 @@ export declare function pushProjectMirrorHeads(input: {
     onlyBranches?: ReadonlySet<string>;
     /** Exact pre-projection commits to publish after the outer tree is reachable. */
     publicationHeads?: ReadonlyMap<string, string>;
+    /** Hidden-mirror tips observed before the corresponding outer projection. */
+    expectedMirrorHeads: ReadonlyMap<string, string | null>;
+    /** Durable branch incarnations used to scope server-authored handoff refs. */
+    branchIds: ReadonlyMap<string, string>;
 }): Promise<Array<{
     branchName: string;
     head: string;
@@ -200,17 +204,40 @@ export type ProjectMirrorHeadObservation = {
     branchName: string;
     previousHead: string;
     mirrorHead: string | null;
-    mode: "fast_forward" | "reseed";
+    mode: "fast_forward" | "reseed" | "server_synced";
+    serverSyncedWorkspaceHeads: string[];
     shouldMove: boolean;
 };
 /**
  * Fetch and pin the exact hidden-mirror tips that may be applied after a
  * causally later outer-workspace fetch and hydration. Observation deliberately
  * does not mutate a live branch or its index.
+ *
+ * With `refreshRemote: false` the network fetch is skipped and the tips come
+ * from the locally cached `refs/r5d/mirror/*` / `refs/r5d/server-synced/*`
+ * refs of an earlier fetch. That is safe in the stale direction (a newer
+ * mirror tip waits for a later cycle, exactly like a tip that lands mid-cycle
+ * today) and in the fresh direction (hidden-mirror publication is tree-first,
+ * so any locally cached tip's covering outer tree was published before the
+ * fetch that cached it, hence before this cycle's outer fetch).
  */
 export declare function observeProjectMirrorHeads(input: Omit<ProjectMirrorHeadUpdateInput, "branchMutationAllowed"> & {
     allowNonFastForward: boolean;
+    branchIds?: ReadonlyMap<string, string>;
+    refreshRemote?: boolean;
 }): Promise<ProjectMirrorHeadObservation[]>;
+/**
+ * Compute the mirror-refs token for the locally cached mirror state — the
+ * token the server will advertise once it hashes the same refs. After a
+ * successful lease push (which updates `refs/r5d/mirror/*` above), this
+ * matches the server's next advertisement unless something else also moved
+ * the canonical repository, in which case the mismatch fails open into a
+ * fetch. Formula twin: `server/git/project-mirror-refs-token.ts`.
+ */
+export declare function computeLocalProjectMirrorRefsToken(input: {
+    projectRoot: string;
+    primaryBranchName: string;
+}): Promise<string>;
 /** Apply only previously observed object ids; this function never refetches. */
 export declare function applyObservedProjectMirrorHeads(input: {
     projectRoot: string;
@@ -218,6 +245,8 @@ export declare function applyObservedProjectMirrorHeads(input: {
     observations: readonly ProjectMirrorHeadObservation[];
     /** Rechecked immediately before refs or the index move. */
     branchMutationAllowed?: (branchName: string, checkoutPath: string) => boolean;
+    /** Proves the visible outer workspace has hydrated the server commit's exact source generation. */
+    serverSyncedWorkspaceCovered?: (observation: ProjectMirrorHeadObservation) => Promise<boolean>;
 }): Promise<Array<{
     branchName: string;
     previousHead: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.93",
+  "version": "0.0.95",
   "type": "module",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/mjs/main.mjs",