@backtickjs/core 0.1.9 → 0.1.11

package/README.md

@@ -36,7 +36,7 @@ export async function Home() {
 }
 ```
 
-`$node` and `$Counter` are splices: `node` is a server variable, written into the bundle as data; `Counter` is a script. `$useState` is a splice too, of an export the client provides. What can be spliced is `Spliceable`: data, and scripts. [Thinking in Backtick](https://backtickjs.com/docs/thinking-in-backtick) has what can cross, what can't, and how server and client components compose.
+`$node` and `$Counter` are splices: `node` is a server variable, written into the bundle as data; `Counter` is a script. `$useState` is a splice too, of an export the client provides. What can be spliced is `Spliceable`: data, and scripts. [Thinking in Backtick](https://backtickjs.com/docs/thinking-in-backtick/) has what can cross, what can't, and how server and client components compose.
 
 A script every component shares, like a context or a store, is made once with `once`: one value for the bundle, where an expression script would run again at each read.
 
@@ -73,6 +73,11 @@ The client must provide that package, and the server must list it in the bundler
 - `Spliced<T>`: what a spliceable value becomes on the client (`Client<U>` becomes `U`; arrays and objects map member by member).
 - `createImport<T>({ name, from, version })`: an export of a module the client provides, as a value a script can splice.
 - `isClientImport`, `ClientImport`: its check and type.
+- `Bundle<T>`: a bundle's code, branded with what it runs to. `bundler.build(…).generate(…)` writes one.
+- `execRoot(bundle, moduleMap)`, from `@backtickjs/core/cjs`: in a React Native app, runs the CommonJS bundle it starts from to its value, as a promise, with `require` answered from `moduleMap`, a `ModuleMap`: the modules the app provides, by specifier.
+- `execRoot(bundle)`, from `@backtickjs/core/es`: in a web page, imports the ES bundle it starts from and resolves to its value, the page's import map answering its imports. Each format has its own entry, so a React Native app's bundler never reads the ES one's `import()`.
+- `exec`: in a script, `$exec(bundle)` runs another bundle as the script's own was run, with the same modules, to a promise of its value.
+- `isClientExec`, `ClientExec`: its check and type.
 - `SplicesAs<T>`: `T` as a splice checks it, member by member. Used by the bundler to check its input.
 - `createJsxElement`, `isJsxElement`, `JsxElement`, `JsxElementOf`, `JsxElementTypeOf`: what a server-side JSX tag evaluates to before bundling. Used by adapters' JSX runtimes.
 - `create`, `isClientScript`, `ClientScript`, `ClientModule`, `Param`: the compiled form of a script, written by the compiler and read by the bundler. Not for application code.
@@ -83,7 +88,7 @@ The client must provide that package, and the server must list it in the bundler
 - [`@backtickjs/react`](https://github.com/backtickjs/backtick/tree/main/adapters/react), [`@backtickjs/react-native`](https://github.com/backtickjs/backtick/tree/main/adapters/react-native), [`@backtickjs/solid-js`](https://github.com/backtickjs/backtick/tree/main/adapters/solid-js): framework adapters
 - [`@backtickjs/node-plugin`](https://github.com/backtickjs/backtick/tree/main/packages/node-plugin), [`@backtickjs/bun-plugin`](https://github.com/backtickjs/backtick/tree/main/packages/bun-plugin): compile scripts as your server loads them
 - [`@backtickjs/tsc`](https://github.com/backtickjs/backtick/tree/main/packages/tsc): type-checks scripts and their splices
-- [Thinking in Backtick](https://backtickjs.com/docs/thinking-in-backtick), [Scripts in depth](https://backtickjs.com/docs/scripts-in-depth)
+- [Thinking in Backtick](https://backtickjs.com/docs/thinking-in-backtick/), [Scripts in depth](https://backtickjs.com/docs/scripts-in-depth/)
 
 ## License
 

package/dist/Bundle.d.ts

@@ -0,0 +1,9 @@
+declare const value: unique symbol;
+/**
+ * A bundle's code, which runs to a `T`: what the bundler writes for a
+ * `Client<T>`, as it reaches the client, from the server.
+ */
+export type Bundle<T> = string & {
+    readonly [value]: T;
+};
+export {};

package/dist/Bundle.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Bundle.js.map

package/dist/Bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bundle.js","sourceRoot":"","sources":["../src/Bundle.ts"],"names":[],"mappings":""}

package/dist/ClientScript.d.ts

@@ -12,7 +12,7 @@ export interface ClientModule {
     readonly map: string;
     readonly dependencies: readonly string[];
     readonly params: readonly Param[];
-    readonly kind: "function" | "expression" | "block";
+    readonly kind: "function" | "class" | "expression" | "block";
 }
 export interface ClientScript {
     readonly "@backtickjs": "ClientScript";

package/dist/ClientScript.js.map

@@ -1 +1 @@
-{"version":3,"file":"ClientScript.js","sourceRoot":"","sources":["../src/ClientScript.ts"],"names":[],"mappings":"AA4CA,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,aAAa,IAAI,KAAK;QACtB,KAAK,CAAC,aAAa,CAAC,KAAK,cAAc,CACxC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,MAAM,CACpB,MAAoB,EACpB,IAA2B;IAE3B,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AACzD,CAAC"}
+{"version":3,"file":"ClientScript.js","sourceRoot":"","sources":["../src/ClientScript.ts"],"names":[],"mappings":"AA6CA,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,aAAa,IAAI,KAAK;QACtB,KAAK,CAAC,aAAa,CAAC,KAAK,cAAc,CACxC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,MAAM,CACpB,MAAoB,EACpB,IAA2B;IAE3B,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AACzD,CAAC"}

package/dist/ModuleMap.d.ts

@@ -0,0 +1,16 @@
+/**
+ * What a bundle may import, by specifier: each the module the app imported
+ * for it. What a web page's import map does, for an app, with modules for
+ * values instead of URLs:
+ *
+ *     import * as React from "react";
+ *     import * as JSXRuntime from "react/jsx-runtime";
+ *     import * as ReactNative from "react-native";
+ *
+ *     export const moduleMap = {
+ *       react: React,
+ *       "react/jsx-runtime": JSXRuntime,
+ *       "react-native": ReactNative,
+ *     };
+ */
+export type ModuleMap = Readonly<Record<string, unknown>>;

package/dist/ModuleMap.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ModuleMap.js.map

package/dist/ModuleMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModuleMap.js","sourceRoot":"","sources":["../src/ModuleMap.ts"],"names":[],"mappings":""}

package/dist/Spliceable.d.ts

@@ -20,6 +20,6 @@ export type SplicesAs<T> = [T] extends [Spliceable] ? T : T extends (...args: ne
 };
 export type Spliced<T> = T extends Client<infer U> ? U : T extends readonly (infer Item extends Spliceable)[] ? number extends T["length"] ? Spliced<Item>[] : {
     -readonly [K in keyof T]: Spliced<T[K]>;
-} : T extends object ? {
+} : T extends string | number | bigint | boolean ? T : T extends object ? {
     -readonly [K in keyof T]: Spliced<T[K]>;
 } : T;

package/dist/cjs.d.ts

@@ -0,0 +1,14 @@
+import type { Bundle } from "./Bundle.js";
+import type { ModuleMap } from "./ModuleMap.js";
+export type { ModuleMap };
+/**
+ * Executes a CommonJS bundle an app starts from, the one nothing else runs,
+ * to its value, with `require` answered from `moduleMap`: how a React Native
+ * app runs what its server answers. The bundles it runs in turn, with `exec`,
+ * get the same modules. Fetching the bundle, and when, is the app's. The
+ * entry an app imports is its format: a web page imports
+ * `@backtickjs/core/es`.
+ *
+ *     const screen = await execRoot(bundle, moduleMap);
+ */
+export declare function execRoot<T>(bundle: Bundle<T>, moduleMap: ModuleMap): Promise<Awaited<T>>;

package/dist/cjs.js

@@ -0,0 +1,22 @@
+/**
+ * Executes a CommonJS bundle an app starts from, the one nothing else runs,
+ * to its value, with `require` answered from `moduleMap`: how a React Native
+ * app runs what its server answers. The bundles it runs in turn, with `exec`,
+ * get the same modules. Fetching the bundle, and when, is the app's. The
+ * entry an app imports is its format: a web page imports
+ * `@backtickjs/core/es`.
+ *
+ *     const screen = await execRoot(bundle, moduleMap);
+ */
+export async function execRoot(bundle, moduleMap) {
+    const require = (specifier) => {
+        if (!Object.hasOwn(moduleMap, specifier)) {
+            throw new Error(`The bundle requires "${specifier}", which this app doesn't provide.`);
+        }
+        return moduleMap[specifier];
+    };
+    const module = { exports: {} };
+    new Function("module", "exports", "require", bundle)(module, module.exports, require);
+    return module.exports;
+}
+//# sourceMappingURL=cjs.js.map

