@tnldotdev/tnl 0.1.0-rc.29 → 0.1.0-rc.31

package/dist/bin/tnl.js

@@ -9,7 +9,26 @@ try {
     process.execve(binary, [binary, ...process.argv.slice(2)], process.env);
 }
 catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+    let message = "launcher failed";
+    try {
+        message = error instanceof Error ? error.message : String(error);
+    }
+    catch { }
+    message = [...message]
+        .map((character) => {
+        const codePoint = character.codePointAt(0);
+        return codePoint !== undefined &&
+            (codePoint <= 0x1f ||
+                (codePoint >= 0x7f && codePoint <= 0x9f) ||
+                codePoint === 0x2028 ||
+                codePoint === 0x2029)
+            ? " "
+            : character;
+    })
+        .join("")
+        .trim();
+    if (message === "")
+        message = "launcher failed";
     process.stderr.write(`tnl: ${message}\n`);
     process.exitCode = 1;
 }

package/dist/config.gen.d.ts

@@ -12,11 +12,11 @@ export interface TnlConfig {
      */
     tunnel?: {
         /**
-         * Complete route hostname to publish.
+         * Complete public URL hostname to publish.
          */
         host?: string;
         /**
-         * One DNS label beneath the current member namespace.
+         * One DNS label beneath the current namespace.
          */
         subdomain?: string;
         /**
@@ -58,15 +58,15 @@ export interface TnlConfig {
              */
             team?: string;
             /**
-             * Route and tunnel overrides for this service.
+             * PublicURL and tunnel overrides for this service.
              */
             tunnel?: {
                 /**
-                 * Complete route hostname to publish.
+                 * Complete public URL hostname to publish.
                  */
                 host?: string;
                 /**
-                 * One DNS label beneath the current member namespace.
+                 * One DNS label beneath the current namespace.
                  */
                 subdomain?: string;
                 /**

package/dist/index.browser.d.ts

@@ -0,0 +1,3 @@
+import type { TnlRuntime } from "./index.js";
+/** Browser-safe project metadata; listener registration is server-only. */
+export declare const tnl: TnlRuntime;

package/dist/index.browser.js

@@ -0,0 +1,11 @@
+import { parseRuntimePayload } from "./internal/runtime.js";
+const runtime = parseRuntimePayload(typeof process === "undefined" ? undefined : process.env?.TNL_PROJECT_RUNTIME);
+/** Browser-safe project metadata; listener registration is server-only. */
+export const tnl = Object.freeze({
+    ...runtime,
+    port: 3000,
+    dev: runtime?.dev ?? false,
+    async register() {
+        throw new Error("tnl.register is available only on a development server");
+    },
+});

package/dist/index.d.ts

@@ -1,11 +1,13 @@
 import { type ProjectMetadata } from "./internal/runtime.js";
+import type { LocalHTTPServer } from "./internal/register.js";
 /** Extended with service types from the generated `.tnl/project.d.ts` file. */
 export interface TnlProjectMetadata {
 }
 type RegisteredTnlProject = keyof TnlProjectMetadata extends never ? ProjectMetadata : Readonly<TnlProjectMetadata>;
-type TnlProject = RegisteredTnlProject & {
-    readonly runningUnderTnlDev: boolean;
-};
-/** Project metadata added by a tnl framework integration during development. */
-export declare const tnl: TnlProject | undefined;
+export type TnlRuntime = Readonly<Partial<RegisteredTnlProject> & {
+    readonly port: number;
+    readonly dev: boolean;
+    register(server: LocalHTTPServer): Promise<void>;
+}>;
+export declare const tnl: TnlRuntime;
 export {};

package/dist/index.js

@@ -1,6 +1,19 @@
+import { developmentPort } from "./internal/port.js";
 import { parseRuntimePayload } from "./internal/runtime.js";
 const serializedRuntime = typeof process === "undefined" ? undefined : process.env?.TNL_PROJECT_RUNTIME;
-/** Project metadata added by a tnl framework integration during development. */
+/** Server port and optional browser-safe project metadata for this process. */
 // The parser validates the runtime shape; generated project declarations supply
 // project-specific service names and literals unavailable to this shared module.
-export const tnl = parseRuntimePayload(serializedRuntime);
+const runtime = parseRuntimePayload(serializedRuntime);
+export const tnl = Object.freeze({
+    ...runtime,
+    port: developmentPort(typeof process === "undefined" ? {} : (process.env ?? {}), "Bun" in globalThis),
+    dev: runtime?.dev ?? false,
+    async register(server) {
+        if (typeof process === "undefined") {
+            throw new Error("tnl.register is available only on a development server");
+        }
+        const { registerServer } = await import("./internal/register.js");
+        await registerServer(server);
+    },
+});

package/dist/internal/dev.d.ts

@@ -6,7 +6,7 @@ export interface TnlDevBootstrap {
 }
 export interface ProjectDocument extends ProjectMetadata {
     readonly projectRoot: string;
-    readonly runningUnderTnlDev: boolean;
+    readonly dev: boolean;
     readonly serviceDirectories: Readonly<Record<string, string>>;
     readonly version: 1;
 }
@@ -23,7 +23,7 @@ export interface DevelopmentContext {
 export interface TnlTunnelAssignment extends TnlDevBootstrap {
     readonly framework: string;
     readonly hostname: string;
-    readonly memberNamespace: string;
+    readonly namespace: string;
     readonly project: ProjectRuntime;
     readonly publicURL: `https://${string}`;
     readonly service: string | null;
@@ -34,7 +34,7 @@ export declare function readDevelopmentContext(environment?: TnlDevEnvironment,
 export declare function requestTunnelAssignment(framework: string, bootstrap: TnlDevBootstrap): Promise<TnlTunnelAssignment>;
 export declare function canonicalLoopbackTarget(host: string, port: number): CanonicalLoopbackTarget;
 export declare function registerLocalTarget(assignment: TnlTunnelAssignment, target: CanonicalLoopbackTarget): Promise<void>;
-export declare function runtimePayload(project: ProjectMetadata, runningUnderTnlDev: boolean): string;
+export declare function runtimePayload(project: ProjectMetadata, dev: boolean): string;
 export declare function discoverProject(cwd: string): ProjectDiscovery | null;
 export declare function socketIdentity(projectRoot: string, service: string | null): string;
 /** Parses a decimal listener port from 1 through 65535. */

package/dist/internal/dev.js

@@ -38,7 +38,7 @@ export async function requestTunnelAssignment(framework, bootstrap) {
         throw new Error("tnl framework name is invalid");
     }
     const body = JSON.stringify({ protocol: 1, framework });
-    const response = await sendRequest(bootstrap, framework, "/v1/configure", body, 200);
+    const response = await sendRequest(bootstrap, framework, "/v1/configure", body, 200, "configuration");
     return parseAssignment(response, bootstrap, framework);
 }
 export function canonicalLoopbackTarget(host, port) {
@@ -63,10 +63,10 @@ export function canonicalLoopbackTarget(host, port) {
 }
 export async function registerLocalTarget(assignment, target) {
     const body = JSON.stringify({ protocol: 1, framework: assignment.framework, target });
-    await sendRequest(assignment, assignment.framework, "/v1/target", body, 204);
+    await sendRequest(assignment, assignment.framework, "/v1/target", body, 204, "target registration");
 }
-export function runtimePayload(project, runningUnderTnlDev) {
-    return serializeRuntimePayload(project, runningUnderTnlDev);
+export function runtimePayload(project, dev) {
+    return serializeRuntimePayload(project, dev);
 }
 export function discoverProject(cwd) {
     let directory = absoluteNormalizedPath(cwd, "working directory");
@@ -147,7 +147,7 @@ function discoverDevSocket(discovery, environment) {
 }
 function parseAssignment(value, bootstrap, framework) {
     const object = record(value, "tnl dev response");
-    exactKeys(object, ["hostname", "memberNamespace", "project", "protocol", "publicURL", "service", "tunnelID"], "tnl dev response");
+    exactKeys(object, ["hostname", "namespace", "project", "protocol", "publicURL", "service", "tunnelID"], "tnl dev response");
     if (object.protocol !== 1) {
         throw new Error("tnl dev returned an inconsistent tunnel assignment");
     }
@@ -157,20 +157,18 @@ function parseAssignment(value, bootstrap, framework) {
     if (object.service !== null && !validServiceName(object.service)) {
         throw new Error("tnl dev returned an invalid service");
     }
-    const memberNamespace = requiredHostname(object.memberNamespace, "tnl dev returned member namespace");
+    const responseNamespace = requiredHostname(object.namespace, "tnl dev returned namespace");
     const hostname = requiredHostname(object.hostname, "tnl dev returned public hostname");
     const publicURL = `https://${hostname}`;
     if (object.publicURL !== publicURL) {
         throw new Error("tnl dev returned an invalid public URL");
     }
     const project = parseProjectRuntime(object.project, "tnl dev project metadata");
-    if (!project.runningUnderTnlDev) {
+    if (!project.dev) {
         throw new Error("tnl dev returned project metadata outside tnl dev");
     }
-    const assignmentNamespace = object.service === null
-        ? project.memberNamespace
-        : project.services[object.service]?.memberNamespace;
-    if (assignmentNamespace !== memberNamespace) {
+    const projectNamespace = object.service === null ? project.namespace : project.services[object.service]?.namespace;
+    if (projectNamespace !== responseNamespace) {
         throw new Error("tnl dev returned inconsistent project metadata");
     }
     if (object.service !== null && project.services[object.service] === undefined) {
@@ -183,7 +181,7 @@ function parseAssignment(value, bootstrap, framework) {
         ...bootstrap,
         framework,
         hostname,
-        memberNamespace,
+        namespace: responseNamespace,
         project,
         publicURL,
         service: object.service,
@@ -202,17 +200,17 @@ function parseProjectDocument(serialized, description, projectRoot) {
 }
 function parseProjectDocumentValue(value, description, projectRoot) {
     const object = record(value, description);
-    exactKeys(object, ["memberNamespace", "runningUnderTnlDev", "serviceDirectories", "services", "version"], description);
+    exactKeys(object, ["dev", "namespace", "serviceDirectories", "services", "version"], description);
     if (object.version !== 1) {
         throw new Error(`${description} has an unsupported version`);
     }
-    if (typeof object.runningUnderTnlDev !== "boolean") {
-        throw new Error(`${description} has an invalid runningUnderTnlDev value`);
+    if (typeof object.dev !== "boolean") {
+        throw new Error(`${description} has an invalid dev value`);
     }
-    if (object.runningUnderTnlDev) {
+    if (object.dev) {
         throw new Error(`${description} cannot be marked as running under tnl dev`);
     }
-    const project = parseProjectMetadata({ memberNamespace: object.memberNamespace, services: object.services }, description);
+    const project = parseProjectMetadata({ namespace: object.namespace, services: object.services }, description);
     const directoryValues = record(object.serviceDirectories, `${description} service directories`);
     const names = Object.keys(project.services);
     if (Object.keys(directoryValues).length !== names.length ||
@@ -226,13 +224,13 @@ function parseProjectDocumentValue(value, description, projectRoot) {
     return Object.freeze({
         ...project,
         projectRoot,
-        runningUnderTnlDev: object.runningUnderTnlDev,
+        dev: object.dev,
         serviceDirectories: Object.freeze(serviceDirectories),
         version: 1,
     });
 }
 function projectMetadata(document) {
-    return Object.freeze({ memberNamespace: document.memberNamespace, services: document.services });
+    return Object.freeze({ namespace: document.namespace, services: document.services });
 }
 function selectService(document, cwd) {
     const absoluteCwd = absoluteNormalizedPath(cwd, "working directory");
@@ -262,64 +260,105 @@ function relativeDirectory(value, description) {
     }
     return value;
 }
-function sendRequest(bootstrap, framework, requestPath, body, expectedStatus) {
+function sendRequest(bootstrap, framework, requestPath, body, expectedStatus, operation) {
     return new Promise((resolve, reject) => {
-        const request = http.request({
-            socketPath: bootstrap.socket,
-            path: requestPath,
-            method: "POST",
-            headers: {
-                "Content-Length": Buffer.byteLength(body),
-                "Content-Type": "application/json",
-            },
-        }, (response) => {
-            response.on("error", reject);
-            const declaredLength = Number(response.headers["content-length"]);
-            if (Number.isFinite(declaredLength) && declaredLength > maximumResponseBytes) {
-                response.destroy(new Error("tnl dev returned an oversized response"));
+        let settled = false;
+        const succeed = (value) => {
+            if (settled)
                 return;
-            }
-            const chunks = [];
-            let size = 0;
-            response.on("data", (chunk) => {
-                size += chunk.length;
-                if (size > maximumResponseBytes) {
-                    response.destroy(new Error("tnl dev returned an oversized response"));
-                    return;
-                }
-                chunks.push(chunk);
-            });
-            response.on("end", () => {
-                const data = Buffer.concat(chunks).toString("utf8").trim();
-                if (response.statusCode !== expectedStatus) {
-                    reject(new Error(`tnl dev rejected the ${framework} request with status ${response.statusCode}${data ? `: ${data}` : ""}`));
+            settled = true;
+            resolve(value);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(error);
+        };
+        const failTransport = (phase, cause) => {
+            fail(new Error(`tnl dev ${operation} ${phase} failed`, { cause }));
+        };
+        let request;
+        try {
+            request = http.request({
+                socketPath: bootstrap.socket,
+                path: requestPath,
+                method: "POST",
+                headers: {
+                    "Content-Length": Buffer.byteLength(body),
+                    "Content-Type": "application/json",
+                },
+            }, (response) => {
+                response.on("error", (error) => failTransport("response", error));
+                response.on("close", () => {
+                    if (!response.complete) {
+                        failTransport("response", new Error("tnl dev response closed before it was complete"));
+                    }
+                });
+                const declaredLength = Number(response.headers["content-length"]);
+                if (Number.isFinite(declaredLength) && declaredLength > maximumResponseBytes) {
+                    fail(new Error("tnl dev returned an oversized response"));
+                    response.destroy();
                     return;
                 }
-                if (expectedStatus === 204) {
-                    if (data !== "") {
-                        reject(new Error("tnl dev returned an unexpected target response"));
+                const chunks = [];
+                let size = 0;
+                response.on("data", (chunk) => {
+                    if (settled)
+                        return;
+                    size += chunk.length;
+                    if (size > maximumResponseBytes) {
+                        fail(new Error("tnl dev returned an oversized response"));
+                        response.destroy();
                         return;
                     }
-                    resolve(undefined);
-                    return;
-                }
-                if (response.headers["content-type"]?.split(";", 1)[0]?.trim() !== "application/json") {
-                    reject(new Error("tnl dev returned a non-JSON configuration"));
-                    return;
-                }
-                try {
-                    resolve(JSON.parse(data));
-                }
-                catch (error) {
-                    reject(new Error("tnl dev returned an invalid configuration", { cause: error }));
-                }
+                    chunks.push(chunk);
+                });
+                response.on("end", () => {
+                    if (!response.complete) {
+                        failTransport("response", new Error("tnl dev response ended before it was complete"));
+                        return;
+                    }
+                    const data = Buffer.concat(chunks).toString("utf8").trim();
+                    if (response.statusCode !== expectedStatus) {
+                        fail(new Error(`tnl dev rejected the ${framework} request with status ${response.statusCode}${data ? `: ${data}` : ""}`));
+                        return;
+                    }
+                    if (expectedStatus === 204) {
+                        if (data !== "") {
+                            fail(new Error("tnl dev returned an unexpected target response"));
+                            return;
+                        }
+                        succeed(undefined);
+                        return;
+                    }
+                    if (response.headers["content-type"]?.split(";", 1)[0]?.trim() !== "application/json") {
+                        fail(new Error("tnl dev returned a non-JSON configuration"));
+                        return;
+                    }
+                    try {
+                        succeed(JSON.parse(data));
+                    }
+                    catch (error) {
+                        fail(new Error("tnl dev returned an invalid configuration", { cause: error }));
+                    }
+                });
             });
-        });
+        }
+        catch (error) {
+            failTransport("request", error);
+            return;
+        }
         request.setTimeout(registrationTimeoutMilliseconds, () => {
             request.destroy(new Error("timed out configuring the target with tnl dev"));
         });
-        request.on("error", reject);
-        request.end(body);
+        request.on("error", (error) => failTransport("request", error));
+        try {
+            request.end(body);
+        }
+        catch (error) {
+            failTransport("request", error);
+        }
     });
 }
 function readBoundedFile(file) {

package/dist/internal/launcher.js

@@ -5,6 +5,7 @@ import process from "node:process";
 import { nativeTargets } from "./native-targets.js";
 const require = createRequire(import.meta.url);
 const launcherManifest = new URL("../../package.json", import.meta.url);
+const packageVersionPattern = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 const nativePackages = new Map(nativeTargets.map(({ platform, architecture, packageName }) => [
     `${platform}-${architecture}`,
     packageName,
@@ -29,10 +30,10 @@ export function resolveNativeBinary(options = {}) {
         }
         throw error;
     }
-    const mainManifest = readManifest(launcherManifest);
-    const nativeManifest = readManifest(nativeManifestPath);
+    const mainManifest = readManifest(launcherManifest, "@tnldotdev/tnl");
+    const nativeManifest = readManifest(nativeManifestPath, packageName);
     if (nativeManifest.version !== mainManifest.version) {
-        throw new Error(`${packageName}@${String(nativeManifest.version)} does not match @tnldotdev/tnl@${String(mainManifest.version)}`);
+        throw new Error(`${packageName}@${nativeManifest.version} does not match @tnldotdev/tnl@${mainManifest.version}`);
     }
     const binary = path.join(path.dirname(nativeManifestPath), "bin", "tnl");
     try {
@@ -43,13 +44,37 @@ export function resolveNativeBinary(options = {}) {
     }
     return binary;
 }
-function readManifest(file) {
-    const value = JSON.parse(readFileSync(file, "utf8"));
+function readManifest(file, packageName) {
+    let serialized;
+    try {
+        serialized = readFileSync(file, "utf8");
+    }
+    catch (error) {
+        throw new Error(`failed to read ${packageName} package manifest`, { cause: error });
+    }
+    let value;
+    try {
+        value = JSON.parse(serialized);
+    }
+    catch (error) {
+        throw new Error(`${packageName} package manifest is not valid JSON`, { cause: error });
+    }
+    try {
+        return parseManifest(value);
+    }
+    catch (error) {
+        throw new Error(`${packageName} package manifest has an invalid shape`, { cause: error });
+    }
+}
+function parseManifest(value) {
     if (value === null ||
         typeof value !== "object" ||
+        Array.isArray(value) ||
         !("version" in value) ||
-        typeof value.version !== "string") {
-        throw new Error("package manifest has an invalid shape");
+        typeof value.version !== "string" ||
+        value.version.length > 256 ||
+        !packageVersionPattern.test(value.version)) {
+        throw new TypeError("package manifest version must be a valid semantic version");
     }
     return { version: value.version };
 }

package/dist/internal/port.d.ts

@@ -0,0 +1,2 @@
+/** Selects a free port under tnl dev, or the runtime's usual local port. */
+export declare function developmentPort(environment: Record<string, string | undefined>, bun: boolean): number;

package/dist/internal/port.js

@@ -0,0 +1,21 @@
+/** Selects a free port under tnl dev, or the runtime's usual local port. */
+export function developmentPort(environment, bun) {
+    if (environment.TNL_DEV_PROTOCOL !== undefined) {
+        if (environment.TNL_DEV_PROTOCOL !== "1") {
+            throw new Error("unsupported tnl dev protocol; upgrade tnl and its integrations");
+        }
+        const forced = environment.TNL_DEV_PORT;
+        return forced === undefined ? 0 : parsePort(forced, "TNL_DEV_PORT");
+    }
+    const configured = bun
+        ? (environment.BUN_PORT ?? environment.PORT ?? environment.NODE_PORT)
+        : environment.PORT;
+    return configured === undefined ? 3000 : parsePort(configured, "development port");
+}
+function parsePort(value, name) {
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535 || String(port) !== value) {
+        throw new Error(`${name} must be a port between 1 and 65535`);
+    }
+    return port;
+}

package/dist/internal/register.d.ts

@@ -0,0 +1,20 @@
+export interface BunHTTPServer {
+    readonly hostname?: string | undefined;
+    readonly port?: number | undefined;
+    readonly url: URL;
+    stop(closeActiveConnections?: boolean): Promise<void> | void;
+}
+/** Small structural surface shared by Node HTTP servers, without Node types in browser declarations. */
+export interface NodeHTTPServer {
+    readonly listening: boolean;
+    address(): unknown;
+    once(event: "listening", listener: () => void): unknown;
+    once(event: "error", listener: (error: Error) => void): unknown;
+    off(event: "listening", listener: () => void): unknown;
+    off(event: "error", listener: (error: Error) => void): unknown;
+    close(callback?: (error?: Error) => void): unknown;
+    closeAllConnections?(): void;
+}
+export type LocalHTTPServer = NodeHTTPServer | BunHTTPServer;
+/** Registers a bound Node or Bun HTTP listener with this tnl dev invocation. */
+export declare function registerServer(server: LocalHTTPServer): Promise<void>;

package/dist/internal/register.js

@@ -0,0 +1,79 @@
+import { Server as HTTPSServer } from "node:https";
+import { canonicalLoopbackTarget, readDevelopmentContext, registerLocalTarget, requestTunnelAssignment, } from "./dev.js";
+/** Registers a bound Node or Bun HTTP listener with this tnl dev invocation. */
+export async function registerServer(server) {
+    const { bootstrap } = readDevelopmentContext();
+    if (bootstrap === null)
+        return;
+    try {
+        const target = await listeningTarget(server);
+        const framework = isBunServer(server) ? "bun" : "node";
+        const assignment = await requestTunnelAssignment(framework, bootstrap);
+        await registerLocalTarget(assignment, target);
+    }
+    catch (error) {
+        try {
+            await closeServer(server);
+        }
+        catch (closeError) {
+            throw new AggregateError([error, closeError], "tnl target registration and server cleanup failed", {
+                cause: error,
+            });
+        }
+        throw error;
+    }
+}
+async function listeningTarget(server) {
+    if (isBunServer(server)) {
+        const hostname = server.hostname ?? server.url.hostname;
+        if (server.url.protocol !== "http:" ||
+            typeof server.port !== "number" ||
+            !Number.isInteger(server.port) ||
+            typeof hostname !== "string") {
+            throw new Error("Bun did not report a TCP listening address");
+        }
+        return canonicalLoopbackTarget(hostname, server.port);
+    }
+    if (server instanceof HTTPSServer) {
+        throw new Error("tnl dev requires a local HTTP listener");
+    }
+    if (server.address() === null) {
+        await new Promise((resolve, reject) => {
+            const onListening = () => {
+                server.off("error", onError);
+                resolve();
+            };
+            const onError = (error) => {
+                server.off("listening", onListening);
+                reject(error);
+            };
+            server.once("listening", onListening);
+            server.once("error", onError);
+        });
+    }
+    const address = server.address();
+    if (address === null ||
+        typeof address !== "object" ||
+        !("address" in address) ||
+        !("port" in address) ||
+        typeof address.address !== "string" ||
+        typeof address.port !== "number") {
+        throw new Error("Node did not report a TCP listening address");
+    }
+    return canonicalLoopbackTarget(address.address, address.port);
+}
+async function closeServer(server) {
+    if (isBunServer(server)) {
+        await server.stop(true);
+        return;
+    }
+    if (server.listening) {
+        await new Promise((resolve, reject) => {
+            server.close((error) => (error ? reject(error) : resolve()));
+            server.closeAllConnections?.();
+        });
+    }
+}
+function isBunServer(server) {
+    return "stop" in server && typeof server.stop === "function";
+}

package/dist/internal/runtime.d.ts

@@ -1,14 +1,14 @@
 export interface ProjectServiceMetadata {
-    readonly memberNamespace: string;
+    readonly namespace: string;
     readonly hostname: string;
     readonly url: `https://${string}`;
 }
 export interface ProjectMetadata {
-    readonly memberNamespace: string;
+    readonly namespace: string;
     readonly services: Readonly<Record<string, ProjectServiceMetadata | undefined>>;
 }
 export interface ProjectRuntime extends ProjectMetadata {
-    readonly runningUnderTnlDev: boolean;
+    readonly dev: boolean;
 }
 /** Checks browser-safe project metadata and makes it read-only. */
 export declare function parseProjectMetadata(value: unknown, description: string): ProjectMetadata;
@@ -16,7 +16,7 @@ export declare function parseProjectMetadata(value: unknown, description: string
 export declare function validServiceName(value: unknown): value is string;
 export declare function parseRuntimePayload(serialized: string | undefined): ProjectRuntime | undefined;
 export declare function parseProjectRuntime(value: unknown, description: string): ProjectRuntime;
-export declare function serializeRuntimePayload(project: ProjectMetadata, runningUnderTnlDev: boolean): string;
+export declare function serializeRuntimePayload(project: ProjectMetadata, dev: boolean): string;
 export declare function requiredHostname(value: unknown, description: string): string;
 export declare function exactKeys(object: Record<string, unknown>, expected: readonly string[], description: string): void;
 export declare function record(value: unknown, description: string): Record<string, unknown>;

package/dist/internal/runtime.js

@@ -4,8 +4,8 @@ const serviceNamePattern = /^[a-z](?:[a-z0-9-]{0,30}[a-z0-9])?$/;
 /** Checks browser-safe project metadata and makes it read-only. */
 export function parseProjectMetadata(value, description) {
     const object = record(value, description);
-    exactKeys(object, ["memberNamespace", "services"], description);
-    const memberNamespace = requiredHostname(object.memberNamespace, `${description} member namespace`);
+    exactKeys(object, ["namespace", "services"], description);
+    const projectNamespace = requiredHostname(object.namespace, `${description} namespace`);
     const servicesObject = record(object.services, `${description} services`);
     const entries = Object.entries(servicesObject);
     if (entries.length > maximumServices) {
@@ -18,8 +18,8 @@ export function parseProjectMetadata(value, description) {
             throw new Error(`${description} contains an invalid service name ${JSON.stringify(name)}`);
         }
         const service = record(value, `${description} service ${JSON.stringify(name)}`);
-        exactKeys(service, ["hostname", "memberNamespace", "url"], `${description} service ${JSON.stringify(name)}`);
-        const serviceMemberNamespace = requiredHostname(service.memberNamespace, `${description} service ${JSON.stringify(name)} member namespace`);
+        exactKeys(service, ["hostname", "namespace", "url"], `${description} service ${JSON.stringify(name)}`);
+        const serviceNamespace = requiredHostname(service.namespace, `${description} service ${JSON.stringify(name)} namespace`);
         const hostname = requiredHostname(service.hostname, `${description} service ${JSON.stringify(name)} hostname`);
         const url = `https://${hostname}`;
         if (service.url !== url) {
@@ -30,13 +30,13 @@ export function parseProjectMetadata(value, description) {
         }
         hostnames.add(hostname);
         services[name] = Object.freeze({
-            memberNamespace: serviceMemberNamespace,
+            namespace: serviceNamespace,
             hostname,
             url,
         });
     }
     return Object.freeze({
-        memberNamespace,
+        namespace: projectNamespace,
         services: Object.freeze(services),
     });
 }
@@ -62,20 +62,20 @@ export function parseRuntimePayload(serialized) {
 }
 export function parseProjectRuntime(value, description) {
     const object = record(value, description);
-    exactKeys(object, ["memberNamespace", "runningUnderTnlDev", "services"], description);
-    if (typeof object.runningUnderTnlDev !== "boolean") {
-        throw new Error(`${description} has an invalid runningUnderTnlDev value`);
+    exactKeys(object, ["dev", "namespace", "services"], description);
+    if (typeof object.dev !== "boolean") {
+        throw new Error(`${description} has an invalid dev value`);
     }
-    const project = parseProjectMetadata({ memberNamespace: object.memberNamespace, services: object.services }, description);
+    const project = parseProjectMetadata({ namespace: object.namespace, services: object.services }, description);
     return Object.freeze({
         ...project,
-        runningUnderTnlDev: object.runningUnderTnlDev,
+        dev: object.dev,
     });
 }
-export function serializeRuntimePayload(project, runningUnderTnlDev) {
+export function serializeRuntimePayload(project, dev) {
     const serialized = JSON.stringify({
-        memberNamespace: project.memberNamespace,
-        runningUnderTnlDev,
+        namespace: project.namespace,
+        dev,
         services: project.services,
     });
     if (byteLength(serialized) > maximumRuntimeBytes) {

package/dist/vite.js

@@ -56,28 +56,41 @@ export default function tnl(...arguments_) {
             }
             const originalListen = server.listen.bind(server);
             server.listen = async (port, isRestart) => {
-                const listening = await originalListen(port, isRestart);
+                let listening;
+                try {
+                    listening = await originalListen(port, isRestart);
+                }
+                catch (error) {
+                    return await closeAfterFailure(server.close.bind(server), error);
+                }
                 if (localPortRegistered) {
                     return listening;
                 }
-                const address = server.httpServer?.address();
-                if (address === null || address === undefined || typeof address === "string") {
-                    await server.close();
-                    throw new Error("Vite did not report its listening port to tnl dev");
-                }
                 try {
+                    const address = server.httpServer?.address();
+                    if (address === null || address === undefined || typeof address === "string") {
+                        throw new Error("Vite did not report its listening port to tnl dev");
+                    }
                     await registerLocalTarget(configured, canonicalLoopbackTarget(address.address, address.port));
                     localPortRegistered = true;
                 }
                 catch (error) {
-                    await server.close();
-                    throw error;
+                    return await closeAfterFailure(server.close.bind(server), error);
                 }
                 return listening;
             };
         },
     };
 }
+async function closeAfterFailure(close, error) {
+    try {
+        await close();
+    }
+    catch (closeError) {
+        throw new AggregateError([error, closeError], "Vite listener setup failed and server cleanup also failed", { cause: error });
+    }
+    throw error;
+}
 function runtimeDefine(payload) {
     return {
         define: {

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@tnldotdev/tnl",
-  "version": "0.1.0-rc.29",
+  "version": "0.1.0-rc.31",
   "bin": {
     "tnl": "dist/bin/tnl.js"
   },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "browser": "./dist/index.browser.js",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
@@ -31,7 +32,21 @@
     "clean": "node ../../scripts/clean-package.ts",
     "prepack": "pnpm run build"
   },
-  "description": "The tnl client and framework integrations for project-local development.",
+  "description": "public urls for every worktree.",
+  "keywords": [
+    "git-worktree",
+    "local-development",
+    "localhost",
+    "nextjs",
+    "ngrok-alternative",
+    "self-hosted",
+    "tunnel",
+    "vite"
+  ],
+  "homepage": "https://tnl.dev",
+  "bugs": {
+    "url": "https://github.com/tnldotdev/tnl/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -49,6 +64,9 @@
     "access": "public"
   },
   "devDependencies": {
+    "@hono/node-server": "2.1.1",
+    "@types/bun": "1.4.2",
+    "hono": "4.13.9",
     "next": "16.3.5",
     "react": "19.3.0",
     "react-dom": "19.3.0",
@@ -70,12 +88,12 @@
     "node": ">=22.18"
   },
   "optionalDependencies": {
-    "@tnldotdev/tnl-darwin-arm64": "0.1.0-rc.29",
-    "@tnldotdev/tnl-darwin-x64": "0.1.0-rc.29",
-    "@tnldotdev/tnl-linux-arm64": "0.1.0-rc.29",
-    "@tnldotdev/tnl-linux-x64": "0.1.0-rc.29"
+    "@tnldotdev/tnl-darwin-arm64": "0.1.0-rc.31",
+    "@tnldotdev/tnl-darwin-x64": "0.1.0-rc.31",
+    "@tnldotdev/tnl-linux-arm64": "0.1.0-rc.31",
+    "@tnldotdev/tnl-linux-x64": "0.1.0-rc.31"
   },
   "tnl": {
-    "commit": "a0c2f155ee7eb907273bfad43e5a691670a058fc"
+    "commit": "99ade4f0196917581f5cbba4626b4dbf8991489b"
   }
 }