rwsdk 0.1.16 → 0.1.17-test.20250715200658

package/dist/runtime/render/renderToString.js

@@ -0,0 +1,26 @@
+import { renderToStream } from "./renderToStream";
+export const renderToString = async (element, options) => {
+    const stream = await new Promise((resolve, reject) => renderToStream(element, {
+        ...options,
+        onError: reject,
+    })
+        .then(resolve)
+        .catch(reject));
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let result = "";
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            result += decoder.decode(value, { stream: true });
+        }
+        // Flush any remaining bytes
+        result += decoder.decode();
+        return result;
+    }
+    finally {
+        reader.releaseLock();
+    }
+};

package/dist/runtime/render/transformRscToHtmlStream.d.ts

@@ -0,0 +1,8 @@
+import { DocumentProps } from "../lib/router";
+import { RequestInfo } from "../requestInfo/types";
+export declare const transformRscToHtmlStream: ({ stream, Document, requestInfo, onError, }: {
+    stream: ReadableStream;
+    Document: React.FC<DocumentProps>;
+    requestInfo: RequestInfo;
+    onError: (error: unknown) => void;
+}) => Promise<import("react-dom/server.js").ReactDOMServerReadableStream>;

package/dist/runtime/render/transformRscToHtmlStream.js

@@ -0,0 +1,19 @@
+import { createModuleMap } from "./createModuleMap.js";
+import ReactServerDom from "react-server-dom-webpack/client.edge";
+import { renderRscThenableToHtmlStream } from "rwsdk/__ssr_bridge";
+const { createFromReadableStream } = ReactServerDom;
+export const transformRscToHtmlStream = ({ stream, Document, requestInfo, onError, }) => {
+    const thenable = createFromReadableStream(stream, {
+        serverConsumerManifest: {
+            moduleMap: createModuleMap(),
+            moduleLoading: null,
+        },
+    });
+    return renderRscThenableToHtmlStream({
+        thenable,
+        Document,
+        requestInfo,
+        shouldSSR: requestInfo.rw.ssr,
+        onError,
+    });
+};

package/dist/runtime/requestInfo/types.d.ts

@@ -0,0 +1,11 @@
+import { RwContext } from "../lib/router";
+export interface DefaultAppContext {
+}
+export interface RequestInfo<Params = any, AppContext = DefaultAppContext> {
+    request: Request;
+    params: Params;
+    ctx: AppContext;
+    headers: Headers;
+    rw: RwContext;
+    cf: ExecutionContext;
+}

package/dist/runtime/requestInfo/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/requestInfo/worker.d.ts

@@ -0,0 +1,5 @@
+import { RequestInfo, DefaultAppContext } from "./types";
+export declare const requestInfo: RequestInfo<DefaultAppContext>;
+export declare function getRequestInfo(): RequestInfo;
+export declare function runWithRequestInfo<Result>(context: Record<string, any>, fn: () => Result): Result;
+export declare function runWithRequestInfoOverrides<Result>(overrides: Record<string, any>, fn: () => Result): Result;

package/dist/runtime/requestInfo/worker.js

@@ -0,0 +1,33 @@
+import { AsyncLocalStorage } from "async_hooks";
+const requestInfoStore = new AsyncLocalStorage();
+const requestInfoBase = {};
+const REQUEST_INFO_KEYS = ["request", "params", "ctx", "headers", "rw", "cf"];
+REQUEST_INFO_KEYS.forEach((key) => {
+    Object.defineProperty(requestInfoBase, key, {
+        enumerable: true,
+        configurable: false,
+        get: function () {
+            const store = requestInfoStore.getStore();
+            return store ? store[key] : undefined;
+        },
+    });
+});
+export const requestInfo = Object.freeze(requestInfoBase);
+export function getRequestInfo() {
+    const store = requestInfoStore.getStore();
+    if (!store) {
+        throw new Error("Request context not found");
+    }
+    return store;
+}
+export function runWithRequestInfo(context, fn) {
+    return requestInfoStore.run(context, fn);
+}
+export function runWithRequestInfoOverrides(overrides, fn) {
+    const requestInfo = requestInfoStore.getStore();
+    const newRequestInfo = {
+        ...requestInfo,
+        ...overrides,
+    };
+    return requestInfoStore.run(newRequestInfo, fn);
+}

