@remnic/plugin-pi 9.3.703 → 9.3.705

package/dist/publisher.d.ts

@@ -1,3 +1,4 @@
+import path from 'node:path';
 import { MemoryExtensionPublisher, PublisherCapabilities, PublishContext, PublishResult } from '@remnic/core';
 
 /**
@@ -33,6 +34,36 @@ declare class HostMemoryExtensionPublisher implements MemoryExtensionPublisher {
     private readonly host;
     static readonly capabilities: PublisherCapabilities;
     protected constructor(host: HostPublisherDescriptor);
+    /**
+     * File basenames this publisher owns inside the extension root. The shared
+     * set is config + wrapper + readme; subclasses add host-specific files
+     * (e.g. omp's pre-bundle loader + package manifest). Used for snapshot,
+     * atomic-write rollback, and unpublish cleanup.
+     */
+    protected get ownedFileNames(): readonly string[];
+    /**
+     * Directory names this publisher owns inside the extension root (build
+     * outputs). Recursively removed on unpublish and on publish rollback when
+     * newly created.
+     */
+    protected get ownedDirNames(): readonly string[];
+    /**
+     * Whether the generated wrapper must use a bun-buildable import specifier
+     * (relative path) instead of a file:// URL. omp pre-bundles the wrapper with
+     * `bun build`, which cannot resolve file:// specifiers; pi loads the wrapper
+     * directly via tsx and keeps the file:// URL.
+     */
+    protected get usesBundledWrapper(): boolean;
+    /**
+     * Hook for subclasses to write host-specific files and run install-time
+     * build steps after the shared config/wrapper/readme are written. Runs
+     * inside the publish try-block: a throw triggers full rollback.
+     */
+    protected finalizePublish(_ctx: PublishContext, _extensionRoot: string, _paths: {
+        configPath: string;
+        wrapperPath: string;
+        pluginPiDistPath: string;
+    }): void;
     get hostId(): string;
     resolveExtensionRoot(env?: NodeJS.ProcessEnv): Promise<string>;
     isHostAvailable(): Promise<boolean>;
