create-nodejs-fn 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,1013 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  createNodejsFnPlugin: () => createNodejsFnPlugin
-});
-module.exports = __toCommonJS(index_exports);
-var import_node_fs3 = __toESM(require("fs"));
-var import_node_path8 = __toESM(require("path"));
-var import_glob = require("glob");
-
-// src/build-container-server.ts
-var import_node_fs2 = __toESM(require("fs"));
-var import_node_path2 = __toESM(require("path"));
-var esbuild = __toESM(require("esbuild"));
-var import_ts_morph2 = require("ts-morph");
-
-// src/fs-utils.ts
-var import_node_fs = __toESM(require("fs"));
-var import_node_path = __toESM(require("path"));
-function ensureDir(p) {
-  import_node_fs.default.mkdirSync(p, { recursive: true });
-}
-function writeFileIfChanged(filePath, content) {
-  ensureDir(import_node_path.default.dirname(filePath));
-  const current = import_node_fs.default.existsSync(filePath) ? import_node_fs.default.readFileSync(filePath, "utf8") : null;
-  if (current === content) return;
-  import_node_fs.default.writeFileSync(filePath, content);
-}
-
-// src/project-utils.ts
-var import_ts_morph = require("ts-morph");
-function makeProject() {
-  return new import_ts_morph.Project({
-    useInMemoryFileSystem: false,
-    manipulationSettings: { quoteKind: import_ts_morph.QuoteKind.Double, useTrailingCommas: true },
-    compilerOptions: {
-      target: import_ts_morph.ScriptTarget.ESNext,
-      module: import_ts_morph.ModuleKind.ESNext,
-      allowJs: true
-    }
-  });
-}
-function printSource(sf) {
-  const text = sf.getFullText();
-  return text.endsWith("\n") ? text : `${text}
-`;
-}
-
-// src/build-container-server.ts
-function collectExternalDeps(rootPkgPath, needed) {
-  let pkgJson = { name: "create-nodejs-fn-container", version: "0.0.0" };
-  if (import_node_fs2.default.existsSync(rootPkgPath)) {
-    try {
-      pkgJson = JSON.parse(import_node_fs2.default.readFileSync(rootPkgPath, "utf8"));
-    } catch {
-    }
-  }
-  const depsSources = [
-    pkgJson.dependencies ?? {},
-    pkgJson.optionalDependencies ?? {},
-    pkgJson.devDependencies ?? {},
-    pkgJson.peerDependencies ?? {}
-  ];
-  const out = {};
-  for (const name of needed) {
-    for (const src of depsSources) {
-      if (src[name]) {
-        out[name] = src[name];
-        break;
-      }
-    }
-  }
-  return {
-    name: pkgJson.name ?? "create-nodejs-fn-container",
-    version: pkgJson.version ?? "0.0.0",
-    dependencies: out
-  };
-}
-async function buildContainerServer(opts) {
-  const { mods, outBaseAbs, dockerOpts, containerPort, external, root } = opts;
-  ensureDir(outBaseAbs);
-  const entryTs = import_node_path2.default.join(outBaseAbs, "container.entry.ts");
-  const outServer = import_node_path2.default.join(outBaseAbs, "server.mjs");
-  const dockerfile = import_node_path2.default.join(outBaseAbs, "Dockerfile");
-  const genProject = makeProject();
-  const sf = genProject.createSourceFile(entryTs, "", { overwrite: true });
-  sf.addStatements(["// AUTO-GENERATED. DO NOT EDIT."]);
-  sf.addImportDeclaration({ defaultImport: "http", moduleSpecifier: "node:http" });
-  sf.addImportDeclaration({
-    moduleSpecifier: "capnweb",
-    namedImports: ["RpcTarget", "nodeHttpBatchRpcResponse"]
-  });
-  for (const mod of mods) {
-    const relFromEntry = import_node_path2.default.relative(import_node_path2.default.dirname(entryTs), import_node_path2.default.join(root, mod.fileRelFromRoot)).replace(/\\/g, "/").replace(/\.tsx?$/, "");
-    sf.addImportDeclaration({
-      namespaceImport: `m_${mod.namespace}`,
-      moduleSpecifier: relFromEntry
-    });
-  }
-  sf.addClass({
-    name: "Api",
-    extends: "RpcTarget",
-    methods: mods.flatMap(
-      (mod) => mod.exports.map((ex) => ({
-        name: `${mod.namespace}__${ex.name}`,
-        parameters: [{ name: "args", isRestParameter: true, type: "any[]" }],
-        returnType: "any",
-        statements: `return (m_${mod.namespace} as any)[${JSON.stringify(ex.name)}](...args);`
-      }))
-    )
-  });
-  sf.addVariableStatement({
-    declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
-    declarations: [{ name: "api", initializer: "new Api()" }]
-  });
-  sf.addVariableStatement({
-    declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
-    declarations: [
-      {
-        name: "server",
-        initializer: `
-http.createServer((req, res) => {
-  const u = new URL(req.url ?? "/", "http://localhost");
-
-  if (u.pathname === "/api") {
-    nodeHttpBatchRpcResponse(req, res, api as any);
-    return;
-  }
-
-  if (u.pathname === "/health") {
-    res.statusCode = 200;
-    res.end("ok");
-    return;
-  }
-
-  res.statusCode = 404;
-  res.end("Not found");
-})
-        `.trim()
-      }
-    ]
-  });
-  sf.addStatements(
-    `server.listen(${containerPort}, "0.0.0.0", () => console.log("create-nodejs-fn container listening on ${containerPort}"));`
-  );
-  writeFileIfChanged(entryTs, printSource(sf));
-  const pkgJson = collectExternalDeps(import_node_path2.default.join(root, "package.json"), external);
-  if (pkgJson) {
-    writeFileIfChanged(
-      import_node_path2.default.join(outBaseAbs, "package.json"),
-      `${JSON.stringify(pkgJson, null, 2)}
-`
-    );
-  }
-  const {
-    baseImage = "node:20-slim",
-    systemPackages = [],
-    preInstallCommands = [],
-    postInstallCommands = [],
-    env: dockerEnv = {}
-  } = dockerOpts ?? {};
-  const installLines = "RUN corepack enable && pnpm install --prod --no-frozen-lockfile";
-  const sysDeps = systemPackages.length > 0 ? [
-    "# System packages (from plugin options)",
-    `RUN apt-get update && apt-get install -y --no-install-recommends ${systemPackages.join(" ")} \\`,
-    "    && rm -rf /var/lib/apt/lists/*"
-  ] : [];
-  const preRuns = preInstallCommands.map((cmd) => `RUN ${cmd}`);
-  const postRuns = postInstallCommands.map((cmd) => `RUN ${cmd}`);
-  const envLines = [
-    "ENV NODE_ENV=production",
-    ...Object.entries(dockerEnv).map(([k, v]) => `ENV ${k}=${JSON.stringify(v ?? "")}`)
-  ];
-  writeFileIfChanged(
-    dockerfile,
-    [
-      "# AUTO-GENERATED. DO NOT EDIT.",
-      `FROM ${baseImage}`,
-      "WORKDIR /app",
-      ...sysDeps,
-      ...preRuns,
-      "# Install deps (only externals declared via plugin options)",
-      "COPY package.json ./",
-      installLines,
-      "# Server bundle",
-      "COPY ./server.mjs ./server.mjs",
-      ...envLines,
-      ...postRuns,
-      `EXPOSE ${containerPort}`,
-      `CMD ["node", "./server.mjs"]`,
-      ""
-    ].filter(Boolean).join("\n")
-  );
-  const buildOptions = {
-    entryPoints: [entryTs],
-    outfile: outServer,
-    bundle: true,
-    platform: "node",
-    target: "node20",
-    format: "esm",
-    sourcemap: true,
-    external
-  };
-  await esbuild.build(buildOptions);
-}
-
-// src/constants.ts
-var GENERATED_FILENAMES = {
-  runtime: "create-nodejs-fn.runtime.ts",
-  client: "create-nodejs-fn.ts",
-  durableObject: "create-nodejs-fn.do.ts",
-  context: "create-nodejs-fn.context.ts",
-  stubBatch: "create-nodejs-fn-stub-batch.ts"
-};
-var ARTIFACTS_DIR_NAME = ".create-nodejs-fn";
-
-// src/extractors.ts
-var import_ts_morph3 = require("ts-morph");
-function methodToFunctionExprText(m) {
-  const body = m.getBody();
-  if (!body) return void 0;
-  const asyncPrefix = m.isAsync() ? "async " : "";
-  const params = m.getParameters().map((p) => p.getText()).join(", ");
-  return `${asyncPrefix}(${params}) => ${body.getText()}`;
-}
-function keyExprText(expr) {
-  if (!expr) return void 0;
-  if (import_ts_morph3.Node.isArrowFunction(expr) || import_ts_morph3.Node.isFunctionExpression(expr) || import_ts_morph3.Node.isStringLiteral(expr) || import_ts_morph3.Node.isNoSubstitutionTemplateLiteral(expr)) {
-    return expr.getText();
-  }
-  return void 0;
-}
-function findTopLevelInitializer(sf, name) {
-  for (const vs of sf.getVariableStatements()) {
-    for (const decl of vs.getDeclarations()) {
-      if (decl.getName() !== name) continue;
-      return decl.getInitializer();
-    }
-  }
-  return void 0;
-}
-function extractContainerKeyFromOptions(sf, exportName, optArg) {
-  if (!optArg) return void 0;
-  if (import_ts_morph3.Node.isCallExpression(optArg)) {
-    const callee = optArg.getExpression();
-    const arg0 = optArg.getArguments()[0];
-    if (import_ts_morph3.Node.isIdentifier(callee) && callee.getText() === "containerKey") {
-      return keyExprText(arg0);
-    }
-  }
-  if (import_ts_morph3.Node.isIdentifier(optArg)) {
-    const init = findTopLevelInitializer(sf, optArg.getText());
-    if (init) return extractContainerKeyFromOptions(sf, exportName, init);
-  }
-  if (!import_ts_morph3.Node.isObjectLiteralExpression(optArg)) return void 0;
-  const obj = optArg;
-  const direct = obj.getProperty("containerKey");
-  if (direct) {
-    if (import_ts_morph3.Node.isMethodDeclaration(direct)) return methodToFunctionExprText(direct) ?? void 0;
-    if (import_ts_morph3.Node.isPropertyAssignment(direct)) {
-      const init = direct.getInitializer();
-      if (init && (import_ts_morph3.Node.isArrowFunction(init) || import_ts_morph3.Node.isFunctionExpression(init) || import_ts_morph3.Node.isStringLiteral(init) || import_ts_morph3.Node.isNoSubstitutionTemplateLiteral(init))) {
-        return init.getText();
-      }
-    }
-  }
-  return void 0;
-}
-function extractExports(sf) {
-  const out = [];
-  for (const vs of sf.getVariableStatements()) {
-    if (!vs.isExported()) continue;
-    for (const decl of vs.getDeclarations()) {
-      const init = decl.getInitializer();
-      const name = decl.getName();
-      if (!init || !import_ts_morph3.Node.isCallExpression(init)) continue;
-      const callee = init.getExpression();
-      if (!import_ts_morph3.Node.isIdentifier(callee) || callee.getText() !== "nodejsFn") continue;
-      const args = init.getArguments();
-      const optArg = args[1];
-      const containerKeyExpr = extractContainerKeyFromOptions(sf, decl.getName(), optArg);
-      out.push({ name, containerKeyExpr });
-    }
-  }
-  for (const fn of sf.getFunctions()) {
-    if (!fn.isExported()) continue;
-    const hasTag = fn.getJsDocs().some((d) => d.getTags().some((t) => t.getTagName() === "container"));
-    if (hasTag) {
-      const name = fn.getName();
-      if (name) out.push({ name });
-    }
-  }
-  return out;
-}
-
-// src/generate-proxy-files.ts
-var import_node_path4 = __toESM(require("path"));
-var import_ts_morph4 = require("ts-morph");
-
-// src/path-utils.ts
-var import_node_crypto = __toESM(require("crypto"));
-var import_node_path3 = __toESM(require("path"));
-function hash8(s) {
-  return import_node_crypto.default.createHash("sha1").update(s).digest("hex").slice(0, 8);
-}
-function sanitizeNamespace(relNoExt) {
-  const noSrc = relNoExt.replace(/^src[/\\]/, "");
-  const noSuffix = noSrc.replace(/\.container$/, "");
-  return noSuffix.replace(/[/\\]/g, "_").replace(/[^A-Za-z0-9_]/g, "_");
-}
-function proxyFilePath(gdirAbs, containerAbs) {
-  const pDir = import_node_path3.default.join(gdirAbs, "__proxies__");
-  ensureDir(pDir);
-  const h = hash8(containerAbs);
-  return import_node_path3.default.join(pDir, `p-${h}.ts`);
-}
-
-// src/generate-proxy-files.ts
-function generateProxyFiles(opts) {
-  const { gdirAbs, mods, root, generatedClientFileName, generatedContextFileName } = opts;
-  const genProject = makeProject();
-  for (const mod of mods) {
-    const proxyPath = proxyFilePath(gdirAbs, mod.fileAbs);
-    const sf = genProject.createSourceFile(proxyPath, "", { overwrite: true });
-    sf.addStatements([`// AUTO-GENERATED. DO NOT EDIT.`, `// Proxy for: ${mod.fileRelFromRoot}`]);
-    const relToGen = import_node_path4.default.relative(import_node_path4.default.dirname(proxyPath), gdirAbs).replace(/\\/g, "/");
-    const genBase = relToGen.startsWith(".") ? relToGen : `./${relToGen}`;
-    sf.addImportDeclaration({
-      moduleSpecifier: `${genBase}/${generatedClientFileName.replace(/\.ts$/, "")}`,
-      namedImports: ["containers"]
-    });
-    sf.addImportDeclaration({
-      moduleSpecifier: `${genBase}/${generatedContextFileName.replace(/\.ts$/, "")}`,
-      namedImports: ["__resolveContainerKey"]
-    });
-    sf.addTypeAlias({
-      name: "__Key",
-      type: `string | ((ctx: { args: any[] }) => string | Promise<string>)`
-    });
-    for (const ex of mod.exports) {
-      const importRel = import_node_path4.default.relative(import_node_path4.default.dirname(proxyPath), import_node_path4.default.join(root, mod.fileRelFromRoot)).replace(/\\/g, "/").replace(/\.tsx?$/, "");
-      const tName = `__T_${ex.name}`;
-      sf.addTypeAlias({
-        name: tName,
-        type: `typeof import(${JSON.stringify(importRel)}).${ex.name}`
-      });
-      const keyExpr = ex.containerKeyExpr ?? "undefined";
-      sf.addVariableStatement({
-        declarationKind: import_ts_morph4.VariableDeclarationKind.Const,
-        isExported: true,
-        declarations: [
-          {
-            name: ex.name,
-            type: tName,
-            initializer: `
-((...args: any[]) => {
-  const ctx = { args };
-  const localKey = (${keyExpr}) as __Key | undefined;
-  const keyP = __resolveContainerKey(${JSON.stringify(mod.namespace)}, ${JSON.stringify(
-              ex.name
-            )}, ctx, localKey ?? "default");
-
-  return Promise.resolve(keyP).then((key) =>
-    (containers({ containerKey: key }) as any).${mod.namespace}.${ex.name}(...args),
-  );
-}) as any
-            `.trim()
-          }
-        ]
-      });
-    }
-    writeFileIfChanged(proxyPath, printSource(sf));
-  }
-}
-
-// src/generate-runtime.ts
-var import_node_path5 = __toESM(require("path"));
-function generateRuntime(gdirAbs, runtimeFileName) {
-  const genProject = makeProject();
-  const filePath = import_node_path5.default.join(gdirAbs, runtimeFileName);
-  const sf = genProject.createSourceFile(filePath, "", { overwrite: true });
-  sf.addStatements([
-    "// AUTO-GENERATED (runtime marker)",
-    "// Intentionally tiny. Used only as a marker in *.container.ts"
-  ]);
-  sf.addTypeAlias({
-    isExported: true,
-    name: "ContainerKey",
-    type: `string | ((ctx: { args: any[] }) => string | Promise<string>)`
-  });
-  sf.addTypeAlias({
-    isExported: true,
-    name: "ContainerKeyToken",
-    type: `{ readonly __containerKeyBrand: true; containerKey: ContainerKey }`
-  });
-  sf.addFunction({
-    isExported: true,
-    name: "nodejsFn",
-    typeParameters: [{ name: "T", constraint: "(...args: any[]) => any" }],
-    parameters: [
-      { name: "fn", type: "T" },
-      { name: "_opts?", type: "ContainerKeyToken" }
-    ],
-    returnType: "T",
-    statements: "return fn;"
-  });
-  sf.addFunction({
-    isExported: true,
-    name: "containerKey",
-    parameters: [{ name: "value", type: "ContainerKey" }],
-    returnType: "ContainerKeyToken",
-    statements: `return { __containerKeyBrand: true, containerKey: value } as const;`
-  });
-  writeFileIfChanged(filePath, printSource(sf));
-}
-
-// src/generate-stub-batch.ts
-var import_node_path6 = __toESM(require("path"));
-function generateStubBatch(gdirAbs, generatedStubBatchFileName) {
-  const filePath = import_node_path6.default.join(gdirAbs, generatedStubBatchFileName);
-  const content = `// Derived from Cloudflare's create-nodejs-fn helper implementation.
-// Modifications: Use Durable Object stub.fetch() instead of global fetch().
-//
-// Copyright (c) 2025 Cloudflare, Inc.
-// Licensed under the MIT license found in the LICENSE.txt file or at:
-//     https://opensource.org/license/mit
-
-import { RpcSession, type RpcSessionOptions, type RpcTransport } from "capnweb";
-import type { RpcStub } from "cloudflare:workers";
-
-type SendBatchFunc = (batch: string[]) => Promise<string[]>;
-
-class BatchClientTransport implements RpcTransport {
-  constructor(sendBatch: SendBatchFunc) {
-    this.#promise = this.#scheduleBatch(sendBatch);
-  }
-
-  #promise: Promise<void>;
-  #aborted: any;
-
-  #batchToSend: string[] | null = [];
-  #batchToReceive: string[] | null = null;
-
-  async send(message: string): Promise<void> {
-    if (this.#batchToSend !== null) {
-      this.#batchToSend.push(message);
-    }
-  }
-
-  async receive(): Promise<string> {
-    if (!this.#batchToReceive) {
-      await this.#promise;
-    }
-
-    const msg = this.#batchToReceive!.shift();
-    if (msg !== undefined) return msg;
-
-    throw new Error("Batch RPC request ended.");
-  }
-
-  abort?(reason: any): void {
-    this.#aborted = reason;
-  }
-
-  async #scheduleBatch(sendBatch: SendBatchFunc) {
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    if (this.#aborted !== undefined) {
-      throw this.#aborted;
-    }
-
-    const batch = this.#batchToSend!;
-    this.#batchToSend = null;
-    this.#batchToReceive = await sendBatch(batch);
-  }
-}
-
-export function newHttpBatchRpcSession<T extends Rpc.Stubable>(
-  stub: { fetch(request: Request): Promise<Response> },
-  options?: RpcSessionOptions,
-  path: string = "/api",
-): RpcStub<T> {
-  const sendBatch: SendBatchFunc = async (batch: string[]) => {
-    const req = new Request(\`http://create-nodejs-fn\${path}\`, {
-      method: "POST",
-      body: batch.join("\\n"),
-      headers: { "content-type": "text/plain; charset=utf-8" },
-    });
-
-    const response = await stub.fetch(req);
-
-    if (!response.ok) {
-      response.body?.cancel();
-      throw new Error(\`RPC request failed: \${response.status} \${response.statusText}\`);
-    }
-
-    const body = await response.text();
-    return body === "" ? [] : body.split("\\n");
-  };
-
-  const transport = new BatchClientTransport(sendBatch);
-  const rpc = new RpcSession(transport, undefined, options);
-  return rpc.getRemoteMain() as unknown as RpcStub<T>;
-}
-
-/*
-MIT License
-
-Copyright (c) 2025 Cloudflare, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-`;
-  writeFileIfChanged(filePath, content.endsWith("\n") ? content : `${content}
-`);
-}
-
-// src/generate-worker-files.ts
-var import_node_path7 = __toESM(require("path"));
-var import_ts_morph5 = require("ts-morph");
-function generateWorkerFiles(opts) {
-  const {
-    gdirAbs,
-    mods,
-    root,
-    binding,
-    className,
-    containerPort,
-    workerEnvVars,
-    clientFileName,
-    doFileName,
-    contextFileName,
-    stubBatchFileName
-  } = opts;
-  const genProject = makeProject();
-  const clientPath = import_node_path7.default.join(gdirAbs, clientFileName);
-  const doPath = import_node_path7.default.join(gdirAbs, doFileName);
-  const ctxPath = import_node_path7.default.join(gdirAbs, contextFileName);
-  {
-    const sf = genProject.createSourceFile(clientPath, "", { overwrite: true });
-    sf.addStatements([
-      "// AUTO-GENERATED. DO NOT EDIT.",
-      "// Generated by vite-plugin-create-nodejs-fn."
-    ]);
-    sf.addImportDeclaration({
-      moduleSpecifier: `./${stubBatchFileName.replace(/\.ts$/, "")}`,
-      namedImports: ["newHttpBatchRpcSession"]
-    });
-    sf.addImportDeclaration({
-      moduleSpecifier: "cloudflare:workers",
-      namedImports: ["env"]
-    });
-    sf.addVariableStatement({
-      declarationKind: import_ts_morph5.VariableDeclarationKind.Const,
-      isExported: true,
-      declarations: [{ name: "BINDING_NAME", initializer: JSON.stringify(binding) }]
-    });
-    for (const mod of mods) {
-      const importRel = import_node_path7.default.relative(import_node_path7.default.dirname(clientPath), import_node_path7.default.join(root, mod.fileRelFromRoot)).replace(/\\/g, "/").replace(/\.tsx?$/, "");
-      for (const ex of mod.exports) {
-        const alias = `__T_${mod.namespace}_${ex.name}`;
-        sf.addTypeAlias({
-          name: alias,
-          type: `typeof import(${JSON.stringify(importRel)}).${ex.name}`
-        });
-      }
-      sf.addInterface({
-        isExported: true,
-        name: `__NS_${mod.namespace}`,
-        methods: mod.exports.map((ex) => {
-          const alias = `__T_${mod.namespace}_${ex.name}`;
-          return {
-            name: ex.name,
-            parameters: [{ name: "args", isRestParameter: true, type: `Parameters<${alias}>` }],
-            returnType: `ReturnType<${alias}>`
-          };
-        })
-      });
-    }
-    sf.addInterface({
-      isExported: true,
-      name: "FlatApi",
-      extends: ["Rpc.RpcTargetBranded "],
-      methods: mods.flatMap(
-        (mod) => mod.exports.map((ex) => {
-          const alias = `__T_${mod.namespace}_${ex.name}`;
-          return {
-            name: `${mod.namespace}__${ex.name}`,
-            parameters: [{ name: "args", isRestParameter: true, type: `Parameters<${alias}>` }],
-            returnType: `ReturnType<${alias}>`
-          };
-        })
-      )
-    });
-    sf.addInterface({
-      isExported: true,
-      name: "Containers",
-      properties: mods.map((m) => ({ name: m.namespace, type: `__NS_${m.namespace}` }))
-    });
-    sf.addFunction({
-      isExported: true,
-      name: "rawClient",
-      parameters: [{ name: "ctx", type: `{ containerKey?: string }` }],
-      statements: `
-const ns = env?.[BINDING_NAME];
-if (!ns?.getByName) throw new Error(\`Container binding missing: \${BINDING_NAME}\`);
-const stub = ns.getByName(ctx.containerKey ?? "default");
-return newHttpBatchRpcSession<FlatApi>(stub);
-      `
-    });
-    const objLines = [];
-    for (const mod of mods) {
-      const lines = mod.exports.map(
-        (ex) => `${ex.name}: (...args: any[]) => (rpc as any)[${JSON.stringify(
-          `${mod.namespace}__${ex.name}`
-        )}](...args),`
-      );
-      objLines.push(`${mod.namespace}: { ${lines.join(" ")} },`);
-    }
-    sf.addFunction({
-      isExported: true,
-      name: "containers",
-      parameters: [{ name: "ctx", type: `{ containerKey?: string }` }],
-      returnType: "Containers",
-      statements: `
-const rpc = rawClient(ctx);
-return { ${objLines.join(" ")} } as any;
-      `
-    });
-    writeFileIfChanged(clientPath, printSource(sf));
-  }
-  {
-    const sf = genProject.createSourceFile(doPath, "", { overwrite: true });
-    sf.addStatements(["// AUTO-GENERATED. DO NOT EDIT."]);
-    sf.addImportDeclaration({
-      moduleSpecifier: "@cloudflare/containers",
-      namedImports: ["Container"]
-    });
-    const envVarEntries = Array.isArray(workerEnvVars) ? workerEnvVars.map((n) => [n, n]) : Object.entries(workerEnvVars);
-    if (envVarEntries.length > 0) {
-      sf.addImportDeclaration({ moduleSpecifier: "cloudflare:workers", namedImports: ["env"] });
-    }
-    const envVarInitializer = envVarEntries.length === 0 ? void 0 : `{
-${envVarEntries.map(([key, src]) => `  ${JSON.stringify(key)}: env[${JSON.stringify(src)}],`).join("\n")}
-}`;
-    sf.addClass({
-      isExported: true,
-      name: className,
-      extends: "Container",
-      properties: [
-        { name: "defaultPort", initializer: String(containerPort) },
-        { name: "sleepAfter", initializer: JSON.stringify("10s") },
-        ...envVarInitializer ? [{ name: "envVars", initializer: envVarInitializer }] : []
-      ]
-    });
-    writeFileIfChanged(doPath, printSource(sf));
-  }
-  {
-    const sf = genProject.createSourceFile(ctxPath, "", { overwrite: true });
-    sf.addStatements(["// AUTO-GENERATED. DO NOT EDIT."]);
-    sf.addTypeAlias({
-      name: "ContainerKey",
-      type: `string | ((ctx: { args: any[] }) => string | Promise<string>)`
-    });
-    sf.addVariableStatement({
-      declarationKind: import_ts_morph5.VariableDeclarationKind.Const,
-      declarations: [{ name: "registry", initializer: "new Map<string, ContainerKey>()" }]
-    });
-    sf.addFunction({
-      isExported: true,
-      name: "setContainerKey",
-      parameters: [
-        { name: "namespace", type: "string" },
-        { name: "exportName", type: "string" },
-        { name: "key", type: "ContainerKey" }
-      ],
-      statements: `registry.set(\`\${namespace}::\${exportName}\`, key);`
-    });
-    sf.addFunction({
-      isExported: true,
-      name: "setNamespaceContainerKey",
-      parameters: [
-        { name: "namespace", type: "string" },
-        { name: "key", type: "ContainerKey" }
-      ],
-      statements: `registry.set(\`\${namespace}::*\`, key);`
-    });
-    sf.addFunction({
-      isExported: true,
-      name: "__resolveContainerKey",
-      parameters: [
-        { name: "namespace", type: "string" },
-        { name: "exportName", type: "string" },
-        { name: "ctx", type: `{ args: any[] }` },
-        { name: "fallback?", type: "ContainerKey" }
-      ],
-      returnType: "string | Promise<string>",
-      statements: `
-const direct = registry.get(\`\${namespace}::\${exportName}\`);
-const ns = registry.get(\`\${namespace}::*\`);
-const candidate = direct ?? ns ?? fallback;
-if (typeof candidate === "function") return candidate(ctx);
-if (typeof candidate === "string") return candidate;
-return "default";
-      `
-    });
-    writeFileIfChanged(ctxPath, printSource(sf));
-  }
-}
-
-// src/index.ts
-function createNodejsFnPlugin(opts = {}) {
-  const files = opts.files ?? ["src/**/*.container.ts"];
-  const generatedDir = opts.generatedDir ?? "src/__generated__";
-  const binding = opts.binding ?? "NODEJS_FN";
-  const className = opts.className ?? "NodejsFnContainer";
-  const containerPort = opts.containerPort ?? 8080;
-  const external = opts.external ?? [];
-  const docker = opts.docker ?? {};
-  const workerEnvVars = opts.workerEnvVars ?? [];
-  const autoRebuildContainers = opts.autoRebuildContainers ?? true;
-  const rebuildDebounceMs = opts.rebuildDebounceMs ?? 600;
-  let root = process.cwd();
-  let outDir = "dist";
-  let config = null;
-  let devServer = null;
-  let restartTimer = null;
-  let restartingDevServer = false;
-  let serveDebounceTimer = null;
-  const pendingChanged = /* @__PURE__ */ new Set();
-  const pendingRemoved = /* @__PURE__ */ new Set();
-  let pendingForce = false;
-  let pendingReason = null;
-  const project = makeProject();
-  const moduleCache = /* @__PURE__ */ new Map();
-  const containerFiles = /* @__PURE__ */ new Set();
-  let regenQueue = Promise.resolve();
-  let generatedOnce = false;
-  function discoverFileList() {
-    const patterns = files;
-    const absFiles = patterns.flatMap((p) => (0, import_glob.globSync)(p, { cwd: root, absolute: true }));
-    absFiles.forEach((f) => {
-      containerFiles.add(import_node_path8.default.normalize(f));
-    });
-    return absFiles;
-  }
-  function loadSourceFile(fileAbs) {
-    const existing = project.getSourceFile(fileAbs);
-    if (existing) {
-      existing.refreshFromFileSystemSync();
-      return existing;
-    }
-    if (import_node_fs3.default.existsSync(fileAbs)) {
-      return project.addSourceFileAtPath(fileAbs);
-    }
-    return void 0;
-  }
-  function refreshModules(changed, removed) {
-    let dirty = false;
-    if (removed?.length) {
-      for (const abs of removed) {
-        moduleCache.delete(import_node_path8.default.normalize(abs));
-        const sf = project.getSourceFile(abs);
-        if (sf) project.removeSourceFile(sf);
-        containerFiles.delete(import_node_path8.default.normalize(abs));
-        dirty = true;
-      }
-    }
-    const targets = changed?.length ? changed : Array.from(containerFiles);
-    for (const absRaw of targets) {
-      const abs = import_node_path8.default.normalize(absRaw);
-      if (!import_node_fs3.default.existsSync(abs)) continue;
-      const sf = loadSourceFile(abs);
-      if (!sf) continue;
-      const exportsWithKeys = extractExports(sf);
-      const rel = import_node_path8.default.relative(root, abs).replace(/\\/g, "/");
-      const relNoExt = rel.replace(/\.[^.]+$/, "");
-      if (exportsWithKeys.length === 0) {
-        dirty = dirty || moduleCache.delete(abs);
-        continue;
-      }
-      const mod = {
-        fileAbs: abs,
-        fileRelFromRoot: rel,
-        namespace: sanitizeNamespace(relNoExt),
-        exports: exportsWithKeys
-      };
-      const prev = moduleCache.get(abs);
-      const changedJson = JSON.stringify(prev) !== JSON.stringify(mod);
-      if (changedJson || !prev) {
-        moduleCache.set(abs, mod);
-        dirty = true;
-      }
-    }
-    return dirty;
-  }
-  async function regenerate(kind, delta) {
-    if (!generatedOnce) {
-      discoverFileList();
-    }
-    const dirty = refreshModules(delta?.changed, delta?.removed) || delta?.force || !generatedOnce;
-    const mods = Array.from(moduleCache.values()).sort(
-      (a, b) => a.namespace.localeCompare(b.namespace)
-    );
-    if (!dirty && generatedOnce) {
-      return;
-    }
-    const gdirAbs = import_node_path8.default.join(root, generatedDir);
-    ensureDir(gdirAbs);
-    generateRuntime(gdirAbs, GENERATED_FILENAMES.runtime);
-    generateStubBatch(gdirAbs, GENERATED_FILENAMES.stubBatch);
-    generateWorkerFiles({
-      gdirAbs,
-      mods,
-      root,
-      binding,
-      className,
-      containerPort,
-      workerEnvVars,
-      clientFileName: GENERATED_FILENAMES.client,
-      doFileName: GENERATED_FILENAMES.durableObject,
-      contextFileName: GENERATED_FILENAMES.context,
-      stubBatchFileName: GENERATED_FILENAMES.stubBatch
-    });
-    generateProxyFiles({
-      gdirAbs,
-      mods,
-      root,
-      generatedContextFileName: GENERATED_FILENAMES.context,
-      generatedClientFileName: GENERATED_FILENAMES.client
-    });
-    await buildContainerServer({
-      mods,
-      outBaseAbs: import_node_path8.default.join(root, ARTIFACTS_DIR_NAME),
-      dockerOpts: docker,
-      containerPort,
-      external,
-      root
-    });
-    if (kind === "build") {
-      const distAbs = import_node_path8.default.join(root, outDir);
-      await buildContainerServer({
-        mods,
-        outBaseAbs: import_node_path8.default.join(distAbs, ARTIFACTS_DIR_NAME),
-        dockerOpts: docker,
-        containerPort,
-        external,
-        root
-      });
-    }
-    generatedOnce = true;
-  }
-  function enqueueRegeneration(kind, delta) {
-    regenQueue = regenQueue.then(() => regenerate(kind, delta)).catch((err) => {
-      console.error("[create-nodejs-fn] regeneration failed", err);
-    });
-    return regenQueue;
-  }
-  function scheduleContainerRebuild(reason) {
-    if (!autoRebuildContainers) return;
-    if (config?.command !== "serve") return;
-    if (!devServer) return;
-    if (restartingDevServer) return;
-    const serverForRestart = devServer;
-    if (restartTimer) clearTimeout(restartTimer);
-    restartTimer = setTimeout(() => {
-      restartTimer = null;
-      regenQueue.then(async () => {
-        if (restartingDevServer) return;
-        restartingDevServer = true;
-        try {
-          serverForRestart?.config.logger?.info?.(
-            `[create-nodejs-fn] Restarting Vite dev server to rebuild containers (${reason})`
-          );
-          await serverForRestart?.restart();
-        } catch (err) {
-          console.error(
-            "[create-nodejs-fn] failed to restart dev server for container rebuild",
-            err
-          );
-        } finally {
-          restartingDevServer = false;
-        }
-      }).catch((err) => {
-        console.error("[create-nodejs-fn] regeneration failed before restart", err);
-      });
-    }, rebuildDebounceMs);
-  }
-  function scheduleServeRegeneration(reason, delta) {
-    delta.changed?.map((p) => pendingChanged.add(import_node_path8.default.normalize(p)));
-    delta.removed?.map((p) => pendingRemoved.add(import_node_path8.default.normalize(p)));
-    if (delta.force) pendingForce = true;
-    pendingReason = reason;
-    if (serveDebounceTimer) clearTimeout(serveDebounceTimer);
-    serveDebounceTimer = setTimeout(() => {
-      serveDebounceTimer = null;
-      const changed = pendingChanged.size ? Array.from(pendingChanged) : void 0;
-      const removed = pendingRemoved.size ? Array.from(pendingRemoved) : void 0;
-      const force = pendingForce;
-      pendingChanged.clear();
-      pendingRemoved.clear();
-      pendingForce = false;
-      enqueueRegeneration("serve", { changed, removed, force });
-      const reasonText = pendingReason ?? "changes";
-      pendingReason = null;
-      scheduleContainerRebuild(reasonText);
-    }, rebuildDebounceMs);
-  }
-  return {
-    name: "vite-plugin-create-nodejs-fn",
-    enforce: "pre",
-    config(userConfig) {
-      if (!external.length) return;
-      const cur = userConfig.optimizeDeps?.exclude ?? [];
-      const merged = Array.from(/* @__PURE__ */ new Set([...cur, ...external]));
-      return { optimizeDeps: { exclude: merged } };
-    },
-    configResolved(c) {
-      config = c;
-      root = c.root;
-      outDir = c.build.outDir || "dist";
-    },
-    async buildStart() {
-      await enqueueRegeneration("serve");
-    },
-    async closeBundle() {
-      await enqueueRegeneration("build");
-    },
-    async resolveId(id, importer, options) {
-      const r = await this.resolve(id, importer, {
-        ...options,
-        skipSelf: true
-      });
-      const resolved = r?.id?.split("?")[0];
-      if (!resolved || !resolved.endsWith(".container.ts")) return null;
-      const gdirAbs = import_node_path8.default.join(root, generatedDir);
-      const proxyPath = proxyFilePath(gdirAbs, resolved);
-      if (!import_node_fs3.default.existsSync(proxyPath)) {
-        await enqueueRegeneration(config?.command === "build" ? "build" : "serve", {
-          changed: [resolved],
-          force: true
-        });
-      }
-      return proxyPath;
-    },
-    configureServer(server) {
-      devServer = server;
-      const patterns = files.map((g) => import_node_path8.default.join(root, g));
-      server.watcher.add(patterns);
-      const onAddOrChange = (p) => {
-        if (!p.endsWith(".container.ts")) return;
-        containerFiles.add(import_node_path8.default.normalize(p));
-        scheduleServeRegeneration(`changed ${import_node_path8.default.relative(root, p)}`, { changed: [p] });
-      };
-      const onUnlink = (p) => {
-        if (!p.endsWith(".container.ts")) return;
-        scheduleServeRegeneration(`removed ${import_node_path8.default.relative(root, p)}`, { removed: [p] });
-      };
-      server.watcher.on("add", onAddOrChange);
-      server.watcher.on("change", onAddOrChange);
-      server.watcher.on("unlink", onUnlink);
-    }
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createNodejsFnPlugin
-});