package/dist/runtime/script.d.ts

@@ -0,0 +1,5 @@
+export declare const defineScript: (fn: ({ env }: {
+    env: Env;
+}) => Promise<unknown>) => {
+    fetch(request: Request, env: Env): Promise<Response>;
+};

package/dist/runtime/script.js

@@ -0,0 +1,8 @@
+export const defineScript = (fn) => {
+    return {
+        async fetch(request, env) {
+            await fn({ env });
+            return new Response("Done!");
+        },
+    };
+};

package/dist/runtime/ssrBridge.d.ts

@@ -0,0 +1,2 @@
+export { renderRscThenableToHtmlStream } from "./render/renderRscThenableToHtmlStream";
+export { ssrLoadModule, ssrGetModuleExport, ssrWebpackRequire, } from "./imports/ssr";

package/dist/runtime/ssrBridge.js

@@ -0,0 +1,11 @@
+// context(justinvdm, 28 May 2025): This is the "bridge" between the RSC side
+// and the SSR side, both run inside the same runtime environment. We have this
+// separation so that they can each be processed with their own respective
+// import conditions and bundling logic
+//
+// **NOTE:** Any time we need to import from SSR side in RSC side, we need to
+// import it through this bridge module, using the bare import path
+// `rwsdk/__ssr_bridge`. We have bundler logic (ssrBridgePlugin) that looks out
+// for imports to it.
+export { renderRscThenableToHtmlStream } from "./render/renderRscThenableToHtmlStream";
+export { ssrLoadModule, ssrGetModuleExport, ssrWebpackRequire, } from "./imports/ssr";

package/dist/runtime/worker.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import { RequestInfo, DefaultAppContext } from "./requestInfo/types";
+import { Route } from "./lib/router";
+declare global {
+    type Env = {
+        ASSETS: Fetcher;
+        DB: D1Database;
+    };
+}
+export declare const defineApp: <T extends RequestInfo = RequestInfo<any, DefaultAppContext>>(routes: Route<T>[]) => {
+    fetch: (request: Request, env: Env, cf: ExecutionContext) => Promise<Response>;
+};
+export declare const SmokeTestWrapper: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const DefaultDocument: React.FC<{
+    children: React.ReactNode;
+}>;

package/dist/runtime/worker.js