@@ -47,6 +78,61 @@ declare class PiMemoryExtensionPublisher extends HostMemoryExtensionPublisher {
 /** Publisher for Oh My Pi / omp (`~/.omp/agent/extensions/remnic`). */
 declare class OmpMemoryExtensionPublisher extends HostMemoryExtensionPublisher {
     constructor();
+    protected get ownedFileNames(): readonly string[];
+    protected get ownedDirNames(): readonly string[];
+    protected get usesBundledWrapper(): boolean;
+    protected finalizePublish(ctx: PublishContext, extensionRoot: string, paths: {
+        configPath: string;
+        wrapperPath: string;
+        pluginPiDistPath: string;
+    }): void;
+    /**
+     * Pre-bundles the omp extension with `bun build` so omp's embedded runtime
+     * never resolves bare npm specifiers (e.g. @sinclair/typebox) from the
+     * extension's node_modules at load time. The bundle is written to a temp
+     * directory and swapped into dist-bundle/ on success. The pre-existing
+     * dist-bundle is renamed aside (not removed) before the swap, so a failure
+     * during the final rename restores the previously working bundle rather than
+     * leaving the install with no bundle at all.
+     *
+     * Override in tests to skip the real bun invocation.
+     */
+    protected runBundleBuild(ctx: PublishContext, extensionRoot: string, bunBin: string): void;
 }
+/**
+ * Resolves the import specifier the omp wrapper uses to reach the
+ * `@remnic/plugin-pi` dist entry from the generated `index.ts`. omp pre-bundles
+ * that wrapper with `bun build`, whose bundler cannot resolve `file://`
+ * specifiers ("Could not resolve: file://…" on Bun 1.2–1.3, verified), so the
+ * specifier must be a relative path. On Windows, when the extension directory
+ * and the plugin-pi install sit on different drives, `path.relative` cannot
+ * express a relative path and returns an absolute drive path (e.g. `D:\…`);
+ * prefixing `./` then yields an invalid module specifier that fails `bun build`
+ * with a cryptic error. Detect that layout and fail fast with an actionable
+ * message instead. (Cross-drive omp installs are unsupported because neither a
+ * relative specifier nor a `file://` URL is acceptable to `bun build`.) Drive
+ * roots are compared case-insensitively so a same-drive Windows install is not
+ * falsely rejected when the agent home and the plugin-pi install report the
+ * drive letter in different casing (`C:\\` vs `c:\\`).
+ *
+ * Exported so the cross-drive guard can be exercised on non-Windows hosts via
+ * `path.win32`.
+ */
+declare function resolveOmpWrapperImportSpecifier(extensionModulePath: string, wrapperDir: string, pathApi?: typeof path): string;
+/**
+ * Walks `PATH` the way a shell does and returns the first `bun` executable it
+ * finds, as a realpath-resolved absolute path (or null when nothing on PATH
+ * is an executable `bun`). Used so the install-time PATH probe can embed an
+ * absolute bun path in the generated loader/postinstall instead of the bare
+ * string `"bun"`, which would break self-heal rebuilds under a stripped
+ * runtime PATH (GUI/service launches). Mirrors `which(1)`; no dependency.
+ */
+declare function resolveBunOnPath(): string | null;
+/**
+ * Resolves the `bun` binary for the install-time pre-bundle. Honours
+ * `REMNIC_OMP_BUN_BIN` (test/override seam), then PATH, then common locations.
+ * Returns null when bun is unavailable so the caller can fail with guidance.
+ */
+declare function resolveBunBinary(): string | null;
 
-export { HostMemoryExtensionPublisher, type HostPublisherDescriptor, OmpMemoryExtensionPublisher, PiMemoryExtensionPublisher };
+export { HostMemoryExtensionPublisher, type HostPublisherDescriptor, OmpMemoryExtensionPublisher, PiMemoryExtensionPublisher, resolveBunBinary, resolveBunOnPath, resolveOmpWrapperImportSpecifier };

package/dist/publisher.js

@@ -4,20 +4,22 @@ import {
   resolveOmpExtensionRoot,
   resolvePiAgentHome,
   resolvePiExtensionRoot
-} from "./chunk-A5WP5NTC.js";
+} from "./chunk-ASGQGBO2.js";
 
 // src/publisher.ts
 import fs from "fs";
+import { spawnSync } from "child_process";
 import path from "path";
 import { fileURLToPath, pathToFileURL } from "url";
+import os from "os";
 import {
   getConnectorToken,
   loadTokenStore,
   saveTokenStore
 } from "@remnic/core";
 var DEFAULT_DAEMON_PORT = 4318;