package/dist/cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cjs.js","sourceRoot":"","sources":["../src/cjs.ts"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAC5B,MAAiB,EACjB,SAAoB;IAEpB,MAAM,OAAO,GAAG,CAAC,SAAiB,EAAW,EAAE;QAC7C,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC;YACzC,MAAM,IAAI,KAAK,CACb,wBAAwB,SAAS,oCAAoC,CACtE,CAAC;QACJ,CAAC;QACD,OAAO,SAAS,CAAC,SAAS,CAAC,CAAC;IAC9B,CAAC,CAAC;IACF,MAAM,MAAM,GAAG,EAAE,OAAO,EAAE,EAAa,EAAE,CAAC;IAC1C,IAAI,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC,CAClD,MAAM,EACN,MAAM,CAAC,OAAO,EACd,OAAO,CACR,CAAC;IACF,OAAO,MAAM,CAAC,OAAqB,CAAC;AACtC,CAAC"}

package/dist/cs.d.ts

@@ -4,15 +4,6 @@ import type { Spliceable, SplicesAs, Spliced } from "./Spliceable.js";
 declare function lift<T>(_: T): Client<T>;
 declare function splice<T extends [T] extends [SplicesAs<T>] ? unknown : Spliceable>(_: T): unknown extends Spliced<T> ? any : Spliced<T>;
 declare function awaited<T>(_: T): Awaited<T>;
