@astrale-os/adapter-cloudflare 0.5.0-beta.150 → 0.5.0-beta.152

package/dist/build/worker/codegen/literal.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Emit one JavaScript literal that shares every structurally identical subtree.
+ *
+ * Build material reaches a Worker as an inline literal, and JSON has no references, so a flat
+ * literal repeats every repeated subtree. A compiled Domain is dominated by pattern automata, and
+ * a handful of distinct expressions account for dozens of identical copies of one automaton, so
+ * the flat form allocates an order of magnitude more objects than the value actually contains.
+ *
+ * Sharing changes nothing an observer can see. The literal evaluates to a value that serialises
+ * identically, so the material digest taken over it is unchanged, and the material is deeply
+ * frozen before anything reads it, so no holder can observe the aliasing.
+ */
+export interface SharedLiteral {
+    /** `const` declarations for each subtree used more than once, each one after its children. */
+    readonly declarations: readonly string[];
+    /** The expression for the value itself, referencing those declarations. */
+    readonly expression: string;
+}
+export declare function sharedLiteral(value: unknown, prefix?: string): SharedLiteral;
+/**
+ * Refuse a literal that does not evaluate back to the value it was built from.
+ *
+ * Emitting source is the one part of sharing that a type cannot check, so the generator proves its
+ * own output instead: a defect becomes a failed build rather than a Worker that boots with the
+ * wrong material. The comparison is the serialised form, which is also what the material digest
+ * is taken over.
+ */
+export declare function verifySharedLiteral(literal: SharedLiteral, expected: unknown): void;

package/dist/build/worker/codegen/literal.js

@@ -0,0 +1,136 @@
+/**
+ * Emit one JavaScript literal that shares every structurally identical subtree.
+ *
+ * Build material reaches a Worker as an inline literal, and JSON has no references, so a flat
+ * literal repeats every repeated subtree. A compiled Domain is dominated by pattern automata, and
+ * a handful of distinct expressions account for dozens of identical copies of one automaton, so
+ * the flat form allocates an order of magnitude more objects than the value actually contains.
+ *
+ * Sharing changes nothing an observer can see. The literal evaluates to a value that serialises
+ * identically, so the material digest taken over it is unchanged, and the material is deeply
+ * frozen before anything reads it, so no holder can observe the aliasing.
+ */
+/**
+ * An object literal assigns the prototype for a plain `__proto__` key, where a computed key
+ * defines an own property, as JSON does.
+ */
+function memberKey(key) {
+    return key === '__proto__' ? `[${JSON.stringify(key)}]:` : `${JSON.stringify(key)}:`;
+}
+export function sharedLiteral(value, prefix = '$m') {
+    const subtrees = [];
+    const references = [];
+    const byShape = new Map();
+    const byIdentity = new WeakMap();
+    /** A piece list, plus the shape text that decides whether two subtrees are the same one. */
+    const encode = (input) => {
+        const pieces = [];
+        const shape = [];
+        const open = Array.isArray(input) ? '[' : '{';
+        pieces.push(open);
+        shape.push(open);
+        const keys = Array.isArray(input) ? undefined : Object.keys(input);
+        const values = Array.isArray(input)
+            ? input
+            : (keys ?? []).map((key) => input[key]);
+        for (const [index, element] of values.entries()) {
+            if (index > 0) {
+                pieces.push(',');
+                shape.push(',');
+            }
+            if (keys !== undefined) {
+                const member = memberKey(keys[index] ?? '');
+                pieces.push(member);
+                shape.push(member);
+            }
+            if (element !== null && typeof element === 'object') {
+                const id = identify(element);
+                pieces.push({ subtree: id });
+                // Quoted JSON text can never start with `#`, so a reference is unambiguous here.
+                shape.push(`#${id}`);
+            }
+            else {
+                const text = JSON.stringify(element);
+                if (text === undefined) {
+                    throw new TypeError(`Build material cannot hold a ${typeof element} value.`);
+                }
+                pieces.push(text);
+                shape.push(text);
+            }
+        }
+        const close = Array.isArray(input) ? ']' : '}';
+        pieces.push(close);
+        shape.push(close);
+        return { pieces, shape: shape.join('') };
+    };
+    const identify = (input) => {
+        const known = byIdentity.get(input);
+        if (known !== undefined) {
+            references[known] += 1;
+            return known;
+        }
+        const { pieces, shape } = encode(input);
+        const existing = byShape.get(shape);
+        if (existing !== undefined) {
+            byIdentity.set(input, existing);
+            references[existing] += 1;
+            return existing;
+        }
+        const id = subtrees.length;
+        subtrees.push({ pieces });
+        references.push(1);
+        byShape.set(shape, id);
+        byIdentity.set(input, id);
+        return id;
+    };
+    if (value === null || typeof value !== 'object') {
+        const text = JSON.stringify(value);
+        if (text === undefined)
+            throw new TypeError('Build material cannot hold an undefined value.');
+        return { declarations: [], expression: text };
+    }
+    const root = identify(value);
+    references[root] -= 1; // The root is the expression itself, not a nested reference.
+    // A nested subtree always carries a lower identifier than the one holding it, so ascending
+    // order declares every name before its first use.
+    const declarations = [];
+    const names = new Map();
+    const inlined = new Map();
+    for (const [id, subtree] of subtrees.entries()) {
+        const text = subtree.pieces
+            .map((piece) => typeof piece === 'string'
+            ? piece
+            : (names.get(piece.subtree) ?? inlined.get(piece.subtree) ?? ''))
+            .join('');
+        if (id !== root && (references[id] ?? 0) > 1) {
+            const name = `${prefix}${id}`;
+            names.set(id, name);
+            declarations.push(`const ${name} = ${text}`);
+        }
+        else {
+            inlined.set(id, text);
+        }
+    }
+    return { declarations, expression: names.get(root) ?? inlined.get(root) ?? 'null' };
+}
+/**
+ * Refuse a literal that does not evaluate back to the value it was built from.
+ *
+ * Emitting source is the one part of sharing that a type cannot check, so the generator proves its
+ * own output instead: a defect becomes a failed build rather than a Worker that boots with the
+ * wrong material. The comparison is the serialised form, which is also what the material digest
+ * is taken over.
+ */
+export function verifySharedLiteral(literal, expected) {
+    const source = `${literal.declarations.join('\n')}\nreturn ${literal.expression}`;
+    let produced;
+    try {
+        produced = new Function(source)();
+    }
+    catch (cause) {
+        throw new TypeError('Generated Build material literal is not valid JavaScript.', { cause });
+    }
+    if (JSON.stringify(produced) !== JSON.stringify(expected)) {
+        throw new TypeError('Generated Build material literal does not reproduce its material.');
+    }
+}