@@ -0,0 +1,173 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { transformRscToHtmlStream } from "./render/transformRscToHtmlStream";
+import { renderToRscStream } from "./render/renderToRscStream";
+import { rscActionHandler } from "./register/worker";
+import { injectRSCPayload } from "rsc-html-stream/server";
+import { ErrorResponse } from "./error";
+import { getRequestInfo, runWithRequestInfo, runWithRequestInfoOverrides, } from "./requestInfo/worker";
+import { defineRoutes } from "./lib/router";
+import { generateNonce } from "./lib/utils";
+import { IS_DEV } from "./constants";
+import { ssrWebpackRequire } from "./imports/worker";
+export const defineApp = (routes) => {
+    return {
+        fetch: async (request, env, cf) => {
+            globalThis.__webpack_require__ = ssrWebpackRequire;
+            const router = defineRoutes(routes);
+            // context(justinvdm, 5 Feb 2025): Serve assets requests using the assets service binding
+            // todo(justinvdm, 5 Feb 2025): Find a way to avoid this so asset requests are served directly
+            // rather than first needing to go through the worker
+            if (request.url.includes("/assets/")) {
+                const url = new URL(request.url);
+                url.pathname = url.pathname.slice("/assets/".length);
+                return env.ASSETS.fetch(new Request(url.toString(), request));
+            }
+            else if (IS_DEV && request.url.includes("/__vite_preamble__")) {
+                return new Response('import RefreshRuntime from "/@react-refresh"; RefreshRuntime.injectIntoGlobalHook(window); window.$RefreshReg$ = () => {}; window.$RefreshSig$ = () => (type) => type; window.__vite_plugin_react_preamble_installed__ = true;', {
+                    headers: {
+                        "content-type": "text/javascript",
+                    },
+                });
+            }
+            try {
+                const url = new URL(request.url);
+                const isRSCRequest = url.searchParams.has("__rsc") ||
+                    request.headers.get("accept")?.includes("text/x-component");
+                const isSmokeTest = url.searchParams.has("__smoke_test");
+                const userHeaders = new Headers();
+                const rw = {
+                    Document: DefaultDocument,
+                    nonce: generateNonce(),
+                    rscPayload: true,
+                    ssr: true,
+                    databases: new Map(),
+                };
+                const outerRequestInfo = {
+                    request,
+                    headers: userHeaders,
+                    cf,
+                    params: {},
+                    ctx: {},
+                    rw,
+                };
+                const createPageElement = (requestInfo, Page) => {
+                    let pageElement;
+                    if (isClientReference(Page)) {
+                        const { ctx, params } = requestInfo; // context(justinvdm, 25 Feb 2025): If the page is a client reference, we need to avoid passing
+                        // down props the client shouldn't get (e.g. env). For safety, we pick the allowed props explicitly.
+                        pageElement = _jsx(Page, { ctx: ctx, params: params });
+                    }
+                    else {
+                        // context(justinvdm, 24 Apr 2025): We need to wrap the page in a component that throws the response to bubble it up and break out of react rendering context
+                        // This way, we're able to return a response from the page component while still staying within react rendering context
+                        const PageWrapper = async () => {
+                            const result = await Page(requestInfo);
+                            if (result instanceof Response) {
+                                throw result;
+                            }
+                            return result;
+                        };
+                        pageElement = _jsx(PageWrapper, {});
+                    }
+                    if (isSmokeTest) {
+                        pageElement = _jsx(SmokeTestWrapper, { children: pageElement });
+                    }
+                    return pageElement;
+                };
+                const renderPage = async (requestInfo, Page, onError) => {
+                    if (isClientReference(requestInfo.rw.Document)) {
+                        if (IS_DEV) {
+                            console.error("Document cannot be a client component");
+                        }
+                        return new Response(null, {
+                            status: 500,
+                        });
+                    }
+                    let actionResult = undefined;
+                    const isRSCActionHandler = url.searchParams.has("__rsc_action_id");
+                    if (isRSCActionHandler) {
+                        actionResult = await rscActionHandler(request);
+                    }
+                    const pageElement = createPageElement(requestInfo, Page);
+                    const { rscPayload: shouldInjectRSCPayload } = rw;
+                    let rscPayloadStream = renderToRscStream({
+                        node: pageElement,
+                        actionResult: actionResult instanceof Response ? null : actionResult,
+                        onError,
+                    });
+                    if (isRSCRequest) {
+                        return new Response(rscPayloadStream, {
+                            headers: {
+                                "content-type": "text/x-component; charset=utf-8",
+                            },
+                        });
+                    }
+                    let injectRSCPayloadStream;
+                    if (shouldInjectRSCPayload) {
+                        const [rscPayloadStream1, rscPayloadStream2] = rscPayloadStream.tee();
+                        rscPayloadStream = rscPayloadStream1;
+                        injectRSCPayloadStream = injectRSCPayload(rscPayloadStream2, {
+                            nonce: rw.nonce,
+                        });
+                    }
+                    let html = await transformRscToHtmlStream({
+                        stream: rscPayloadStream,
+                        Document: rw.Document,
+                        requestInfo: requestInfo,
+                        onError,
+                    });
+                    if (injectRSCPayloadStream) {
+                        html = html.pipeThrough(injectRSCPayloadStream);
+                    }
+                    return new Response(html, {
+                        headers: {
+                            "content-type": "text/html; charset=utf-8",
+                        },
+                    });
+                };
+                const response = await runWithRequestInfo(outerRequestInfo, async () => new Promise(async (resolve, reject) => {
+                    try {
+                        resolve(await router.handle({
+                            request,
+                            renderPage,
+                            getRequestInfo: getRequestInfo,
+                            runWithRequestInfoOverrides,
+                            onError: reject,
+                        }));
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                }));
+                // context(justinvdm, 18 Mar 2025): In some cases, such as a .fetch() call to a durable object instance, or Response.redirect(),
+                // we need to return a mutable response object.
+                const mutableResponse = new Response(response.body, response);
+                for (const [key, value] of userHeaders.entries()) {
+                    if (!response.headers.has(key)) {
+                        mutableResponse.headers.set(key, value);
+                    }
+                }
+                return mutableResponse;
+            }
+            catch (e) {
+                if (e instanceof ErrorResponse) {
+                    return new Response(e.message, { status: e.code });
+                }
+                if (e instanceof Response) {
+                    return e;
+                }
+                console.error("Unhandled error", e);
+                throw e;
+            }
+        },
+    };
+};
+export const SmokeTestWrapper = async ({ children }) => {
+    const smokeTestInfo = await Object.values(await import.meta.glob("/src/app/components/__SmokeTest.tsx"))[0]();
+    const SmokeTestInfo = smokeTestInfo.SmokeTestInfo;
+    return (_jsxs(_Fragment, { children: [_jsx(SmokeTestInfo, {}), children] }));
+};
+export const DefaultDocument = ({ children, }) => (_jsxs("html", { lang: "en", children: [_jsxs("head", { children: [_jsx("meta", { charSet: "utf-8" }), _jsx("meta", { name: "viewport", content: "width=device-width, initial-scale=1" })] }), _jsx("body", { children: _jsx("div", { id: "root", children: children }) })] }));
+const isClientReference = (Component) => {
+    return Object.prototype.hasOwnProperty.call(Component, "$$isClientReference");
+};

package/dist/scripts/__sdk.d.mts

@@ -0,0 +1 @@
+export declare const __sdk: (...args: string[]) => Promise<void>;

package/dist/scripts/__sdk.mjs

@@ -0,0 +1,14 @@
+import { $ } from "../lib/$.mjs";
+export const __sdk = async (...args) => {
+    console.log("Resetting development environment...");
+    await $({
+        shell: true,
+    }) `(cd ../../sdk && NODE_ENV=development pnpm build) && pnpm clean:vite && rm -r node_modules/rwsdk/dist && cp -r ../../sdk/{package.json,dist} node_modules/rwsdk/`;
+    if (args.length > 0) {
+        await $({ stdio: "inherit" }) `pnpm ${args.join(" ")}`;
+    }
+};
+if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
+    const args = process.argv.slice(2);
+    __sdk(...args);
+}