-/**
- * The globals a project declares — its libs, `@types`, a `declare global` —
- * as an ordinary object type: reading one it doesn't declare is an error
- * however strict the project is, where `typeof globalThis` itself lets it
- * through as `any` without `noImplicitAny`.
- */
-export type GlobalThis = {
-    [Key in keyof typeof globalThis]: (typeof globalThis)[Key];
-};
 /**
  * Writes a client script: code in the host's files that runs on the client.
  * The template is one expression, one block in braces, or one function; a
@@ -20,16 +11,11 @@ export type GlobalThis = {
  * `${expression}` splice host values into it. Returns a `Client<T>`, `T`
  * being what the script computes. Compiled when the host loads the file, by
  * a Backtick plugin; called uncompiled, it throws.
- *
- * `cs.globalThis` is what a name the script didn't bind is read off. In the
- * type and not in the object: nothing runs the virtual code it is written in.
  */
 export declare const cs: ((_strings: TemplateStringsArray, ..._values: unknown[]) => Client<unknown>) & {
     awaited: typeof awaited;
     create: typeof create;
     lift: typeof lift;
     splice: typeof splice;
-} & {
-    readonly globalThis: GlobalThis;
 };
 export {};

package/dist/cs.js

@@ -20,13 +20,6 @@ function awaited(_) {
     throw new Error("Don't call `cs.awaited` directly; it's used to generate virtual " +
         "code for the typechecker. Write code using cs`...` instead.");
 }
-// What hangs off the tag.
-const members = {
-    awaited,
-    create,
-    lift,
-    splice,
-};
 /**
  * Writes a client script: code in the host's files that runs on the client.
  * The template is one expression, one block in braces, or one function; a
@@ -34,11 +27,8 @@ const members = {
  * `${expression}` splice host values into it. Returns a `Client<T>`, `T`
  * being what the script computes. Compiled when the host loads the file, by
  * a Backtick plugin; called uncompiled, it throws.
- *
- * `cs.globalThis` is what a name the script didn't bind is read off. In the
- * type and not in the object: nothing runs the virtual code it is written in.
  */
 export const cs = Object.assign((_strings, ..._values) => {
     throw new Error("`cs` was not compiled. Is @backtickjs set up for this project?");
-}, members);
+}, { awaited, create, lift, splice });
 //# sourceMappingURL=cs.js.map

package/dist/cs.js.map

