@base44/functions-compiler 0.1.0 → 0.1.4

package/lib/src/private-data-sources/node-net-adapter.ts

@@ -3,6 +3,7 @@ import nodeNet from "node:net";
 import { Duplex } from "node:stream";
 
 import { isCloudflareTcpSocket } from "./tcp";
+import type { CloudflareTcpSocket } from "./types";
 
 interface NodeNetSocket extends Duplex {
   connecting: boolean;
@@ -95,10 +96,7 @@ export function buildNodeNetSocket(
   label: string,
   options: { deferConnectEvent?: boolean } = {},
 ): NodeNetSocket {
-  if (!isCloudflareTcpSocket(socket)) {
-    throw new Error(`${label} did not return a readable/writable TCP socket`);
-  }
-  const cloudflareSocket = socket;
+  let cloudflareSocket: CloudflareTcpSocket | undefined;
 
   let reader: ReadableStreamDefaultReader<Uint8Array> | null = null;
   let writer: WritableStreamDefaultWriter<Uint8Array> | null = null;
@@ -107,6 +105,14 @@ export function buildNodeNetSocket(
   let readableEnded = false;
   let timeout: ReturnType<typeof setTimeout> | null = null;
   let writeChain = Promise.resolve();
+  const socketReady = Promise.resolve(socket).then((resolved) => {
+    if (!isCloudflareTcpSocket(resolved)) {
+      throw new Error(`${label} did not return a readable/writable TCP socket`);
+    }
+    cloudflareSocket = resolved;
+    if (closed) resolved.close?.();
+    return resolved;
+  });
 
   function clearTimer() {
     if (!timeout) return;
@@ -143,8 +149,9 @@ export function buildNodeNetSocket(
       const bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
       writeChain = writeChain
         .then(async () => {
+          const connectedSocket = await socketReady;
           if (closed) throw new Error(`${label} connection is closed`);
-          const activeWriter = writer ?? cloudflareSocket.writable.getWriter();
+          const activeWriter = writer ?? connectedSocket.writable.getWriter();
           writer = activeWriter;
           await activeWriter.write(bytes);
         })
@@ -157,7 +164,7 @@ export function buildNodeNetSocket(
       writeChain
         .then(() => {
           try {
-            cloudflareSocket.close?.();
+            cloudflareSocket?.close?.();
           } finally {
             callback();
           }
@@ -168,7 +175,7 @@ export function buildNodeNetSocket(
       closed = true;
       clearTimer();
       try {
-        cloudflareSocket.close?.();
+        cloudflareSocket?.close?.();
       } catch {
         // The stream is already being destroyed; surface the original error below.
       }
@@ -192,7 +199,7 @@ export function buildNodeNetSocket(
   };
 
   async function readLoop() {
-    const activeReader = reader ?? cloudflareSocket.readable.getReader();
+    const activeReader = reader ?? cloudflareSocket!.readable.getReader();
     reader = activeReader;
     try {
       while (!closed) {
@@ -226,19 +233,15 @@ export function buildNodeNetSocket(
     }
   }
 
-  if (cloudflareSocket.opened) {
-    cloudflareSocket.opened.then(
-      (info) => scheduleConnected(info),
-      (error) => stream.destroy(error instanceof Error ? error : new Error(String(error))),
-    );
-  } else {
-    queueMicrotask(() => scheduleConnected());
-  }
-  cloudflareSocket.closed?.finally(() => {
-    closed = true;
-    clearTimer();
-    endReadable();
-    releaseLocks();
+  socketReady.then(async (connectedSocket) => {
+    connectedSocket.closed?.finally(() => {
+      closed = true;
+      clearTimer();
+      endReadable();
+      releaseLocks();
+    }).catch((error) => stream.destroy(error instanceof Error ? error : new Error(String(error))));
+    const info = await connectedSocket.opened;
+    scheduleConnected(info);
   }).catch((error) => stream.destroy(error instanceof Error ? error : new Error(String(error))));
   return stream;
 }

package/lib/src/private-data-sources/oracle.ts

@@ -0,0 +1,34 @@
+import { createHash } from "node:crypto";
+
+import { privateDataSourceReference } from "./manifest";
+import { installPrivateNodeNetAdapter, registerPrivateNodeNetRoute } from "./node-net-adapter";
+import { buildTcpPrivateDataSource } from "./tcp";
+
+export function oracle(name: unknown) {
+  installPrivateNodeNetAdapter();
+  const entry = privateDataSourceReference(name, "oracle");
+  const source = buildTcpPrivateDataSource(entry);
+  // A numeric alias avoids Oracle's client-side DNS lookup of private hostnames.
+  const hash = createHash("sha256").update(String(entry.name)).digest("hex").slice(0, 28);
+  const driverHost = `fd44:${hash.match(/.{4}/g)!.join(":")}`;
+
+  const extension = {
+    oracledbOptions() {
+      const serviceName = source.database;
+      if (!serviceName || !/^[a-zA-Z0-9_.$#-]+$/.test(serviceName)) {
+        throw new Error("Enter an Oracle service name using letters, numbers, underscores, dots, $, #, or hyphens.");
+      }
+      const port = source.port!;
+      registerPrivateNodeNetRoute(driverHost, port, {
+        label: `Oracle private data source "${entry.name}"`,
+        connect: () => source.connect(),
+      });
+      return Object.freeze({
+        user: source.username,
+        password: source.password,
+        connectString: `(DESCRIPTION=(TRANSPORT_CONNECT_TIMEOUT=10)(CONNECT_TIMEOUT=15)(RETRY_COUNT=0)(ADDRESS=(PROTOCOL=TCP)(HOST=${driverHost})(PORT=${port}))(CONNECT_DATA=(SERVICE_NAME=${serviceName})(SERVER=DEDICATED)))`,
+      });
+    },
+  };
+  return Object.freeze(Object.defineProperties(extension, Object.getOwnPropertyDescriptors(source)) as typeof source & typeof extension);
+}

package/lib/src/shards/build.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Compile an app's functions into the final Cloudflare Workers shards.
+ *
+ * The loop is: plan the partition, compile each shard, measure it, and halve any
+ * shard whose module is over a ceiling before anything is uploaded. Ported from
+ * `_build_shard_with_split` in apper's `cloudflare_wfp_runtime.py`.
+ *
+ * That function also splits on two exceptions, and neither is a trigger here.
+ * The bundler's 413 is its HTTP request-body cap — a property of the shard's
+ * packed SOURCE going over the wire, not of the module coming out, and there is
+ * no request to reject locally. Cloudflare's 10027 is a real Worker limit, but
+ * it is the same 64 MiB `workerRawSizeBreach` already computes from the bytes in
+ * hand, so reaching it from a rejected upload is a failsafe, not the design.
+ * Measuring is the design, and it happens here.
+ *
+ * Unlike the compiler's own `bundleApp`, this refuses a partial result. A module
+ * missing a handler is not a smaller success, it is a broken app.
+ */
+import type { AppFunctionInput } from "../contracts.js";
+import type { BundleErrorItem } from "../errors.js";
+import { type ShardPolicy } from "./plan.js";
+export interface CompiledShard {
+    /** Position in the emitted list. Not a deployment identity — the caller owns
+     *  placement, and a split makes more shards than the plan had. */
+    index: number;
+    /** Function names in this shard, in the order they were compiled. */
+    functions: string[];
+    module: string;
+    mainModule: string;
+    rawBytes: number;
+    gzipBytes: number;
+}
+export interface ShardBuildFailure {
+    /** The function this is about, when it belongs to one. */
+    function?: string;
+    message: string;
+    errors?: BundleErrorItem[];
+}
+export type ShardBuildResult = {
+    ok: true;
+    shards: CompiledShard[];
+} | {
+    ok: false;
+    failures: ShardBuildFailure[];
+};
+/**
+ * Compile every function into shards, or fail the whole build.
+ *
+ * Succeeds only when each declared function appears exactly once across the
+ * shards and every one of them compiled.
+ */
+export declare function compileFunctionShards(functions: AppFunctionInput[], policy: ShardPolicy, options?: {
+    postResponseTelemetry?: boolean;
+    runtimeSecrets?: boolean;
+}): Promise<ShardBuildResult>;

package/lib/src/shards/build.js

@@ -0,0 +1,156 @@
+/**
+ * Compile an app's functions into the final Cloudflare Workers shards.
+ *
+ * The loop is: plan the partition, compile each shard, measure it, and halve any
+ * shard whose module is over a ceiling before anything is uploaded. Ported from
+ * `_build_shard_with_split` in apper's `cloudflare_wfp_runtime.py`.
+ *
+ * That function also splits on two exceptions, and neither is a trigger here.
+ * The bundler's 413 is its HTTP request-body cap — a property of the shard's
+ * packed SOURCE going over the wire, not of the module coming out, and there is
+ * no request to reject locally. Cloudflare's 10027 is a real Worker limit, but
+ * it is the same 64 MiB `workerRawSizeBreach` already computes from the bytes in
+ * hand, so reaching it from a rejected upload is a failsafe, not the design.
+ * Measuring is the design, and it happens here.
+ *
+ * Unlike the compiler's own `bundleApp`, this refuses a partial result. A module
+ * missing a handler is not a smaller success, it is a broken app.
+ */
+import { bundleApp } from "../bundler.js";
+import { planFreshShards } from "./plan.js";
+import { judgeBundleSize } from "./size.js";
+/** Shards compile independently; bound how many esbuild runs are in flight so
+ *  peak memory does not scale with the app's function count. */
+const MAX_PARALLEL_SHARDS = 4;
+/**
+ * Compile every function into shards, or fail the whole build.
+ *
+ * Succeeds only when each declared function appears exactly once across the
+ * shards and every one of them compiled.
+ */
+export async function compileFunctionShards(functions, policy, options = {}) {
+    const duplicate = firstDuplicate(functions.map((fn) => fn.name));
+    if (duplicate) {
+        return fail([{ message: `Duplicate function name "${duplicate}".` }]);
+    }
+    const byName = new Map(functions.map((fn) => [fn.name, fn]));
+    const plan = planFreshShards(functions.map((fn) => fn.name), policy);
+    const groups = plan.map((names) => names.map((name) => byName.get(name)));
+    const outcomes = await mapWithConcurrency(groups, MAX_PARALLEL_SHARDS, (group) => buildWithSplit(group, policy, options));
+    const failures = outcomes.flatMap((o) => (o.ok ? [] : o.failures));
+    if (failures.length > 0)
+        return fail(failures);
+    const shards = outcomes
+        .flatMap((o) => (o.ok ? o.shards : []))
+        .map((shard, index) => ({ ...shard, index }));
+    const missing = assertEveryFunctionPlacedOnce(functions, shards);
+    if (missing.length > 0)
+        return fail(missing);
+    return { ok: true, shards };
+}
+/** Compile one planned group, halving it when its module is over a ceiling. The
+ *  verdict comes from the bytes, so nothing is uploaded to discover it. */
+async function buildWithSplit(group, policy, options) {
+    const response = await bundleApp({ functions: group, ...options });
+    const compileFailures = response.functions
+        .filter((fn) => !fn.ok)
+        .map((fn) => ({
+        function: fn.name,
+        message: `Function "${fn.name}" failed to compile.`,
+        errors: fn.ok ? undefined : fn.errors,
+    }));
+    // A partial module is what the service ships and a whole-app build must not:
+    // the peers compiled, but the app is missing a handler.
+    if (compileFailures.length > 0)
+        return { ok: false, failures: compileFailures };
+    if (!response.ok) {
+        return fail([{ message: "The combined build produced no module." }]);
+    }
+    const verdict = await judgeBundleSize(response.module, policy.gzipCapBytes);
+    if (!verdict.breach) {
+        return {
+            ok: true,
+            shards: [shardOf(group, response.module, response.main_module, verdict)],
+        };
+    }
+    if (group.length === 1) {
+        // Splitting is exhausted: one function's module alone is over the ceiling.
+        return {
+            ok: false,
+            failures: [{ function: group[0].name, message: verdict.breach }],
+        };
+    }
+    const mid = Math.floor(group.length / 2);
+    const halves = await Promise.all([
+        buildWithSplit(group.slice(0, mid), policy, options),
+        buildWithSplit(group.slice(mid), policy, options),
+    ]);
+    const halfFailures = halves.flatMap((h) => (h.ok ? [] : h.failures));
+    if (halfFailures.length > 0)
+        return { ok: false, failures: halfFailures };
+    return { ok: true, shards: halves.flatMap((h) => (h.ok ? h.shards : [])) };
+}
+function shardOf(group, module, mainModule, verdict) {
+    return {
+        functions: group.map((fn) => fn.name),
+        module,
+        mainModule,
+        rawBytes: verdict.rawBytes,
+        gzipBytes: verdict.gzipBytes,
+    };
+}
+/** Every declared function must land in exactly one emitted shard. A name that
+ *  vanished, or turned up twice after a split, would deploy a broken app. */
+function assertEveryFunctionPlacedOnce(functions, shards) {
+    const placed = new Map();
+    for (const shard of shards) {
+        for (const name of shard.functions) {
+            placed.set(name, (placed.get(name) ?? 0) + 1);
+        }
+    }
+    const failures = [];
+    for (const fn of functions) {
+        const count = placed.get(fn.name) ?? 0;
+        if (count !== 1) {
+            failures.push({
+                function: fn.name,
+                message: `Function "${fn.name}" appears in ${count} shards; expected exactly 1.`,
+            });
+        }
+    }
+    for (const name of placed.keys()) {
+        if (!functions.some((fn) => fn.name === name)) {
+            failures.push({
+                function: name,
+                message: `Shard holds unknown function "${name}".`,
+            });
+        }
+    }
+    return failures;
+}
+function firstDuplicate(names) {
+    const seen = new Set();
+    for (const name of names) {
+        if (seen.has(name))
+            return name;
+        seen.add(name);
+    }
+    return null;
+}
+function fail(failures) {
+    return { ok: false, failures };
+}
+/** Bounded concurrency, input order preserved. */
+async function mapWithConcurrency(items, limit, fn) {
+    const results = new Array(items.length);
+    let cursor = 0;
+    const worker = async () => {
+        while (cursor < items.length) {
+            const index = cursor++;
+            results[index] = await fn(items[index]);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+    return results;
+}
+//# sourceMappingURL=build.js.map

package/lib/src/shards/build.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.js","sourceRoot":"","sources":["../../../src/shards/build.ts"],"names":[],"mappings":"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"}

package/lib/src/shards/plan.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Which functions go in which shard, for a build with no previous deploy to
+ * reuse. Ported from apper's `shard_planning.py` (`target_shard_count`,
+ * `full_repartition`) and the capacity refusal in `deploy_app`.
+ *
+ * Only the fresh path crosses over. Incremental reuse needs the previous
+ * deployment map, and the per-app shard-size ratchet is state written across
+ * deploys; both stay with the service.
+ */
+/** Everything the planner is allowed to know. It reads no settings and no
+ *  entitlements — the caller resolves these and passes them in. */
+export interface ShardPolicy {
+    /** Functions packed into one shard. May be lower than `globalShardSize` when
+     *  the caller carries a ratcheted override. */
+    shardSize: number;
+    /** The size capacity is judged at. A lowered `shardSize` changes packing only
+     *  and must never lock an app out of deploying. */
+    globalShardSize: number;
+    maxShards: number;
+    /** Compressed ceiling for one shard's module, in bytes. */
+    gzipCapBytes: number;
+}
+export declare class ShardCapacityError extends Error {
+    constructor(message: string);
+}
+/**
+ * How many shards the desired set needs. `maxShards === 1` — sharding off — is
+ * always one shard whatever the function count: the whole app bundles into a
+ * single Worker, which is the legacy per-app behaviour. Going through the
+ * division would trip the capacity check for a flag-off app.
+ */
+export declare function targetShardCount(functionCount: number, shardSize: number, maxShards: number): number;
+/**
+ * Refuse a set the product cannot hold. Judged at the GLOBAL shard size: a
+ * ratcheted-down `shardSize` affects packing only, so judging at it would lock
+ * a recovered app out of deploys. The resulting plan may therefore hold more
+ * shards than `maxShards` — bounded by the function count, which is no more
+ * Workers than the legacy per-function topology used. Do not "tidy" this into a
+ * check on the final shard count.
+ */
+export declare function assertWithinCapacity(functionCount: number, policy: ShardPolicy): void;
+/**
+ * The fresh partition, as a list of shards holding function names.
+ *
+ * A single planned shard keeps the caller's order; a multi-shard plan sorts by
+ * name before chunking. The two differ in apper and the difference is load
+ * bearing — function order inside a combined module changes the emitted bytes,
+ * so normalising them would be a byte change wearing a cleanup's clothes.
+ */
+export declare function planFreshShards(names: string[], policy: ShardPolicy): string[][];

package/lib/src/shards/plan.js

@@ -0,0 +1,78 @@
+/**
+ * Which functions go in which shard, for a build with no previous deploy to
+ * reuse. Ported from apper's `shard_planning.py` (`target_shard_count`,
+ * `full_repartition`) and the capacity refusal in `deploy_app`.
+ *
+ * Only the fresh path crosses over. Incremental reuse needs the previous
+ * deployment map, and the per-app shard-size ratchet is state written across
+ * deploys; both stay with the service.
+ */
+export class ShardCapacityError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ShardCapacityError";
+    }
+}
+/** The three counts have to be whole numbers of at least one. A zero or
+ *  negative `shardSize` made the chunking loop below never advance — it hung
+ *  rather than refusing, where the Python raises on the same input. */
+function assertUsablePolicy(policy) {
+    for (const field of ["shardSize", "globalShardSize", "maxShards"]) {
+        const value = policy[field];
+        if (!Number.isInteger(value) || value < 1) {
+            throw new Error(`ShardPolicy.${field} must be an integer of at least 1, got ${value}`);
+        }
+    }
+}
+function ceilDiv(a, b) {
+    return Math.ceil(a / b);
+}
+/**
+ * How many shards the desired set needs. `maxShards === 1` — sharding off — is
+ * always one shard whatever the function count: the whole app bundles into a
+ * single Worker, which is the legacy per-app behaviour. Going through the
+ * division would trip the capacity check for a flag-off app.
+ */
+export function targetShardCount(functionCount, shardSize, maxShards) {
+    if (maxShards === 1)
+        return 1;
+    return ceilDiv(functionCount, shardSize);
+}
+/**
+ * Refuse a set the product cannot hold. Judged at the GLOBAL shard size: a
+ * ratcheted-down `shardSize` affects packing only, so judging at it would lock
+ * a recovered app out of deploys. The resulting plan may therefore hold more
+ * shards than `maxShards` — bounded by the function count, which is no more
+ * Workers than the legacy per-function topology used. Do not "tidy" this into a
+ * check on the final shard count.
+ */
+export function assertWithinCapacity(functionCount, policy) {
+    const needed = targetShardCount(functionCount, policy.globalShardSize, policy.maxShards);
+    if (needed > policy.maxShards) {
+        throw new ShardCapacityError(`App has ${functionCount} functions — over the per-app Worker capacity of ` +
+            `${policy.globalShardSize * policy.maxShards} ` +
+            `(${policy.maxShards} shards × ${policy.globalShardSize}).`);
+    }
+}
+/**
+ * The fresh partition, as a list of shards holding function names.
+ *
+ * A single planned shard keeps the caller's order; a multi-shard plan sorts by
+ * name before chunking. The two differ in apper and the difference is load
+ * bearing — function order inside a combined module changes the emitted bytes,
+ * so normalising them would be a byte change wearing a cleanup's clothes.
+ */
+export function planFreshShards(names, policy) {
+    assertUsablePolicy(policy);
+    assertWithinCapacity(names.length, policy);
+    const target = targetShardCount(names.length, policy.shardSize, policy.maxShards);
+    if (target <= 1)
+        return [[...names]];
+    const sorted = [...names].sort();
+    const shards = [];
+    for (let i = 0; i < sorted.length; i += policy.shardSize) {
+        shards.push(sorted.slice(i, i + policy.shardSize));
+    }
+    return shards;
+}
+//# sourceMappingURL=plan.js.map

package/lib/src/shards/plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.js","sourceRoot":"","sources":["../../../src/shards/plan.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAgBH,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AAED;;uEAEuE;AACvE,SAAS,kBAAkB,CAAC,MAAmB;IAC7C,KAAK,MAAM,KAAK,IAAI,CAAC,WAAW,EAAE,iBAAiB,EAAE,WAAW,CAAU,EAAE,CAAC;QAC3E,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YAC1C,MAAM,IAAI,KAAK,CACb,eAAe,KAAK,0CAA0C,KAAK,EAAE,CACtE,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC;AAED,SAAS,OAAO,CAAC,CAAS,EAAE,CAAS;IACnC,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAC1B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAC9B,aAAqB,EACrB,SAAiB,EACjB,SAAiB;IAEjB,IAAI,SAAS,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAC9B,OAAO,OAAO,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,oBAAoB,CAClC,aAAqB,EACrB,MAAmB;IAEnB,MAAM,MAAM,GAAG,gBAAgB,CAC7B,aAAa,EACb,MAAM,CAAC,eAAe,EACtB,MAAM,CAAC,SAAS,CACjB,CAAC;IACF,IAAI,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;QAC9B,MAAM,IAAI,kBAAkB,CAC1B,WAAW,aAAa,mDAAmD;YACzE,GAAG,MAAM,CAAC,eAAe,GAAG,MAAM,CAAC,SAAS,GAAG;YAC/C,IAAI,MAAM,CAAC,SAAS,aAAa,MAAM,CAAC,eAAe,IAAI,CAC9D,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAC7B,KAAe,EACf,MAAmB;IAEnB,kBAAkB,CAAC,MAAM,CAAC,CAAC;IAC3B,oBAAoB,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE3C,MAAM,MAAM,GAAG,gBAAgB,CAC7B,KAAK,CAAC,MAAM,EACZ,MAAM,CAAC,SAAS,EAChB,MAAM,CAAC,SAAS,CACjB,CAAC;IACF,IAAI,MAAM,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;IAErC,MAAM,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC;IACjC,MAAM,MAAM,GAAe,EAAE,CAAC;IAC9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;QACzD,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/lib/src/shards/size.d.ts

@@ -0,0 +1,45 @@
+/**
+ * How large a compiled Worker module is, and whether Cloudflare will take it.
+ *
+ * Ported from apper's `cloudflare_wfp_runtime.py` (`measure_bundle_bytes`,
+ * `worker_raw_size_breach`, `worker_gzip_cap_breach`, `judge_bundle_size`).
+ * Deciding this before an upload is the whole point: the one real production
+ * rejection spent 30 seconds uploading 97 MB to be told the same thing this
+ * computes for free.
+ */
+/** zlib's default, and the level `wrangler --dry-run` reports — so the number
+ *  here means the same thing as the one in Cloudflare's docs, in a support
+ *  thread and on a developer's terminal. It is not a claim about Cloudflare's
+ *  own server-side compressor, which is unpublished; the safety margin lives in
+ *  the cap instead. */
+export declare const BUNDLE_GZIP_LEVEL = 6;
+/** Cloudflare's uncompressed per-Worker ceiling, in the units Cloudflare states
+ *  it in. Taken from a real 10027 in production, which reads verbatim: "Your
+ *  Worker exceeded the uncompressed size limit of 64 MiB." Decimal 64_000_000
+ *  would refuse 3 MiB early for no reason. */
+export declare const WORKER_RAW_SIZE_CEILING_BYTES: number;
+export interface BundleSize {
+    rawBytes: number;
+    gzipBytes: number;
+}
+export interface SizeVerdict extends BundleSize {
+    /** Why the module is over a ceiling, or `null` when it is within both. */
+    breach: string | null;
+}
+/** `(raw, gzip)` for a compiled module. Compression runs off the event loop:
+ *  a multi-megabyte gzip is long enough to matter when several shards are in
+ *  flight. */
+export declare function measureBundleBytes(module: string): Promise<BundleSize>;
+/** Why Cloudflare will reject this module outright, or `null`. The only verdict
+ *  taken on a number Cloudflare states itself — no estimate, no compression, no
+ *  headroom to argue about. */
+export declare function workerRawSizeBreach(rawBytes: number): string | null;
+/** Why the module is over the compressed ceiling, or `null`. Our side of the
+ *  comparison is the estimate, not Cloudflare's number: it compresses
+ *  server-side with an unpublished algorithm, so level-6 gzip is a proxy for
+ *  the figure it measures. The cap carries the margin. */
+export declare function workerGzipCapBreach(gzipBytes: number, gzipCapBytes: number): string | null;
+/** Measure a module and say whether it breaches either ceiling. Never throws:
+ *  what a breach costs depends on whether the caller can re-partition, and only
+ *  the caller knows that. */
+export declare function judgeBundleSize(module: string, gzipCapBytes: number): Promise<SizeVerdict>;

package/lib/src/shards/size.js

@@ -0,0 +1,64 @@
+/**
+ * How large a compiled Worker module is, and whether Cloudflare will take it.
+ *
+ * Ported from apper's `cloudflare_wfp_runtime.py` (`measure_bundle_bytes`,
+ * `worker_raw_size_breach`, `worker_gzip_cap_breach`, `judge_bundle_size`).
+ * Deciding this before an upload is the whole point: the one real production
+ * rejection spent 30 seconds uploading 97 MB to be told the same thing this
+ * computes for free.
+ */
+import { promisify } from "node:util";
+import { gzip } from "node:zlib";
+const gzipAsync = promisify(gzip);
+/** zlib's default, and the level `wrangler --dry-run` reports — so the number
+ *  here means the same thing as the one in Cloudflare's docs, in a support
+ *  thread and on a developer's terminal. It is not a claim about Cloudflare's
+ *  own server-side compressor, which is unpublished; the safety margin lives in
+ *  the cap instead. */
+export const BUNDLE_GZIP_LEVEL = 6;
+/** Cloudflare's uncompressed per-Worker ceiling, in the units Cloudflare states
+ *  it in. Taken from a real 10027 in production, which reads verbatim: "Your
+ *  Worker exceeded the uncompressed size limit of 64 MiB." Decimal 64_000_000
+ *  would refuse 3 MiB early for no reason. */
+export const WORKER_RAW_SIZE_CEILING_BYTES = 64 * 1024 * 1024;
+/** `(raw, gzip)` for a compiled module. Compression runs off the event loop:
+ *  a multi-megabyte gzip is long enough to matter when several shards are in
+ *  flight. */
+export async function measureBundleBytes(module) {
+    const raw = Buffer.from(module, "utf8");
+    const compressed = await gzipAsync(raw, { level: BUNDLE_GZIP_LEVEL });
+    return { rawBytes: raw.byteLength, gzipBytes: compressed.byteLength };
+}
+/** Why Cloudflare will reject this module outright, or `null`. The only verdict
+ *  taken on a number Cloudflare states itself — no estimate, no compression, no
+ *  headroom to argue about. */
+export function workerRawSizeBreach(rawBytes) {
+    if (rawBytes > WORKER_RAW_SIZE_CEILING_BYTES) {
+        return (`bundled module is ${rawBytes} bytes uncompressed, over Cloudflare's ` +
+            `${WORKER_RAW_SIZE_CEILING_BYTES}-byte (64 MiB) per-Worker ceiling`);
+    }
+    return null;
+}
+/** Why the module is over the compressed ceiling, or `null`. Our side of the
+ *  comparison is the estimate, not Cloudflare's number: it compresses
+ *  server-side with an unpublished algorithm, so level-6 gzip is a proxy for
+ *  the figure it measures. The cap carries the margin. */
+export function workerGzipCapBreach(gzipBytes, gzipCapBytes) {
+    if (gzipBytes > gzipCapBytes) {
+        return (`bundled module is ${gzipBytes} bytes gzipped (level ${BUNDLE_GZIP_LEVEL}), ` +
+            `over the ${gzipCapBytes}-byte cap for a Cloudflare Worker script`);
+    }
+    return null;
+}
+/** Measure a module and say whether it breaches either ceiling. Never throws:
+ *  what a breach costs depends on whether the caller can re-partition, and only
+ *  the caller knows that. */
+export async function judgeBundleSize(module, gzipCapBytes) {
+    const { rawBytes, gzipBytes } = await measureBundleBytes(module);
+    // Uncompressed first: it is the exact one, so when both are over it is the
+    // verdict worth reporting.
+    const breach = workerRawSizeBreach(rawBytes) ??
+        workerGzipCapBreach(gzipBytes, gzipCapBytes);
+    return { rawBytes, gzipBytes, breach };
+}
+//# sourceMappingURL=size.js.map

package/lib/src/shards/size.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"size.js","sourceRoot":"","sources":["../../../src/shards/size.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,MAAM,SAAS,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;AAElC;;;;uBAIuB;AACvB,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC;AAEnC;;;8CAG8C;AAC9C,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AAY9D;;cAEc;AACd,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,MAAc;IACrD,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,MAAM,UAAU,GAAG,MAAM,SAAS,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC,CAAC;IACtE,OAAO,EAAE,QAAQ,EAAE,GAAG,CAAC,UAAU,EAAE,SAAS,EAAE,UAAU,CAAC,UAAU,EAAE,CAAC;AACxE,CAAC;AAED;;+BAE+B;AAC/B,MAAM,UAAU,mBAAmB,CAAC,QAAgB;IAClD,IAAI,QAAQ,GAAG,6BAA6B,EAAE,CAAC;QAC7C,OAAO,CACL,qBAAqB,QAAQ,yCAAyC;YACtE,GAAG,6BAA6B,mCAAmC,CACpE,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;0DAG0D;AAC1D,MAAM,UAAU,mBAAmB,CACjC,SAAiB,EACjB,YAAoB;IAEpB,IAAI,SAAS,GAAG,YAAY,EAAE,CAAC;QAC7B,OAAO,CACL,qBAAqB,SAAS,yBAAyB,iBAAiB,KAAK;YAC7E,YAAY,YAAY,0CAA0C,CACnE,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;6BAE6B;AAC7B,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,MAAc,EACd,YAAoB;IAEpB,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,MAAM,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACjE,2EAA2E;IAC3E,2BAA2B;IAC3B,MAAM,MAAM,GACV,mBAAmB,CAAC,QAAQ,CAAC;QAC7B,mBAAmB,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;IAC/C,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC;AACzC,CAAC"}

package/lib/src/version.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This package's version, as a literal.
+ *
+ * It goes into every compiled shard's banner, which means it is part of the
+ * emitted bytes and therefore part of a deployed version's identity. Reading it
+ * from `package.json` at runtime cannot work: a host that bundles this module
+ * into an artifact of its own — which the CLI does — ships no `package.json`
+ * beside it, and the read silently degraded to "unknown", so the same functions
+ * compiled to different bytes in the CLI and in the service.
+ *
+ * A literal resolves in every host. `version.test.ts` fails the build if it
+ * drifts from `package.json`, so bumping the package still means editing two
+ * files but cannot mean forgetting one.
+ */
+export declare const COMPILER_VERSION = "0.1.4";

package/lib/src/version.js

@@ -0,0 +1,16 @@
+/**
+ * This package's version, as a literal.
+ *
+ * It goes into every compiled shard's banner, which means it is part of the
+ * emitted bytes and therefore part of a deployed version's identity. Reading it
+ * from `package.json` at runtime cannot work: a host that bundles this module
+ * into an artifact of its own — which the CLI does — ships no `package.json`
+ * beside it, and the read silently degraded to "unknown", so the same functions
+ * compiled to different bytes in the CLI and in the service.
+ *
+ * A literal resolves in every host. `version.test.ts` fails the build if it
+ * drifts from `package.json`, so bumping the package still means editing two
+ * files but cannot mean forgetting one.
+ */
+export const COMPILER_VERSION = "0.1.4";
+//# sourceMappingURL=version.js.map

package/lib/src/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAC"}