-var EXTENSION_OWNED_FILES = ["remnic.config.json", "index.ts", "README.md"];
-var EXTENSION_OWNED_TEMP_FILE_PATTERN = /^(?:remnic\.config\.json|index\.ts|README\.md)\.tmp-\d+-\d+$/u;
+var BASE_OWNED_FILES = ["remnic.config.json", "index.ts", "README.md"];
+var EXTENSION_OWNED_TEMP_FILE_SUFFIX = /\.tmp-\d+-\d+$/u;
 var PI_HOST = {
   hostId: "pi",
   connectorId: "pi",
@@ -71,6 +73,39 @@ var HostMemoryExtensionPublisher = class {
     citationFormat: false,
     readPathTemplate: false
   };
+  /**
+   * File basenames this publisher owns inside the extension root. The shared
+   * set is config + wrapper + readme; subclasses add host-specific files
+   * (e.g. omp's pre-bundle loader + package manifest). Used for snapshot,
+   * atomic-write rollback, and unpublish cleanup.
+   */
+  get ownedFileNames() {
+    return BASE_OWNED_FILES;
+  }
+  /**
+   * Directory names this publisher owns inside the extension root (build
+   * outputs). Recursively removed on unpublish and on publish rollback when
+   * newly created.
+   */
+  get ownedDirNames() {
+    return [];
+  }
+  /**
+   * Whether the generated wrapper must use a bun-buildable import specifier
+   * (relative path) instead of a file:// URL. omp pre-bundles the wrapper with
+   * `bun build`, which cannot resolve file:// specifiers; pi loads the wrapper
+   * directly via tsx and keeps the file:// URL.
+   */
+  get usesBundledWrapper() {
+    return false;
+  }
+  /**
+   * Hook for subclasses to write host-specific files and run install-time
+   * build steps after the shared config/wrapper/readme are written. Runs
+   * inside the publish try-block: a throw triggers full rollback.
+   */
+  finalizePublish(_ctx, _extensionRoot, _paths) {
+  }
   get hostId() {
     return this.host.hostId;
   }
@@ -112,9 +147,16 @@ var HostMemoryExtensionPublisher = class {
     const filesWritten = [];
     const skipped = [];
     ctx.log.info(`Publishing ${this.host.displayName} memory extension to ${extensionRoot}`);
-    const [configPath, wrapperPath, readmePath] = extensionOwnedPaths(extensionRoot);
+    const ownedFilePaths = this.ownedFileNames.map((fileName) => path.join(extensionRoot, fileName));
+    const configPath = ownedFilePaths[0];
+    const wrapperPath = ownedFilePaths[1];
+    const readmePath = ownedFilePaths[2];
+    const pluginPiDistPath = resolveExtensionModulePath();
     const rootExisted = fs.existsSync(extensionRoot);
-    const snapshots = snapshotFiles([configPath, wrapperPath, readmePath]);
+    const fileSnapshots = snapshotFiles(ownedFilePaths);
+    const dirSnapshots = snapshotDirs(
+      this.ownedDirNames.map((dirName) => path.join(extensionRoot, dirName))
+    );
     const priorTokenEntry = ctx.rollbackTokenEntry === void 0 ? snapshotTokenEntry(this.host.connectorId) : cloneTokenEntry(ctx.rollbackTokenEntry);
     const token = getConnectorToken(this.host.connectorId);
     if (!token) {
@@ -149,25 +191,40 @@ var HostMemoryExtensionPublisher = class {
       atomicWriteFile(configPath, `${JSON.stringify(config, null, 2)}
 `, 384);
       filesWritten.push(configPath);
-      atomicWriteFile(wrapperPath, renderWrapper(resolveExtensionModulePath(), configPath), 420);
+      atomicWriteFile(
+        wrapperPath,
+        renderWrapper(
+          pluginPiDistPath,
+          configPath,
+          this.usesBundledWrapper ? extensionRoot : void 0
+        ),
+        420
+      );
       filesWritten.push(wrapperPath);
       atomicWriteFile(readmePath, `${await this.renderInstructions(ctx)}
 `, 420);
       filesWritten.push(readmePath);
+      this.finalizePublish(ctx, extensionRoot, { configPath, wrapperPath, pluginPiDistPath });
+      for (let i = BASE_OWNED_FILES.length; i < ownedFilePaths.length; i++) {
+        filesWritten.push(ownedFilePaths[i]);
+      }
     } catch (err) {
       try {
-        restorePublishSnapshot(extensionRoot, rootExisted, snapshots);
+        restoreDirSnapshots(dirSnapshots);
+        restorePublishSnapshot(extensionRoot, rootExisted, fileSnapshots);
       } catch (restoreErr) {
         ctx.log.warn(
           `${this.host.displayName} extension rollback failed: ${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)}`
         );
       }
-      try {
-        restoreTokenEntry(priorTokenEntry, this.host.connectorId);
-      } catch (tokenErr) {
-        ctx.log.warn(
-          `${this.host.displayName} connector token rollback failed: ${tokenErr instanceof Error ? tokenErr.message : String(tokenErr)}`
-        );
+      if (!(err instanceof OmpPreBundleError)) {
+        try {
+          restoreTokenEntry(priorTokenEntry, this.host.connectorId);
+        } catch (tokenErr) {
+          ctx.log.warn(
+            `${this.host.displayName} connector token rollback failed: ${tokenErr instanceof Error ? tokenErr.message : String(tokenErr)}`
+          );
+        }
       }
       throw err;
     }
@@ -180,6 +237,8 @@ var HostMemoryExtensionPublisher = class {
   }
   async unpublish() {
     const agentHomes = this.host.listRemovalAgentHomes ? this.host.listRemovalAgentHomes(process.env) : [this.host.resolveAgentHome(process.env)];
+    const ownedFileNames = this.ownedFileNames;
+    const ownedDirNames = this.ownedDirNames;
     const seen = /* @__PURE__ */ new Set();
     for (const agentHome of agentHomes) {
       const extensionRoot = path.join(path.resolve(agentHome), "extensions", "remnic");
@@ -187,10 +246,28 @@ var HostMemoryExtensionPublisher = class {
       seen.add(extensionRoot);
       if (!fs.existsSync(extensionRoot)) continue;
       assertSafeExtensionRoot(extensionRoot, agentHome);
-      const removableFiles = removableOwnedExtensionFiles(extensionOwnedUnpublishPaths(extensionRoot));
+      const removableFiles = removableOwnedExtensionFiles(
+        extensionOwnedUnpublishPaths(extensionRoot, ownedFileNames)
+      );
       for (const filePath of removableFiles) {
         fs.rmSync(filePath, { force: true });
       }
+      for (const dirName of ownedDirNames) {
+        const dirPath = path.join(extensionRoot, dirName);
+        let stat;
+        try {
+          stat = fs.lstatSync(dirPath);
+        } catch (err) {
+          if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") continue;
+          throw err;
+        }
+        if (stat.isSymbolicLink()) {
+          throw new Error(`Extension path must not be a symlink: ${dirPath}`);
+        }
+        if (stat.isDirectory()) {
+          fs.rmSync(dirPath, { recursive: true, force: true });
+        }
+      }
       removeEmptyDirectory(extensionRoot);
     }
   }
@@ -200,18 +277,112 @@ var PiMemoryExtensionPublisher = class extends HostMemoryExtensionPublisher {
     super(PI_HOST);
   }
 };
+var OmpPreBundleError = class extends Error {
+};
 var OmpMemoryExtensionPublisher = class extends HostMemoryExtensionPublisher {
   constructor() {
     super(OMP_HOST);
   }
+  get ownedFileNames() {
+    return [...BASE_OWNED_FILES, "loader.js", "package.json", "postinstall-bundle.cjs"];
+  }
+  get ownedDirNames() {
+    return ["dist-bundle"];
+  }
+  // omp pre-bundles index.ts with `bun build`; the wrapper must use a relative
+  // import specifier (bun's bundler cannot resolve file:// URLs).
+  get usesBundledWrapper() {
+    return true;
+  }
+  finalizePublish(ctx, extensionRoot, paths) {
+    const bunBin = resolveBunBinary();
+    if (!bunBin) {
+      throw new OmpPreBundleError(
+        "Remnic omp extension requires `bun` to pre-bundle the extension: omp's embedded runtime cannot resolve bare npm specifiers from the extension's node_modules. Install bun from https://bun.sh, then re-run `remnic connectors install omp`."
+      );
+    }
+    const loaderPath = path.join(extensionRoot, "loader.js");
+    const packageJsonPath = path.join(extensionRoot, "package.json");
+    const postinstallPath = path.join(extensionRoot, "postinstall-bundle.cjs");
+    atomicWriteFile(loaderPath, renderOmpLoader(paths.pluginPiDistPath, bunBin), 420);
+    atomicWriteFile(postinstallPath, renderOmpPostinstall(bunBin), 420);
+    atomicWriteFile(packageJsonPath, renderOmpPackageJson(), 420);
+    try {
+      this.runBundleBuild(ctx, extensionRoot, bunBin);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new OmpPreBundleError(message);
+    }
+  }
+  /**
+   * Pre-bundles the omp extension with `bun build` so omp's embedded runtime
+   * never resolves bare npm specifiers (e.g. @sinclair/typebox) from the
+   * extension's node_modules at load time. The bundle is written to a temp
+   * directory and swapped into dist-bundle/ on success. The pre-existing
+   * dist-bundle is renamed aside (not removed) before the swap, so a failure
+   * during the final rename restores the previously working bundle rather than
+   * leaving the install with no bundle at all.
+   *
+   * Override in tests to skip the real bun invocation.
+   */
+  runBundleBuild(ctx, extensionRoot, bunBin) {
+    const sourceEntry = path.join(extensionRoot, "index.ts");
+    const tmpOutDir = path.join(extensionRoot, `.dist-bundle.tmp-${process.pid}-${Date.now()}`);
+    const finalOutDir = path.join(extensionRoot, "dist-bundle");
+    const result = spawnSync(bunBin, ["build", sourceEntry, "--target=bun", `--outdir=${tmpOutDir}`], {
+      cwd: extensionRoot,
+      encoding: "utf-8"
+    });
+    if (result.error || result.status !== 0) {
+      try {
+        fs.rmSync(tmpOutDir, { recursive: true, force: true });
+      } catch {
+      }
+      const detail = (typeof result.stderr === "string" ? result.stderr.trim() : "") || (result.error instanceof Error ? result.error.message : "") || `bun exited with status ${result.status ?? "null"}`;
+      throw new Error(
+        `Remnic omp extension: bun build failed (${detail}). Resolve the error and re-run \`remnic connectors install omp\`, or build manually with \`bun build index.ts --target=bun --outdir=dist-bundle\` inside ${extensionRoot}.`
+      );
+    }
+    let backupDir = null;
+    try {
+      if (fs.existsSync(finalOutDir)) {
+        backupDir = path.join(extensionRoot, `.dist-bundle.bak-${process.pid}-${Date.now()}`);
+        fs.renameSync(finalOutDir, backupDir);
+      }
+      fs.renameSync(tmpOutDir, finalOutDir);
+      if (backupDir) {
+        try {
+          fs.rmSync(backupDir, { recursive: true, force: true });
+        } catch {
+        }
+      }
+    } catch (err) {
+      try {
+        if (fs.existsSync(tmpOutDir)) fs.rmSync(tmpOutDir, { recursive: true, force: true });
+      } catch {
+      }
+      if (backupDir && fs.existsSync(backupDir) && !fs.existsSync(finalOutDir)) {
+        try {
+          fs.renameSync(backupDir, finalOutDir);
+        } catch {
+        }
+      }
+      throw new Error(
+        `Remnic omp extension: failed to finalize bundle output \u2014 ${err instanceof Error ? err.message : String(err)}.`
+      );
+    }
+    ctx.log.info(`Pre-bundled omp extension into ${finalOutDir}`);
+  }
 };
-function extensionOwnedPaths(extensionRoot) {
-  return EXTENSION_OWNED_FILES.map((fileName) => path.join(extensionRoot, fileName));
+function extensionOwnedPaths(extensionRoot, ownedFileNames) {
+  return ownedFileNames.map((fileName) => path.join(extensionRoot, fileName));
 }
-function extensionOwnedUnpublishPaths(extensionRoot) {
-  const ownedPaths = extensionOwnedPaths(extensionRoot);
+function extensionOwnedUnpublishPaths(extensionRoot, ownedFileNames) {
+  const ownedBaseNames = new Set(ownedFileNames);
+  const ownedPaths = extensionOwnedPaths(extensionRoot, ownedFileNames);
   for (const fileName of fs.readdirSync(extensionRoot)) {
-    if (EXTENSION_OWNED_TEMP_FILE_PATTERN.test(fileName)) {
+    const match = EXTENSION_OWNED_TEMP_FILE_SUFFIX.exec(fileName);
+    if (match && ownedBaseNames.has(fileName.slice(0, match.index))) {
       ownedPaths.push(path.join(extensionRoot, fileName));
     }
   }
@@ -236,15 +407,223 @@ function resolveExtensionModulePath() {
   if (fs.existsSync(source)) return source;
   return built;
 }
-function renderWrapper(extensionModulePath, configPath) {
-  const moduleUrl = pathToFileURL(extensionModulePath).href;
+function resolveOmpWrapperImportSpecifier(extensionModulePath, wrapperDir, pathApi = path) {
+  if (pathApi.parse(wrapperDir).root.toLowerCase() !== pathApi.parse(extensionModulePath).root.toLowerCase()) {
+    throw new Error(
+      `Remnic omp extension cannot pre-bundle: the extension directory (${wrapperDir}) and the @remnic/plugin-pi install (${extensionModulePath}) are on different drives, so no relative import specifier can be generated for \`bun build\` (and \`bun build\` cannot resolve a \`file://\` specifier). Move the omp agent home and the Remnic install onto the same drive.`
+    );
+  }
+  let rel = pathApi.relative(wrapperDir, extensionModulePath);
+  rel = rel.split(pathApi.sep).join("/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function renderWrapper(extensionModulePath, configPath, wrapperDir) {
+  let importSpecifier;
+  if (wrapperDir) {
+    importSpecifier = resolveOmpWrapperImportSpecifier(extensionModulePath, wrapperDir);
+  } else {
+    importSpecifier = pathToFileURL(extensionModulePath).href;
+  }
   return [
-    `import { createRemnicPiExtension } from ${JSON.stringify(moduleUrl)};`,
+    `import { createRemnicPiExtension } from ${JSON.stringify(importSpecifier)};`,
     "",
     `export default createRemnicPiExtension({ configPath: ${JSON.stringify(configPath)} });`,
     ""
   ].join("\n");
 }
+function renderOmpLoader(pluginPiDistPath, bunBin) {
+  return [
+    "// Auto-generated by Remnic's OmpMemoryExtensionPublisher.",
+    "// omp's embedded runtime cannot resolve bare npm specifiers from this",
+    "// extension's node_modules, so we pre-bundle with `bun build` and import",
+    "// the self-contained bundle here. Rebuilt automatically when index.ts or",
+    "// the underlying @remnic/plugin-pi dist changes.",
+    "",
+    'import { existsSync, renameSync, rmSync, statSync } from "node:fs";',
+    'import { spawnSync } from "node:child_process";',
+    'import { dirname, join } from "node:path";',
+    'import { fileURLToPath, pathToFileURL } from "node:url";',
+    "",
+    "const here = dirname(fileURLToPath(import.meta.url));",
+    'const bundleDir = join(here, "dist-bundle");',
+    'const bundleEntry = join(bundleDir, "index.js");',
+    'const sourceEntry = join(here, "index.ts");',
+    `const pluginPiEntry = ${JSON.stringify(pluginPiDistPath)};`,
+    // Reuse the bun path resolved at install time (REMNIC_OMP_BUN_BIN, PATH,
+    // or a common absolute location). Fall back to "bun" on PATH if the
+    // resolved path no longer exists (e.g. the extension tree was moved), so
+    // self-healing still works when bun is reachable only via PATH.
+    `const resolvedBunBin = ${JSON.stringify(bunBin)};`,
+    'const bunForRebuild = resolvedBunBin && existsSync(resolvedBunBin) ? resolvedBunBin : "bun";',
+    "",
+    "function bundleIsStale() {",
+    "  if (!existsSync(bundleEntry)) return true;",
+    "  const bundleMtime = statSync(bundleEntry).mtimeMs;",
+    "  if (existsSync(sourceEntry) && bundleMtime < statSync(sourceEntry).mtimeMs) return true;",
+    "  if (pluginPiEntry && existsSync(pluginPiEntry) && bundleMtime < statSync(pluginPiEntry).mtimeMs) return true;",
+    "  return false;",
+    "}",
+    "",
+    "function rebuildBundle() {",
+    "  // Build to a temp dir and swap, mirroring the install-time build, so a",
+    "  // failed self-heal rebuild never corrupts the working bundle.",
+    '  var tmp = join(here, ".dist-bundle.tmp-" + process.pid + "-" + Date.now());',
+    "  var result = spawnSync(bunForRebuild, [",
+    '    "build",',
+    "    sourceEntry,",
+    '    "--target=bun",',
+    '    "--outdir=" + tmp',
+    "  ], {",
+    "    cwd: here,",
+    '    stdio: "inherit",',
+    "  });",
+    "  if (result.status !== 0 || result.error) {",
+    "    try { rmSync(tmp, { recursive: true, force: true }); } catch (e) {}",
+    "    throw new Error(",
+    '      "Remnic omp extension: bundle is stale or missing and could not be rebuilt. " +',
+    '      "Install bun (https://bun.sh), then run " +',
+    '      "`bun build index.ts --target=bun --outdir=dist-bundle` inside " + here',
+    "    );",
+    "  }",
+    "  var backup = null;",
+    "  try {",
+    "    if (existsSync(bundleDir)) {",
+    '      backup = join(here, ".dist-bundle.bak-" + process.pid + "-" + Date.now());',
+    "      renameSync(bundleDir, backup);",
+    "    }",
+    "    renameSync(tmp, bundleDir);",
+    "    if (backup) { try { rmSync(backup, { recursive: true, force: true }); } catch (e) {} }",
+    "  } catch (err) {",
+    "    try { rmSync(tmp, { recursive: true, force: true }); } catch (e) {}",
+    "    if (backup && existsSync(backup) && !existsSync(bundleDir)) { try { renameSync(backup, bundleDir); } catch (e) {} }",
+    "    throw new Error(",
+    '      "Remnic omp extension: failed to finalize rebuilt bundle - " + (err && err.message ? err.message : err)',
+    "    );",
+    "  }",
+    "}",
+    "",
+    "if (bundleIsStale()) rebuildBundle();",
+    "",
+    "// Cache-bust so a freshly rebuilt bundle is loaded instead of a stale cached copy.",
+    'const bundle = await import(pathToFileURL(bundleEntry).href + "?t=" + Date.now());',
+    "export default bundle.default;",
+    ""
+  ].join("\n");
+}
+function renderOmpPackageJson() {
+  const manifest = {
+    name: "remnic-omp-extension",
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    omp: { extensions: ["./loader.js"] },
+    // Legacy key so older omp builds that only read `pi.extensions` also
+    // resolve loader.js instead of falling through to index.ts.
+    pi: { extensions: ["./loader.js"] },
+    scripts: { postinstall: "node postinstall-bundle.cjs" }
+  };
+  return `${JSON.stringify(manifest, null, 2)}
+`;
+}
+function renderOmpPostinstall(bunBin) {
+  return `// Auto-generated by Remnic's OmpMemoryExtensionPublisher.
+// Re-bundles the omp extension after npm install (e.g. a plugin-pi upgrade)
+// using the bun path resolved at install time, with a PATH fallback. Node-only
+// so it runs under npm's default cmd.exe shell on Windows as well as POSIX bash.
+"use strict";
+var fs = require("node:fs");
+var cp = require("node:child_process");
+var path = require("node:path");
+
+var RESOLVED_BUN = ${JSON.stringify(bunBin)};
+var dir = __dirname;
+var entry = path.join(dir, "index.ts");
+var out = path.join(dir, "dist-bundle");
+
+function pickBun() {
+  var env = process.env.REMNIC_OMP_BUN_BIN;
+  if (env && fs.existsSync(env)) return env;
+  if (RESOLVED_BUN && fs.existsSync(RESOLVED_BUN)) return RESOLVED_BUN;
+  return "bun";
+}
+
+function rebuild() {
+  var bun = pickBun();
+  var tmp = path.join(dir, ".dist-bundle.tmp-" + process.pid + "-" + Date.now());
+  var r = cp.spawnSync(bun, ["build", entry, "--target=bun", "--outdir=" + tmp], { cwd: dir, stdio: "inherit" });
+  if (r.error || r.status !== 0) {
+    try { fs.rmSync(tmp, { recursive: true, force: true }); } catch (e) {}
+    throw new Error("Remnic omp extension: postinstall bun build failed (bun=" + bun + "). Run bun build index.ts --target=bun --outdir=dist-bundle manually inside " + dir);
+  }
+  var backup = null;
+  try {
+    if (fs.existsSync(out)) {
+      backup = path.join(dir, ".dist-bundle.bak-" + process.pid + "-" + Date.now());
+      fs.renameSync(out, backup);
+    }
+    fs.renameSync(tmp, out);
+    if (backup) { try { fs.rmSync(backup, { recursive: true, force: true }); } catch (e) {} }
+  } catch (err) {
+    try { fs.rmSync(tmp, { recursive: true, force: true }); } catch (e) {}
+    if (backup && fs.existsSync(backup) && !fs.existsSync(out)) { try { fs.renameSync(backup, out); } catch (e) {} }
+    throw err;
+  }
+}
+
+try {
+  rebuild();
+} catch (err) {
+  console.error(err && err.message ? err.message : err);
+  process.exit(1);
+}
+`;
+}
+function isExecutableFile(candidate) {
+  try {
+    const stat = fs.statSync(candidate);
+    if (!stat.isFile()) return false;
+    fs.accessSync(candidate, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveBunOnPath() {
+  const pathVar = process.env.PATH ?? process.env.Path ?? process.env.path ?? "";
+  const separator = process.platform === "win32" ? ";" : ":";
+  const candidateNames = process.platform === "win32" ? ["bun.exe", "bun"] : ["bun"];
+  for (const dir of pathVar.split(separator)) {
+    if (!dir) continue;
+    for (const name of candidateNames) {
+      const candidate = path.isAbsolute(dir) ? path.join(dir, name) : path.resolve(dir, name);
+      if (isExecutableFile(candidate)) {
+        return fs.realpathSync(candidate);
+      }
+    }
+  }
+  return null;
+}
+function resolveBunBinary() {
+  const override = process.env.REMNIC_OMP_BUN_BIN;
+  if (override !== void 0) {
+    return fs.existsSync(override) ? override : null;
+  }
+  const pathProbe = spawnSync("bun", ["--version"], { encoding: "utf-8" });
+  if (!pathProbe.error && pathProbe.status === 0) {
+    return resolveBunOnPath() ?? "bun";
+  }
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
+  const candidates = [
+    path.join(home ?? "", ".bun", "bin", "bun"),
+    path.join(home ?? "", ".bun", "bin", "bun.exe"),
+    "/usr/local/bin/bun",
+    "/opt/homebrew/bin/bun"
+  ];
+  for (const candidate of candidates) {
+    if (isExecutableFile(candidate)) return candidate;
+  }
+  return null;
+}
 function atomicWriteFile(filePath, content, mode) {
   rejectSymlinkPath(filePath);
   const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
@@ -300,6 +679,34 @@ function restorePublishSnapshot(extensionRoot, rootExisted, snapshots) {
     removeEmptyDirectory(extensionRoot);
   }
 }
+function snapshotDirs(paths) {
+  return paths.map((dirPath) => {
+    let existed = false;
+    try {
+      const stat = fs.lstatSync(dirPath);
+      if (stat.isSymbolicLink()) {
+        throw new Error(`Extension path must not be a symlink: ${dirPath}`);
+      }
+      existed = stat.isDirectory();
+    } catch (err) {
+      if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+        existed = false;
+      } else {
+        throw err;
+      }
+    }
+    return { path: dirPath, existed };
+  });
+}
+function restoreDirSnapshots(snapshots) {
+  for (const snapshot of snapshots) {
+    if (snapshot.existed) continue;
+    try {
+      fs.rmSync(snapshot.path, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
 function canCleanNewExtensionRoot(extensionRoot) {
   let stat;
   try {
@@ -417,6 +824,9 @@ function restoreTokenEntry(priorEntry, connectorId) {
 export {
   HostMemoryExtensionPublisher,
   OmpMemoryExtensionPublisher,
-  PiMemoryExtensionPublisher
+  PiMemoryExtensionPublisher,
+  resolveBunBinary,
+  resolveBunOnPath,
+  resolveOmpWrapperImportSpecifier
 };
 //# sourceMappingURL=publisher.js.map