@@ -1 +1 @@
-{"version":3,"file":"cs.js","sourceRoot":"","sources":["../src/cs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,uBAAuB;AACvB,SAAS,IAAI,CAAI,CAAI;IACnB,MAAM,IAAI,KAAK,CACb,+DAA+D;QAC7D,6DAA6D,CAChE,CAAC;AACJ,CAAC;AAED,uEAAuE;AACvE,0EAA0E;AAC1E,yEAAyE;AACzE,gFAAgF;AAChF,sEAAsE;AACtE,uEAAuE;AACvE,SAAS,MAAM,CACb,CAAI;IAEJ,MAAM,IAAI,KAAK,CACb,iEAAiE;QAC/D,6DAA6D,CAChE,CAAC;AACJ,CAAC;AAED,6EAA6E;AAC7E,gDAAgD;AAChD,SAAS,OAAO,CAAI,CAAI;IACtB,MAAM,IAAI,KAAK,CACb,kEAAkE;QAChE,6DAA6D,CAChE,CAAC;AACJ,CAAC;AAED,0BAA0B;AAC1B,MAAM,OAAO,GAAG;IACd,OAAO;IACP,MAAM;IACN,IAAI;IACJ,MAAM;CACP,CAAC;AAYF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,CAC7B,CAAC,QAA8B,EAAE,GAAG,OAAkB,EAAmB,EAAE;IACzE,MAAM,IAAI,KAAK,CACb,gEAAgE,CACjE,CAAC;AACJ,CAAC,EACD,OAEC,CACF,CAAC"}
+{"version":3,"file":"cs.js","sourceRoot":"","sources":["../src/cs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,uBAAuB;AACvB,SAAS,IAAI,CAAI,CAAI;IACnB,MAAM,IAAI,KAAK,CACb,+DAA+D;QAC7D,6DAA6D,CAChE,CAAC;AACJ,CAAC;AAED,uEAAuE;AACvE,0EAA0E;AAC1E,yEAAyE;AACzE,gFAAgF;AAChF,sEAAsE;AACtE,uEAAuE;AACvE,SAAS,MAAM,CACb,CAAI;IAEJ,MAAM,IAAI,KAAK,CACb,iEAAiE;QAC/D,6DAA6D,CAChE,CAAC;AACJ,CAAC;AAED,6EAA6E;AAC7E,gDAAgD;AAChD,SAAS,OAAO,CAAI,CAAI;IACtB,MAAM,IAAI,KAAK,CACb,kEAAkE;QAChE,6DAA6D,CAChE,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,CAC7B,CAAC,QAA8B,EAAE,GAAG,OAAkB,EAAmB,EAAE;IACzE,MAAM,IAAI,KAAK,CACb,gEAAgE,CACjE,CAAC;AACJ,CAAC,EACD,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAClC,CAAC"}

package/dist/es.d.ts

@@ -0,0 +1,11 @@
+import type { Bundle } from "./Bundle.js";
+/**
+ * Executes an ES bundle a web page starts from, the one nothing else runs, to
+ * its value: imported from a `data:` URL, the page's import map answering its
+ * imports, and those of the bundles it runs in turn with `exec`. Apart from
+ * `@backtickjs/core/cjs`, so a React Native app never reads its `import()`:
+ * Metro rejects one of anything but a string literal, and Hermes has none.
+ *
+ *     const screen = await execRoot(bundle);
+ */
+export declare function execRoot<T>(bundle: Bundle<T>): Promise<Awaited<T>>;

package/dist/es.js

@@ -0,0 +1,14 @@
+/**
+ * Executes an ES bundle a web page starts from, the one nothing else runs, to
+ * its value: imported from a `data:` URL, the page's import map answering its
+ * imports, and those of the bundles it runs in turn with `exec`. Apart from
+ * `@backtickjs/core/cjs`, so a React Native app never reads its `import()`:
+ * Metro rejects one of anything but a string literal, and Hermes has none.
+ *
+ *     const screen = await execRoot(bundle);
+ */
+export async function execRoot(bundle) {
+    const module = (await import("data:text/javascript," + encodeURIComponent(bundle)));
+    return module.default;
+}
+//# sourceMappingURL=es.js.map

package/dist/es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"es.js","sourceRoot":"","sources":["../src/es.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAI,MAAiB;IACjD,MAAM,MAAM,GAAG,CAAC,MAAM,MAAM,CAC1B,uBAAuB,GAAG,kBAAkB,CAAC,MAAM,CAAC,CACrD,CAA4B,CAAC;IAC9B,OAAO,MAAM,CAAC,OAAO,CAAC;AACxB,CAAC"}

package/dist/exec.d.ts

@@ -0,0 +1,14 @@
+import type { Bundle } from "./Bundle.js";
+import type { Client } from "./Client.js";
+/**
+ * Executes a bundle on the client, as the bundle reading it was run, with the
+ * same modules, and resolves to its value: what a script fetched at runtime
+ * from the server, which the bundler couldn't see. As CommonJS, a function of
+ * `require`, handed the bundle's own; as an ES module, imported from a `data:`
+ * URL, which the page's import map answers.
+ */
+export interface ClientExec extends Client<(<T>(bundle: Bundle<T>) => Promise<Awaited<T>>)> {
+    readonly "@backtickjs": "ClientExec";
+}
+export declare const exec: Client<(<T>(bundle: Bundle<T>) => Promise<Awaited<T>>)>;
+export declare function isClientExec(value: unknown): value is ClientExec;

package/dist/exec.js

@@ -0,0 +1,10 @@
+export const exec = {
+    "@backtickjs": "ClientExec",
+};
+export function isClientExec(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "@backtickjs" in value &&
+        value["@backtickjs"] === "ClientExec");
+}
+//# sourceMappingURL=exec.js.map

package/dist/exec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec.js","sourceRoot":"","sources":["../src/exec.ts"],"names":[],"mappings":"AAgBA,MAAM,CAAC,MAAM,IAAI,GAA0D;IACzE,aAAa,EAAE,YAAY;CACH,CAAC;AAE3B,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,aAAa,IAAI,KAAK;QACtB,KAAK,CAAC,aAAa,CAAC,KAAK,YAAY,CACtC,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -7,5 +7,7 @@ export type { Client } from "./Client.js";
 export { once } from "./once.js";
 export type { Spliceable, SplicesAs, Spliced } from "./Spliceable.js";
 export { createImport, isClientImport, type ClientImport, } from "./ClientImport.js";
+export type { Bundle } from "./Bundle.js";
+export { exec, isClientExec, type ClientExec } from "./exec.js";
 export { createJsxElement, isJsxElement, type JsxElement, type JsxElementOf, type JsxElementTypeOf, } from "./JsxElement.js";
 export { create, type ClientModule, type ClientScript, isClientScript, type Param, } from "./ClientScript.js";

package/dist/index.js

@@ -7,6 +7,7 @@
 export { cs } from "./cs.js";
 export { once } from "./once.js";
 export { createImport, isClientImport, } from "./ClientImport.js";
+export { exec, isClientExec } from "./exec.js";
 // A drawing as a host builds one: what an adapter's JSX runtime makes, and
 // what the bundler expands.
 export { createJsxElement, isJsxElement, } from "./JsxElement.js";

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,4EAA4E;AAC5E,wCAAwC;AACxC,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAKjC,OAAO,EACL,YAAY,EACZ,cAAc,GAEf,MAAM,mBAAmB,CAAC;AAE3B,2EAA2E;AAC3E,4BAA4B;AAC5B,OAAO,EACL,gBAAgB,EAChB,YAAY,GAIb,MAAM,iBAAiB,CAAC;AAEzB,6EAA6E;AAC7E,qCAAqC;AACrC,OAAO,EACL,MAAM,EAGN,cAAc,GAEf,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,4EAA4E;AAC5E,wCAAwC;AACxC,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAKjC,OAAO,EACL,YAAY,EACZ,cAAc,GAEf,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EAAE,IAAI,EAAE,YAAY,EAAmB,MAAM,WAAW,CAAC;AAEhE,2EAA2E;AAC3E,4BAA4B;AAC5B,OAAO,EACL,gBAAgB,EAChB,YAAY,GAIb,MAAM,iBAAiB,CAAC;AAEzB,6EAA6E;AAC7E,qCAAqC;AACrC,OAAO,EACL,MAAM,EAGN,cAAc,GAEf,MAAM,mBAAmB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backtickjs/core",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "The cs tag for Backtick client scripts, and the types for the values that cross from server to client",
   "keywords": [
     "backtick",
@@ -28,6 +28,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./cjs": {
+      "types": "./dist/cjs.d.ts",
+      "default": "./dist/cjs.js"
+    },
+    "./es": {
+      "types": "./dist/es.d.ts",
+      "default": "./dist/es.js"
     }
   },
   "files": [

package/src/Bundle.ts

@@ -0,0 +1,7 @@
+declare const value: unique symbol;
+
+/**
+ * A bundle's code, which runs to a `T`: what the bundler writes for a
+ * `Client<T>`, as it reaches the client, from the server.
+ */
+export type Bundle<T> = string & { readonly [value]: T };

package/src/ClientScript.ts

@@ -24,8 +24,9 @@ export interface ClientModule {
   // `params[i]` is the function's `$splice<i>` or `$capture<i>`
   readonly params: readonly Param[];
   // What the script is written as: a function, `(props) => …`, which a splice
-  // reads as that function; or an expression or a block, which a splice runs.
-  readonly kind: "function" | "expression" | "block";
+  // reads as that function; a class, `class … {}`, one class for the bundle;
+  // or an expression or a block, which a splice runs.
+  readonly kind: "function" | "class" | "expression" | "block";
 }
 
 // One run of a `cs`: its module, and the values that run passes it. The rest

package/src/ModuleMap.ts

@@ -0,0 +1,16 @@
+/**
+ * What a bundle may import, by specifier: each the module the app imported
+ * for it. What a web page's import map does, for an app, with modules for
+ * values instead of URLs:
+ *
+ *     import * as React from "react";
+ *     import * as JSXRuntime from "react/jsx-runtime";
+ *     import * as ReactNative from "react-native";
+ *
+ *     export const moduleMap = {
+ *       react: React,
+ *       "react/jsx-runtime": JSXRuntime,
+ *       "react-native": ReactNative,
+ *     };
+ */
+export type ModuleMap = Readonly<Record<string, unknown>>;

package/src/Spliceable.ts

@@ -34,7 +34,7 @@ export type SplicesAs<T> = [T] extends [Spliceable]
 //   Client<U>                 -> U
 //   T[], [A, B]               -> Spliced<T>[], [Spliced<A>, Spliced<B>]
 //   { k: T }                  -> { k: Spliced<T> }
-//   primitives                -> unchanged
+//   primitives                -> unchanged, branded ones too e.g. `Bundle<T>`
 // A tuple maps homomorphically, which keeps it a tuple; any other array stays
 // `Spliced<Item>[]`, which TypeScript defers, so `Spliceable[]` doesn't recurse.
 export type Spliced<T> =
@@ -44,6 +44,8 @@ export type Spliced<T> =
       ? number extends T["length"]
         ? Spliced<Item>[]
         : { -readonly [K in keyof T]: Spliced<T[K]> }
-      : T extends object
-        ? { -readonly [K in keyof T]: Spliced<T[K]> }
-        : T;
+      : T extends string | number | bigint | boolean
+        ? T
+        : T extends object
+          ? { -readonly [K in keyof T]: Spliced<T[K]> }
+          : T;

package/src/cjs.ts

@@ -0,0 +1,35 @@
+import type { Bundle } from "./Bundle.js";
+import type { ModuleMap } from "./ModuleMap.js";
+
+export type { ModuleMap };
+
+/**
+ * Executes a CommonJS bundle an app starts from, the one nothing else runs,
+ * to its value, with `require` answered from `moduleMap`: how a React Native
+ * app runs what its server answers. The bundles it runs in turn, with `exec`,
+ * get the same modules. Fetching the bundle, and when, is the app's. The
+ * entry an app imports is its format: a web page imports
+ * `@backtickjs/core/es`.
+ *
+ *     const screen = await execRoot(bundle, moduleMap);
+ */
+export async function execRoot<T>(
+  bundle: Bundle<T>,
+  moduleMap: ModuleMap,
+): Promise<Awaited<T>> {
+  const require = (specifier: string): unknown => {
+    if (!Object.hasOwn(moduleMap, specifier)) {
+      throw new Error(
+        `The bundle requires "${specifier}", which this app doesn't provide.`,
+      );
+    }
+    return moduleMap[specifier];
+  };
+  const module = { exports: {} as unknown };
+  new Function("module", "exports", "require", bundle)(
+    module,
+    module.exports,
+    require,
+  );
+  return module.exports as Awaited<T>;
+}

package/src/cs.ts

@@ -34,24 +34,6 @@ function awaited<T>(_: T): Awaited<T> {
   );
 }
 