package/dist/scripts/debug-sync.d.mts

@@ -0,0 +1,6 @@
+export interface DebugSyncOptions {
+    targetDir: string;
+    sdkDir?: string;
+    watch?: string | boolean;
+}
+export declare const debugSync: (opts: DebugSyncOptions) => Promise<void>;

package/dist/scripts/debug-sync.mjs

@@ -0,0 +1,224 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { $ } from "execa";
+import fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+import chokidar from "chokidar";
+import { lock } from "proper-lockfile";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const getPackageManagerInfo = (targetDir) => {
+    const pnpmResult = {
+        name: "pnpm",
+        lockFile: "pnpm-lock.yaml",
+        command: "add",
+    };
+    if (existsSync(path.join(targetDir, "yarn.lock"))) {
+        return { name: "yarn", lockFile: "yarn.lock", command: "add" };
+    }
+    if (existsSync(path.join(targetDir, "pnpm-lock.yaml"))) {
+        return pnpmResult;
+    }
+    if (existsSync(path.join(targetDir, "package-lock.json"))) {
+        return { name: "npm", lockFile: "package-lock.json", command: "install" };
+    }
+    return pnpmResult;
+};
+const performFullSync = async (sdkDir, targetDir) => {
+    console.log("📦 Packing SDK...");
+    const packResult = await $ `npm pack`;
+    const tarballName = packResult.stdout?.trim() ?? "";
+    if (!tarballName) {
+        console.error("❌ Failed to get tarball name from npm pack.");
+        return;
+    }
+    const tarballPath = path.resolve(sdkDir, tarballName);
+    console.log(`💿 Installing ${tarballName} in ${targetDir}...`);
+    const pm = getPackageManagerInfo(targetDir);
+    const packageJsonPath = path.join(targetDir, "package.json");
+    const lockfilePath = path.join(targetDir, pm.lockFile);
+    const originalPackageJson = await fs
+        .readFile(packageJsonPath, "utf-8")
+        .catch(() => null);
+    const originalLockfile = await fs
+        .readFile(lockfilePath, "utf-8")
+        .catch(() => null);
+    try {
+        const cmd = pm.name;
+        const args = [pm.command];
+        if (pm.name === "yarn") {
+            args.push(`file:${tarballPath}`);
+        }
+        else {
+            args.push(tarballPath);
+        }
+        await $(cmd, args, {
+            cwd: targetDir,
+            stdio: "inherit",
+        });
+    }
+    finally {
+        if (originalPackageJson) {
+            console.log("Restoring package.json...");
+            await fs.writeFile(packageJsonPath, originalPackageJson);
+        }
+        if (originalLockfile) {
+            console.log(`Restoring ${pm.lockFile}...`);
+            await fs.writeFile(lockfilePath, originalLockfile);
+        }
+        await fs.unlink(tarballPath).catch(() => {
+            // ignore if deletion fails
+        });
+    }
+};
+const performFastSync = async (sdkDir, targetDir) => {
+    console.log("⚡️ No dependency changes, performing fast sync...");
+    const sdkPackageJson = JSON.parse(await fs.readFile(path.join(sdkDir, "package.json"), "utf-8"));
+    const filesToSync = sdkPackageJson.files || [];
+    for (const file of filesToSync) {
+        const source = path.join(sdkDir, file);
+        const destination = path.join(targetDir, "node_modules/rwsdk", file);
+        if (existsSync(source)) {
+            await fs.cp(source, destination, { recursive: true, force: true });
+        }
+    }
+    // Always copy package.json
+    await fs.copyFile(path.join(sdkDir, "package.json"), path.join(targetDir, "node_modules/rwsdk/package.json"));
+};
+const performSync = async (sdkDir, targetDir) => {
+    console.log("🏗️  Rebuilding SDK...");
+    await $ `pnpm build`;
+    const sdkPackageJsonPath = path.join(sdkDir, "package.json");
+    const installedSdkPackageJsonPath = path.join(targetDir, "node_modules/rwsdk/package.json");
+    let packageJsonChanged = true;
+    if (existsSync(installedSdkPackageJsonPath)) {
+        const sdkPackageJsonContent = await fs.readFile(sdkPackageJsonPath, "utf-8");
+        const installedSdkPackageJsonContent = await fs.readFile(installedSdkPackageJsonPath, "utf-8");
+        if (sdkPackageJsonContent === installedSdkPackageJsonContent) {
+            packageJsonChanged = false;
+        }
+    }
+    if (packageJsonChanged) {
+        console.log("📦 package.json changed, performing full sync...");
+        await performFullSync(sdkDir, targetDir);
+    }
+    else {
+        await performFastSync(sdkDir, targetDir);
+    }
+    console.log("✅ Done syncing");
+};
+export const debugSync = async (opts) => {
+    const { targetDir, sdkDir = process.cwd(), watch } = opts;
+    if (!targetDir) {
+        console.error("❌ Please provide a target directory as an argument.");
+        process.exit(1);
+    }
+    // If not in watch mode, just do a one-time sync and exit.
+    if (!watch) {
+        await performSync(sdkDir, targetDir);
+        return;
+    }
+    // --- Watch Mode Logic ---
+    const lockfilePath = path.join(targetDir, "node_modules", ".rwsync.lock");
+    let release;
+    // Ensure the directory for the lockfile exists
+    await fs.mkdir(path.dirname(lockfilePath), { recursive: true });
+    // "Touch" the file to ensure it exists before locking
+    await fs.appendFile(lockfilePath, "").catch(() => { });
+    try {
+        release = await lock(lockfilePath, { retries: 0 });
+    }
+    catch (e) {
+        if (e.code === "ELOCKED") {
+            console.error(`❌ Another rwsync process is already watching ${targetDir}.`);
+            console.error(`   If this is not correct, please remove the lockfile at ${lockfilePath}`);
+            process.exit(1);
+        }
+        throw e;
+    }
+    // Initial sync for watch mode. We do it *after* acquiring the lock.
+    let initialSyncOk = false;
+    try {
+        await performSync(sdkDir, targetDir);
+        initialSyncOk = true;
+    }
+    catch (error) {
+        console.error("❌ Initial sync failed:", error);
+        console.log("   Still watching for changes...");
+    }
+    const filesToWatch = [
+        path.join(sdkDir, "src"),
+        path.join(sdkDir, "types"),
+        path.join(sdkDir, "bin"),
+        path.join(sdkDir, "package.json"),
+    ];
+    console.log("👀 Watching for changes...");
+    let childProc = null;
+    const runWatchedCommand = () => {
+        if (typeof watch === "string") {
+            console.log(`\n> ${watch}\n`);
+            childProc = $({
+                stdio: "inherit",
+                shell: true,
+                cwd: targetDir,
+                reject: false,
+            }) `${watch}`;
+        }
+    };
+    const watcher = chokidar.watch(filesToWatch, {
+        ignoreInitial: true,
+        cwd: sdkDir,
+    });
+    watcher.on("all", async () => {
+        console.log("\nDetected change, re-syncing...");
+        if (childProc && !childProc.killed) {
+            console.log("Stopping running process...");
+            childProc.kill();
+            await childProc.catch(() => {
+                /* ignore kill errors */
+            });
+        }
+        try {
+            await performSync(sdkDir, targetDir);
+            runWatchedCommand();
+        }
+        catch (error) {
+            console.error("❌ Sync failed:", error);
+            console.log("   Still watching for changes...");
+        }
+    });
+    const cleanup = async () => {
+        console.log("\nCleaning up...");
+        if (childProc && !childProc.killed) {
+            childProc.kill();
+        }
+        await release();
+        process.exit();
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    if (initialSyncOk) {
+        runWatchedCommand();
+    }
+};
+if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
+    const args = process.argv.slice(2);
+    const watchFlagIndex = args.indexOf("--watch");
+    let watchCmd = watchFlagIndex !== -1;
+    let cmdArgs = args;
+    if (watchFlagIndex !== -1) {
+        if (watchFlagIndex + 1 < args.length &&
+            !args[watchFlagIndex + 1].startsWith("--")) {
+            watchCmd = args[watchFlagIndex + 1];
+        }
+        // remove --watch and its potential command from args
+        const watchArgCount = typeof watchCmd === "string" ? 2 : 1;
+        cmdArgs = args.filter((_, i) => i < watchFlagIndex || i >= watchFlagIndex + watchArgCount);
+    }
+    const targetDir = cmdArgs[0] ?? process.cwd();
+    const sdkDir = path.resolve(__dirname, "..", "..");
+    debugSync({
+        targetDir,
+        sdkDir,
+        watch: watchCmd,
+    });
+}