package/dist/build/worker/codegen/service.js

@@ -1,7 +1,14 @@
 import { generatedMaterial } from '@astrale-os/sdk/deployment/build';
+import { sharedLiteral, verifySharedLiteral } from './literal.js';
 export function generateExecutionService(options) {
     const workerSpecifier = options.workerSpecifier ?? '@astrale-os/adapter-cloudflare/worker';
     const generated = generatedMaterial(options.build);
+    // JSON has no references, so a flat literal repeats every repeated subtree. A compiled Domain
+    // is dominated by pattern automata, of which a few expressions account for dozens of identical
+    // copies, so sharing them cuts what the isolate allocates and seals by an order of magnitude.
+    const material = sharedLiteral(generated);
+    verifySharedLiteral(material, generated);
+    const materialDeclarations = material.declarations.map((line) => `    ${line}\n`).join('');
     const router = options.router;
     const routerPredicate = router === undefined
         ? ''
@@ -36,10 +43,12 @@ type WorkerEnv = CloudflareEnv & CloudflareAdapterBindings & {
 type RuntimeEnv = Omit<WorkerEnv, 'ASTRALE_SIGNING_IDENTITY'>
 ${routerPredicate}
 export default generatedCloudflareWorkerEntry<WorkerEnv, RuntimeEnv>()({
-${frontend}${options.frontendRevision === undefined ? '' : `  frontendRevision: ${JSON.stringify(options.frontendRevision)},\n`}${options.frontendAddressed === undefined ? '' : `  frontendAddressed: ${JSON.stringify(options.frontendAddressed)},\n`}  load: async () => ({
-    runtime: (await import(${JSON.stringify(options.runtimeSpecifier)})).default,
-    material: ${JSON.stringify(generated)} as unknown as GeneratedBuildMaterial,
-  }),
+${frontend}${options.frontendRevision === undefined ? '' : `  frontendRevision: ${JSON.stringify(options.frontendRevision)},\n`}${options.frontendAddressed === undefined ? '' : `  frontendAddressed: ${JSON.stringify(options.frontendAddressed)},\n`}  load: async () => {
+${materialDeclarations}    return {
+      runtime: (await import(${JSON.stringify(options.runtimeSpecifier)})).default,
+      material: ${material.expression} as unknown as GeneratedBuildMaterial,
+    }
+  },
   privateKey: (env) => decodeSigningIdentity(env.ASTRALE_SIGNING_IDENTITY),
   resolveEnvironment: runtimeBindings,
   resolveUrl: (env, requestOrigin) => env.WORKER_URL ?? env.IDENTITY_ISS ?? requestOrigin,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/adapter-cloudflare",
-  "version": "0.5.0-beta.150",
+  "version": "0.5.0-beta.152",
   "description": "Deploy an Astrale application through Cloudflare Workers",
   "keywords": [
     "adapter",
@@ -53,7 +53,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@astrale-os/sdk": "0.5.0-beta.147",
+    "@astrale-os/sdk": "0.5.0-beta.149",
     "@noble/hashes": "2.3.0",
     "hono": "^4.6.20",
     "jose": "^6.1.3",
@@ -61,6 +61,7 @@
   },
   "devDependencies": {
     "@astrale-os/ox": "0.1.3",
+    "@cloudflare/workers-types": "^5.20260820.1",
     "@types/node": "^22.0.0",
     "oxfmt": "0.63.0",
     "oxlint": "1.78.0",
@@ -72,7 +73,7 @@
     "node": ">=22"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json && tsc --noEmit -p __tests__/tsconfig.types.json",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p src/worker/tsconfig.json && tsc --noEmit -p tsconfig.test.json && tsc --noEmit -p __tests__/tsconfig.types.json",
     "test": "vitest run",
     "lint": "oxlint --disable-nested-config .",
     "format": "pnpm exec oxfmt --write .",