-// What hangs off the tag.
-const members = {
-  awaited,
-  create,
-  lift,
-  splice,
-};
-
-/**
- * The globals a project declares — its libs, `@types`, a `declare global` —
- * as an ordinary object type: reading one it doesn't declare is an error
- * however strict the project is, where `typeof globalThis` itself lets it
- * through as `any` without `noImplicitAny`.
- */
-export type GlobalThis = {
-  [Key in keyof typeof globalThis]: (typeof globalThis)[Key];
-};
-
 /**
  * Writes a client script: code in the host's files that runs on the client.
  * The template is one expression, one block in braces, or one function; a
@@ -59,9 +41,6 @@ export type GlobalThis = {
  * `${expression}` splice host values into it. Returns a `Client<T>`, `T`
  * being what the script computes. Compiled when the host loads the file, by
  * a Backtick plugin; called uncompiled, it throws.
- *
- * `cs.globalThis` is what a name the script didn't bind is read off. In the
- * type and not in the object: nothing runs the virtual code it is written in.
  */
 export const cs = Object.assign(
   (_strings: TemplateStringsArray, ..._values: unknown[]): Client<unknown> => {
@@ -69,7 +48,5 @@ export const cs = Object.assign(
       "`cs` was not compiled. Is @backtickjs set up for this project?",
     );
   },
-  members as typeof members & {
-    readonly globalThis: GlobalThis;
-  },
+  { awaited, create, lift, splice },
 );