package/dist/scripts/dev-init.d.mts

@@ -0,0 +1 @@
+export declare const initDev: () => Promise<never>;

package/dist/scripts/dev-init.mjs

@@ -0,0 +1,25 @@
+import { $ } from "../lib/$.mjs";
+import { hasPkgScript } from "../lib/hasPkgScript.mjs";
+export const initDev = async () => {
+    console.log("Initializing development environment...");
+    const projectRootDir = process.cwd();
+    if (await hasPkgScript(projectRootDir, "generate")) {
+        console.log("Generating...");
+        await $ `npm run generate`;
+    }
+    if (await hasPkgScript(projectRootDir, "migrate:dev")) {
+        console.log("Running migrations...");
+        await $ `npm run migrate:dev`;
+    }
+    if (await hasPkgScript(projectRootDir, "seed")) {
+        console.log("Seeding database...");
+        await $ `npm run seed`;
+    }
+    console.log("Done!");
+    console.log();
+    // todo(justinvdm, 01 Apr 2025): Investigate what handles are remaining open
+    process.exit(0);
+};
+if (import.meta.url === new URL(process.argv[1], import.meta.url).href) {
+    initDev();
+}

package/dist/scripts/ensure-deploy-env.d.mts

@@ -0,0 +1 @@
+export declare const ensureDeployEnv: () => Promise<never>;