package/src/es.ts

@@ -0,0 +1,17 @@
+import type { Bundle } from "./Bundle.js";
+
+/**
+ * Executes an ES bundle a web page starts from, the one nothing else runs, to
+ * its value: imported from a `data:` URL, the page's import map answering its
+ * imports, and those of the bundles it runs in turn with `exec`. Apart from
+ * `@backtickjs/core/cjs`, so a React Native app never reads its `import()`:
+ * Metro rejects one of anything but a string literal, and Hermes has none.
+ *
+ *     const screen = await execRoot(bundle);
+ */
+export async function execRoot<T>(bundle: Bundle<T>): Promise<Awaited<T>> {
+  const module = (await import(
+    "data:text/javascript," + encodeURIComponent(bundle)
+  )) as { default: Awaited<T> };
+  return module.default;
+}

package/src/exec.ts

@@ -0,0 +1,28 @@
+import type { Bundle } from "./Bundle.js";
+import type { Client } from "./Client.js";
+
+/**
+ * Executes a bundle on the client, as the bundle reading it was run, with the
+ * same modules, and resolves to its value: what a script fetched at runtime
+ * from the server, which the bundler couldn't see. As CommonJS, a function of
+ * `require`, handed the bundle's own; as an ES module, imported from a `data:`
+ * URL, which the page's import map answers.
+ */
+export interface ClientExec extends Client<
+  <T>(bundle: Bundle<T>) => Promise<Awaited<T>>
+> {
+  readonly "@backtickjs": "ClientExec";
+}
+
+export const exec: Client<<T>(bundle: Bundle<T>) => Promise<Awaited<T>>> = {
+  "@backtickjs": "ClientExec",
+} as unknown as ClientExec;
+
+export function isClientExec(value: unknown): value is ClientExec {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "@backtickjs" in value &&
+    value["@backtickjs"] === "ClientExec"
+  );
+}

package/src/index.ts

@@ -17,6 +17,11 @@ export {
   isClientImport,
   type ClientImport,
 } from "./ClientImport.js";
+// A bundle's code, typed by what it runs to, and, in a script, executing
+// another as this one was. The one an app starts from is executed by
+// `@backtickjs/core/cjs` or `@backtickjs/core/es`.
+export type { Bundle } from "./Bundle.js";
+export { exec, isClientExec, type ClientExec } from "./exec.js";
 
 // A drawing as a host builds one: what an adapter's JSX runtime makes, and
 // what the bundler expands.