@selvajs/server 0.2.0-beta.1

package/dist/compute/client-cache.js

@@ -0,0 +1,147 @@
+import { GrasshopperClient, enableDebugLogging } from '@selvajs/compute';
+/** Derive the opaque cache identity from a resolved server. Identity is the `id`. */
+export function serverIdentity(server) {
+    return server.id;
+}
+const DEFAULT_MAX_CACHED_CLIENTS = 16;
+/**
+ * Build a per-server warm-client cache. Each cache owns its own LRU `Map` keyed
+ * on server `id`.
+ */
+export function createClientCache(config) {
+    const maxCachedClients = config.maxCachedClients ?? DEFAULT_MAX_CACHED_CLIENTS;
+    const cache = new Map();
+    if (config.debugVerbose)
+        enableDebugLogging();
+    const debugLog = (message) => {
+        if (config.debug)
+            config.onDebugLog?.(message);
+    };
+    async function build(server, definitionGuid) {
+        // Holders for per-request results from the client/scheduler callbacks; the
+        // caller reads them right after each solve resolves to build Server-Timing.
+        const rhinoTiming = { last: null };
+        const solveMeta = { last: null };
+        const clientConfig = {
+            serverUrl: server.serverUrl,
+            apiKey: server.apiKey,
+            // Lib-level debug is the verbose one (full payload logs); keep it on the
+            // verbose flag so the concise cache logs can run without the noise.
+            debug: config.debugVerbose,
+            // Ask Rhino.Compute to cache solve results and return them on identical
+            // repeats (same definition + inputs), skipping the solve.
+            cachesolve: config.cachesolve,
+            // Opt-in: also cache solves that reported GH errors.
+            cacheerroredsolves: config.cacheerroredsolves,
+            // DEBUG: the server's per-request timing breakdown, which exposes the two
+            // SERVER-side caches at once — definition cache (pointer reuse) via
+            // `decode`, solve cache (cachesolve) via `solve`. Flagged below so the
+            // contrast is obvious in the logs.
+            onServerTiming: (t) => {
+                const decode = t.decode ?? 0;
+                const solve = t.solve ?? 0;
+                const encode = t.encode ?? 0;
+                // Always recorded (cheap): the caller reads this after scheduler.solve.
+                rhinoTiming.last = { decode, solve, encode };
+                if (!config.debug)
+                    return;
+                // Heuristic thresholds: a genuine parse/solve is many ms; a cache hit
+                // is sub-millisecond. Only meaningful relative to the first (cold) solve.
+                const defCache = decode <= 1 ? 'HIT (definition reused, no re-upload/parse)' : 'miss (full parse)';
+                const solveCache = config.cachesolve && solve <= 1
+                    ? 'HIT (cached result, solve skipped)'
+                    : config.cachesolve
+                        ? 'miss (solved fresh)'
+                        : 'off';
+                debugLog(`[Compute/rhino-cache] decode=${decode}ms solve=${solve}ms encode=${encode}ms ` +
+                    `| definition-cache: ${defCache} | solve-cache (cachesolve): ${solveCache}`);
+            }
+        };
+        // `X-Selva-Definition` on the wire (ADR 0004 D2). Baked at client-create
+        // time because the scheduler has no per-request header hook — inert for a
+        // single-member "pool", useful in compute-side access logs immediately.
+        if (definitionGuid) {
+            clientConfig.headers = { 'X-Selva-Definition': definitionGuid };
+        }
+        const client = await GrasshopperClient.create(clientConfig);
+        const scheduler = client.createScheduler({
+            mode: 'queue',
+            timeoutMs: config.maxSolveDurationMs,
+            cache: { maxEntries: 20, ttlMs: 5 * 60_000 },
+            // Solve large definitions by server cache-key (pointer) instead of
+            // re-uploading the full binary every solve. On a stale-pointer miss the
+            // client transparently re-uploads.
+            reuseServerDefinitionCache: config.reuseServerDefinitionCache,
+            // DEBUG: observe the in-process response cache. `fromCache === true` means
+            // this solve was served from the app's own cache — Rhino.Compute was never
+            // called. `false` means it went to the compute server.
+            onSettle: (_ctx, result) => {
+                if (result.status !== 'success')
+                    return;
+                // Always recorded (cheap): the caller surfaces these on Server-Timing.
+                solveMeta.last = {
+                    fromCache: result.fromCache === true,
+                    definitionReuploaded: result.definitionReuploaded
+                };
+                if (!config.debug)
+                    return;
+                debugLog(`[Compute/selva-cache] ${result.fromCache ? 'HIT  — served from cache (no compute call)' : 'miss — went to Rhino.Compute'} (${Math.round(result.durationMs)}ms)`);
+                // Definition-cache verdict for a real compute call (not a cache HIT).
+                if (!result.fromCache) {
+                    debugLog(result.definitionReuploaded === true
+                        ? '[Compute/def-cache] miss — definition RE-UPLOADED (pointer was cold/stale)'
+                        : result.definitionReuploaded === false
+                            ? '[Compute/def-cache] HIT  — definition reused from server cache (no upload)'
+                            : '[Compute/def-cache] n/a — reuse disabled or non-reusable definition');
+                }
+                // Surface real GH errors when present. An errored solve is NEVER cached
+                // server-side (cachesolve only stores error-free solves).
+                if (!result.fromCache) {
+                    const errs = result.response?.errors;
+                    const errCount = Array.isArray(errs) ? errs.length : 0;
+                    if (errCount > 0) {
+                        debugLog(`[Compute/rhino-cache] ${errCount} GH error(s); not cacheable until fixed. First: ${JSON.stringify(errs[0])}`);
+                    }
+                }
+            }
+        });
+        return { client, scheduler, rhinoTiming, solveMeta };
+    }
+    return {
+        async getClient(server, opts) {
+            const key = server.id;
+            const existing = cache.get(key);
+            if (existing) {
+                // Refresh LRU position.
+                cache.delete(key);
+                cache.set(key, existing);
+                return existing;
+            }
+            const entry = await build(server, opts?.definitionGuid);
+            // Evict the least-recently-used entry before inserting when at capacity.
+            if (cache.size >= maxCachedClients) {
+                const oldestKey = cache.keys().next().value;
+                if (oldestKey !== undefined) {
+                    cache.get(oldestKey)?.scheduler.dispose();
+                    cache.delete(oldestKey);
+                }
+            }
+            cache.set(key, entry);
+            return entry;
+        },
+        evict(id) {
+            const key = id;
+            const entry = cache.get(key);
+            if (entry) {
+                entry.scheduler.dispose();
+                cache.delete(key);
+            }
+        },
+        disposeAll() {
+            for (const entry of cache.values())
+                entry.scheduler.dispose();
+            cache.clear();
+        }
+    };
+}
+//# sourceMappingURL=client-cache.js.map

package/dist/compute/client-cache.js.map

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

package/dist/compute/index.d.ts

@@ -0,0 +1,8 @@
+export { resolveComputeLimits, readPositiveInt, readBool, type ComputeLimits, type EnvRecord } from './limits.js';
+export { createComputeRateLimiter, type ComputeRateLimiter, type ComputeRateLimiterConfig, type RateLimitResult } from './rate-limit.js';
+export { isSafeRemoteDefinitionUrl, assertSafeRemoteDefinitionUrl } from './safe-url.js';
+export { transformInputParameter } from './transform-input.js';
+export { createClientCache, serverIdentity, type ClientCache, type ClientCacheConfig, type CachedClient, type ResolvedServer, type ServerIdentity } from './client-cache.js';
+export { createRemoteDefinitionFetcher, readBodyWithCap, type RemoteDefinitionFetcher, type RemoteDefinitionConfig } from './remote-definition.js';
+export { runSolvePipeline, COMPUTE_CONTRACT_VERSION, COMPUTE_VERSION_HEADER, type SolvePipelineArgs, type SolveOutcome, type SolveEnvelope, type SolvePhaseMetrics, type PipelineInput } from './solve-pipeline.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/compute/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compute/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACN,oBAAoB,EACpB,eAAe,EACf,QAAQ,EACR,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,MAAM,aAAa,CAAC;AAErB,OAAO,EACN,wBAAwB,EACxB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,eAAe,EACpB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,yBAAyB,EAAE,6BAA6B,EAAE,MAAM,eAAe,CAAC;AAEzF,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,OAAO,EACN,iBAAiB,EACjB,cAAc,EACd,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACN,6BAA6B,EAC7B,eAAe,EACf,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACN,gBAAgB,EAChB,wBAAwB,EACxB,sBAAsB,EACtB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,MAAM,qBAAqB,CAAC"}

package/dist/compute/index.js

@@ -0,0 +1,9 @@
+// Compute/solve server building blocks — transport-agnostic, env-injected.
+export { resolveComputeLimits, readPositiveInt, readBool } from './limits.js';
+export { createComputeRateLimiter } from './rate-limit.js';
+export { isSafeRemoteDefinitionUrl, assertSafeRemoteDefinitionUrl } from './safe-url.js';
+export { transformInputParameter } from './transform-input.js';
+export { createClientCache, serverIdentity } from './client-cache.js';
+export { createRemoteDefinitionFetcher, readBodyWithCap } from './remote-definition.js';
+export { runSolvePipeline, COMPUTE_CONTRACT_VERSION, COMPUTE_VERSION_HEADER } from './solve-pipeline.js';
+//# sourceMappingURL=index.js.map

package/dist/compute/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/compute/index.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAE3E,OAAO,EACN,oBAAoB,EACpB,eAAe,EACf,QAAQ,EAGR,MAAM,aAAa,CAAC;AAErB,OAAO,EACN,wBAAwB,EAIxB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,yBAAyB,EAAE,6BAA6B,EAAE,MAAM,eAAe,CAAC;AAEzF,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,OAAO,EACN,iBAAiB,EACjB,cAAc,EAMd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACN,6BAA6B,EAC7B,eAAe,EAGf,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACN,gBAAgB,EAChB,wBAAwB,EACxB,sBAAsB,EAMtB,MAAM,qBAAqB,CAAC"}

package/dist/compute/limits.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Compute/solve server limits, resolved from an injected env map.
+ *
+ * This is the transport- and framework-agnostic core: it takes a plain
+ * `Record<string, string | undefined>` (the caller passes SvelteKit's
+ * `$env/dynamic/private`, `process.env`, or any config source) and returns a
+ * fully-resolved `ComputeLimits` object. No ambient `$env` / `process.env`
+ * read happens here, so the module is importable from any runtime and testable
+ * without env plumbing.
+ *
+ * Every knob is env-overridable so deployments can tune without code changes;
+ * the defaults are sized for typical interactive use (sliders + small uploads).
+ * Centralizing them surfaces the tradeoffs (raise the rate cap → also consider
+ * the body cap) at one glance.
+ *
+ * Client-side counterparts (the in-flight compute throttle and slider debounce)
+ * live in `@selvajs/ui` and are bundled into the client, so they can't read
+ * env — they carry their own defaults.
+ */
+/** Env source: any string→string map. `$env/dynamic/private` satisfies this. */
+export type EnvRecord = Record<string, string | undefined>;
+/**
+ * Parse a positive integer env value. Returns `fallback` when absent, and warns
+ * + falls back when present but not a finite positive number.
+ */
+export declare function readPositiveInt(env: EnvRecord, name: string, fallback: number): number;
+/**
+ * Parse a boolean env flag. Accepts `true/1/yes/on` (case-insensitive) as true
+ * and `false/0/no/off` as false; any other / absent value falls back.
+ */
+export declare function readBool(env: EnvRecord, name: string, fallback: boolean): boolean;
+/** Fully-resolved server-side compute limits. */
+export interface ComputeLimits {
+    /**
+     * Longest the app waits for one solve. Enforced by the SolveScheduler
+     * (`@selvajs/compute`), which propagates AbortSignal into the upstream
+     * Compute call — a timeout actually cancels the work. Forwarded to the
+     * client to drive the in-browser AbortController.
+     *
+     * Caveat: bounds only the parts of the stack we own. A reverse proxy or
+     * serverless platform cap may shoot the request sooner; bumping past those
+     * caps produces 502s, not longer solves.
+     */
+    maxSolveDurationMs: number;
+    /** Fixed-window cap on /api/compute: window length + max requests per window. */
+    rateLimitWindowMs: number;
+    rateLimitMaxRequests: number;
+    /**
+     * Largest .gh definition accepted on upload AND the largest remote definition
+     * fetched for compute — kept in lockstep so a remote URL can't smuggle a file
+     * past the upload cap.
+     */
+    maxGhFileSize: number;
+    maxImageFileSize: number;
+    /**
+     * /api/compute JSON *request* body cap (inputs + values, not the .gh). A
+     * `file`-widget input embeds geometry as base64 in `values`; must stay <=
+     * the adapter-node global BODY_SIZE_LIMIT or the global backstop rejects first.
+     */
+    computeRequestMaxBytes: number;
+    /**
+     * /api/compute JSON *response* cap. A `file`-typed output is base64-embedded
+     * in the response; guards V8's ~512 MB single-string wall (a `JSON.stringify`
+     * `RangeError`) and browser-tab OOM. Defensive backstop → clear 413 instead of
+     * an opaque crash (real fix is out-of-band streaming, ADR 0003).
+     */
+    computeResponseMaxBytes: number;
+    /** Hard cap on fetching a remote definition — tracks `maxGhFileSize`. */
+    remoteDefinitionMaxBytes: number;
+    /** Deadline on fetching a remote definition (slow-loris protection). */
+    remoteDefinitionFetchTimeoutMs: number;
+    /** In-process cache TTL for remote-fetched .gh bytes. */
+    definitionCacheTtlMs: number;
+    /**
+     * Reuse the server's cached definition via a pointer instead of re-uploading
+     * the binary each solve. SAFE only on a compute server that signals a
+     * stale-pointer miss (VektorNode fork / a fork that throws) — a server that
+     * returns an empty 200 would silently yield EMPTY geometry. Off for unknown
+     * / standard rhino.compute.
+     */
+    computeReuseDefinitionCache: boolean;
+    /**
+     * Ask Rhino.Compute to cache solve RESULTS keyed on the full request and
+     * return a cached result on an identical repeat. Server-wide (survives Selva
+     * restarts, spans instances). Only helps IDENTICAL re-solves.
+     */
+    computeServerCachesolve: boolean;
+    /**
+     * Also cache solves that reported Grasshopper errors — correct for
+     * error-by-design definitions (guarded Python, pruned branches) that still
+     * produce valid geometry. Requires `computeServerCachesolve` and a server
+     * honoring the flag. Conservative default off.
+     */
+    computeCacheErroredSolves: boolean;
+}
+/**
+ * Resolve every server-side compute limit from an env map. Pure: the same env
+ * always yields the same limits, and nothing is read ambiently. The app calls
+ * this once at its composition root with `$env/dynamic/private`.
+ */
+export declare function resolveComputeLimits(env: EnvRecord): ComputeLimits;
+//# sourceMappingURL=limits.d.ts.map

package/dist/compute/limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../../src/compute/limits.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,gFAAgF;AAChF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;AAE3D;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAStF;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAQjF;AAED,iDAAiD;AACjD,MAAM,WAAW,aAAa;IAC7B;;;;;;;;;OASG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iFAAiF;IACjF,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oBAAoB,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,sBAAsB,EAAE,MAAM,CAAC;IAC/B;;;;;OAKG;IACH,uBAAuB,EAAE,MAAM,CAAC;IAChC,yEAAyE;IACzE,wBAAwB,EAAE,MAAM,CAAC;IACjC,wEAAwE;IACxE,8BAA8B,EAAE,MAAM,CAAC;IACvC,yDAAyD;IACzD,oBAAoB,EAAE,MAAM,CAAC;IAC7B;;;;;;OAMG;IACH,2BAA2B,EAAE,OAAO,CAAC;IACrC;;;;OAIG;IACH,uBAAuB,EAAE,OAAO,CAAC;IACjC;;;;;OAKG;IACH,yBAAyB,EAAE,OAAO,CAAC;CACnC;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,SAAS,GAAG,aAAa,CAsBlE"}

package/dist/compute/limits.js

@@ -0,0 +1,76 @@
+/**
+ * Compute/solve server limits, resolved from an injected env map.
+ *
+ * This is the transport- and framework-agnostic core: it takes a plain
+ * `Record<string, string | undefined>` (the caller passes SvelteKit's
+ * `$env/dynamic/private`, `process.env`, or any config source) and returns a
+ * fully-resolved `ComputeLimits` object. No ambient `$env` / `process.env`
+ * read happens here, so the module is importable from any runtime and testable
+ * without env plumbing.
+ *
+ * Every knob is env-overridable so deployments can tune without code changes;
+ * the defaults are sized for typical interactive use (sliders + small uploads).
+ * Centralizing them surfaces the tradeoffs (raise the rate cap → also consider
+ * the body cap) at one glance.
+ *
+ * Client-side counterparts (the in-flight compute throttle and slider debounce)
+ * live in `@selvajs/ui` and are bundled into the client, so they can't read
+ * env — they carry their own defaults.
+ */
+const MB = 1024 * 1024;
+/**
+ * Parse a positive integer env value. Returns `fallback` when absent, and warns
+ * + falls back when present but not a finite positive number.
+ */
+export function readPositiveInt(env, name, fallback) {
+    const raw = env[name];
+    if (!raw)
+        return fallback;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        console.warn(`[selva] Invalid ${name}=${raw}, falling back to ${fallback}`);
+        return fallback;
+    }
+    return Math.floor(parsed);
+}
+/**
+ * Parse a boolean env flag. Accepts `true/1/yes/on` (case-insensitive) as true
+ * and `false/0/no/off` as false; any other / absent value falls back.
+ */
+export function readBool(env, name, fallback) {
+    const raw = env[name];
+    if (raw == null || raw === '')
+        return fallback;
+    const v = raw.trim().toLowerCase();
+    if (v === 'true' || v === '1' || v === 'yes' || v === 'on')
+        return true;
+    if (v === 'false' || v === '0' || v === 'no' || v === 'off')
+        return false;
+    console.warn(`[selva] Invalid ${name}=${raw}, falling back to ${fallback}`);
+    return fallback;
+}
+/**
+ * Resolve every server-side compute limit from an env map. Pure: the same env
+ * always yields the same limits, and nothing is read ambiently. The app calls
+ * this once at its composition root with `$env/dynamic/private`.
+ */
+export function resolveComputeLimits(env) {
+    const maxGhFileSize = readPositiveInt(env, 'MAX_GH_FILE_SIZE_BYTES', 300 * MB);
+    return {
+        maxSolveDurationMs: readPositiveInt(env, 'MAX_SOLVE_DURATION_MS', 100_000),
+        rateLimitWindowMs: readPositiveInt(env, 'COMPUTE_RATE_LIMIT_WINDOW_MS', 100_000),
+        rateLimitMaxRequests: readPositiveInt(env, 'COMPUTE_RATE_LIMIT_MAX', 120),
+        maxGhFileSize,
+        maxImageFileSize: readPositiveInt(env, 'MAX_IMAGE_FILE_SIZE_BYTES', 10 * MB),
+        computeRequestMaxBytes: readPositiveInt(env, 'COMPUTE_REQUEST_MAX_BYTES', 300 * MB),
+        computeResponseMaxBytes: readPositiveInt(env, 'COMPUTE_RESPONSE_MAX_BYTES', 300 * MB),
+        // Tracks the upload cap so a remote URL can't smuggle a larger file.
+        remoteDefinitionMaxBytes: maxGhFileSize,
+        remoteDefinitionFetchTimeoutMs: readPositiveInt(env, 'REMOTE_DEFINITION_FETCH_TIMEOUT_MS', 30_000),
+        definitionCacheTtlMs: readPositiveInt(env, 'DEFINITION_CACHE_TTL_MS', 5 * 60 * 1000),
+        computeReuseDefinitionCache: readBool(env, 'COMPUTE_REUSE_DEFINITION_CACHE', true),
+        computeServerCachesolve: readBool(env, 'COMPUTE_SERVER_CACHESOLVE', true),
+        computeCacheErroredSolves: readBool(env, 'COMPUTE_CACHE_ERRORED_SOLVES', false)
+    };
+}
+//# sourceMappingURL=limits.js.map

package/dist/compute/limits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"limits.js","sourceRoot":"","sources":["../../src/compute/limits.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AAKvB;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,GAAc,EAAE,IAAY,EAAE,QAAgB;IAC7E,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;IACtB,IAAI,CAAC,GAAG;QAAE,OAAO,QAAQ,CAAC;IAC1B,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAC3B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC,EAAE,CAAC;QAC7C,OAAO,CAAC,IAAI,CAAC,mBAAmB,IAAI,IAAI,GAAG,qBAAqB,QAAQ,EAAE,CAAC,CAAC;QAC5E,OAAO,QAAQ,CAAC;IACjB,CAAC;IACD,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;AAC3B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,QAAQ,CAAC,GAAc,EAAE,IAAY,EAAE,QAAiB;IACvE,MAAM,GAAG,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;IACtB,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,KAAK,EAAE;QAAE,OAAO,QAAQ,CAAC;IAC/C,MAAM,CAAC,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IACnC,IAAI,CAAC,KAAK,MAAM,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACxE,IAAI,CAAC,KAAK,OAAO,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,KAAK;QAAE,OAAO,KAAK,CAAC;IAC1E,OAAO,CAAC,IAAI,CAAC,mBAAmB,IAAI,IAAI,GAAG,qBAAqB,QAAQ,EAAE,CAAC,CAAC;IAC5E,OAAO,QAAQ,CAAC;AACjB,CAAC;AAmED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAc;IAClD,MAAM,aAAa,GAAG,eAAe,CAAC,GAAG,EAAE,wBAAwB,EAAE,GAAG,GAAG,EAAE,CAAC,CAAC;IAC/E,OAAO;QACN,kBAAkB,EAAE,eAAe,CAAC,GAAG,EAAE,uBAAuB,EAAE,OAAO,CAAC;QAC1E,iBAAiB,EAAE,eAAe,CAAC,GAAG,EAAE,8BAA8B,EAAE,OAAO,CAAC;QAChF,oBAAoB,EAAE,eAAe,CAAC,GAAG,EAAE,wBAAwB,EAAE,GAAG,CAAC;QACzE,aAAa;QACb,gBAAgB,EAAE,eAAe,CAAC,GAAG,EAAE,2BAA2B,EAAE,EAAE,GAAG,EAAE,CAAC;QAC5E,sBAAsB,EAAE,eAAe,CAAC,GAAG,EAAE,2BAA2B,EAAE,GAAG,GAAG,EAAE,CAAC;QACnF,uBAAuB,EAAE,eAAe,CAAC,GAAG,EAAE,4BAA4B,EAAE,GAAG,GAAG,EAAE,CAAC;QACrF,qEAAqE;QACrE,wBAAwB,EAAE,aAAa;QACvC,8BAA8B,EAAE,eAAe,CAC9C,GAAG,EACH,oCAAoC,EACpC,MAAM,CACN;QACD,oBAAoB,EAAE,eAAe,CAAC,GAAG,EAAE,yBAAyB,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;QACpF,2BAA2B,EAAE,QAAQ,CAAC,GAAG,EAAE,gCAAgC,EAAE,IAAI,CAAC;QAClF,uBAAuB,EAAE,QAAQ,CAAC,GAAG,EAAE,2BAA2B,EAAE,IAAI,CAAC;QACzE,yBAAyB,EAAE,QAAQ,CAAC,GAAG,EAAE,8BAA8B,EAAE,KAAK,CAAC;KAC/E,CAAC;AACH,CAAC"}

package/dist/compute/rate-limit.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Per-key fixed-window rate limiter for the compute-solve endpoint. Compute
+ * solves are the one expensive endpoint in a Selva-engine app — without a cap a
+ * single authenticated user (or share-link consumer) can burn through compute
+ * budget far faster than any other surface allows.
+ *
+ * Design:
+ *  - Process-local `Map`. Multi-instance deployments see N× the per-key rate —
+ *    acceptable as a first line; a distributed limiter is a follow-up. The state
+ *    lives behind this factory so a shared-store implementation can slot in
+ *    later without changing the call sites.
+ *  - Fixed window (vs sliding) — simpler, no per-request bookkeeping; the
+ *    "burst at window edges" mode is fine here (share-link `maxSolves` and
+ *    per-user auth already prevent unbounded abuse — this flattens short spikes).
+ *  - Keyed by caller — the app passes `user:{userId}` for authenticated solves,
+ *    `share:{linkId}` for share-token solves, so anonymous consumers of one link
+ *    don't share a bucket with the link's owner.
+ *
+ * The window + cap are injected (they live in `ComputeLimits`), so this module
+ * reads no env of its own.
+ */
+export interface RateLimitResult {
+    allowed: boolean;
+    /** Seconds until the bucket resets, when not allowed. */
+    retryAfter?: number;
+}
+export interface ComputeRateLimiterConfig {
+    /** Fixed-window length in ms. */
+    windowMs: number;
+    /** Max requests admitted per key per window. */
+    maxPerWindow: number;
+}
+export interface ComputeRateLimiter {
+    /**
+     * Check + record one request against `key`. Increments the counter on allow.
+     * Returns `{ allowed: false, retryAfter }` once the bucket is full.
+     */
+    check(key: string): RateLimitResult;
+    /** Test seam — wipes in-memory state. Production code never calls this. */
+    reset(): void;
+    /** The resolved config, exposed for time-based test assertions. */
+    readonly config: Readonly<ComputeRateLimiterConfig>;
+}
+/**
+ * Build a process-local fixed-window rate limiter. Each limiter owns its own
+ * bucket `Map`, so distinct endpoints/keys-spaces don't collide.
+ */
+export declare function createComputeRateLimiter(config: ComputeRateLimiterConfig): ComputeRateLimiter;
+//# sourceMappingURL=rate-limit.d.ts.map

package/dist/compute/rate-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../../src/compute/rate-limit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,wBAAwB;IACxC,iCAAiC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IAClC;;;OAGG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAAC;IACpC,2EAA2E;IAC3E,KAAK,IAAI,IAAI,CAAC;IACd,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,wBAAwB,CAAC,CAAC;CACpD;AAOD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,wBAAwB,GAAG,kBAAkB,CA0B7F"}

package/dist/compute/rate-limit.js

@@ -0,0 +1,49 @@
+/**
+ * Per-key fixed-window rate limiter for the compute-solve endpoint. Compute
+ * solves are the one expensive endpoint in a Selva-engine app — without a cap a
+ * single authenticated user (or share-link consumer) can burn through compute
+ * budget far faster than any other surface allows.
+ *
+ * Design:
+ *  - Process-local `Map`. Multi-instance deployments see N× the per-key rate —
+ *    acceptable as a first line; a distributed limiter is a follow-up. The state
+ *    lives behind this factory so a shared-store implementation can slot in
+ *    later without changing the call sites.
+ *  - Fixed window (vs sliding) — simpler, no per-request bookkeeping; the
+ *    "burst at window edges" mode is fine here (share-link `maxSolves` and
+ *    per-user auth already prevent unbounded abuse — this flattens short spikes).
+ *  - Keyed by caller — the app passes `user:{userId}` for authenticated solves,
+ *    `share:{linkId}` for share-token solves, so anonymous consumers of one link
+ *    don't share a bucket with the link's owner.
+ *
+ * The window + cap are injected (they live in `ComputeLimits`), so this module
+ * reads no env of its own.
+ */
+/**
+ * Build a process-local fixed-window rate limiter. Each limiter owns its own
+ * bucket `Map`, so distinct endpoints/keys-spaces don't collide.
+ */
+export function createComputeRateLimiter(config) {
+    const { windowMs, maxPerWindow } = config;
+    const buckets = new Map();
+    return {
+        config,
+        check(key) {
+            const now = Date.now();
+            const entry = buckets.get(key);
+            if (!entry || now > entry.resetAt) {
+                buckets.set(key, { count: 1, resetAt: now + windowMs });
+                return { allowed: true };
+            }
+            if (entry.count >= maxPerWindow) {
+                return { allowed: false, retryAfter: Math.ceil((entry.resetAt - now) / 1000) };
+            }
+            entry.count += 1;
+            return { allowed: true };
+        },
+        reset() {
+            buckets.clear();
+        }
+    };
+}
+//# sourceMappingURL=rate-limit.js.map

package/dist/compute/rate-limit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.js","sourceRoot":"","sources":["../../src/compute/rate-limit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAgCH;;;GAGG;AACH,MAAM,UAAU,wBAAwB,CAAC,MAAgC;IACxE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,MAAM,CAAC;IAC1C,MAAM,OAAO,GAAG,IAAI,GAAG,EAAuB,CAAC;IAE/C,OAAO;QACN,MAAM;QACN,KAAK,CAAC,GAAW;YAChB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACvB,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAE/B,IAAI,CAAC,KAAK,IAAI,GAAG,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;gBACnC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,QAAQ,EAAE,CAAC,CAAC;gBACxD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;YAC1B,CAAC;YAED,IAAI,KAAK,CAAC,KAAK,IAAI,YAAY,EAAE,CAAC;gBACjC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC;YAChF,CAAC;YAED,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC;YACjB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;QAC1B,CAAC;QACD,KAAK;YACJ,OAAO,CAAC,KAAK,EAAE,CAAC;QACjB,CAAC;KACD,CAAC;AACH,CAAC"}

package/dist/compute/remote-definition.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Remote-definition fetch: SSRF-guarded, size-capped, timed, and TTL-cached.
+ *
+ * A solve can reference its `.gh` by remote URL instead of a stored blob. That
+ * URL is attacker-controllable (a share-token caller supplies `definitionUrl`),
+ * so every fetch runs through {@link assertSafeRemoteDefinitionUrl} (literal +
+ * DNS host validation, blocking private/loopback/link-local targets and
+ * literal-encoding bypasses), streams the body with an early size cap, and
+ * bounds the wall time with a deadline.
+ *
+ * The TTL cache is a per-fetcher `Map<url, {data, fetchedAt}>` so repeated
+ * solves of the same remote definition skip the network. It's created by
+ * {@link createRemoteDefinitionFetcher} rather than being module-global, so a
+ * consuming app can hold one fetcher per process (the app binding does) or
+ * several isolated ones (tests) without shared state leaking across them.
+ */
+/** Injected limits — the app derives these from its env-resolved `ComputeLimits`. */
+export interface RemoteDefinitionConfig {
+    /** Hard cap on the fetched body; a lying/absent content-length can't exceed it. */
+    maxBytes: number;
+    /** Deadline on the fetch (slow-loris protection). */
+    fetchTimeoutMs: number;
+    /** How long a fetched definition stays warm in the in-process cache. */
+    cacheTtlMs: number;
+    /**
+     * Current epoch millis. Injected (not read via `Date.now()` ambiently) so the
+     * TTL is testable and the module stays side-effect-free. The app binding
+     * passes `() => Date.now()`.
+     */
+    now: () => number;
+}
+export interface RemoteDefinitionFetcher {
+    /**
+     * Fetch (or return cached) `.gh` bytes for a remote URL. Throws on an unsafe
+     * host, a non-2xx response, an oversized body, or a timeout — the caller maps
+     * the failure to a 400.
+     */
+    load(url: string): Promise<Uint8Array>;
+}
+/**
+ * Read a response body into memory, aborting (and throwing) as soon as the
+ * running byte total exceeds `maxBytes`. Falls back to `arrayBuffer()` only when
+ * the body isn't a readable stream (older fetch impls). Exported for direct use
+ * and reuse; the fetcher below wraps it with SSRF + TTL.
+ */
+export declare function readBodyWithCap(response: Response, maxBytes: number, controller: AbortController): Promise<Uint8Array>;
+/**
+ * Build a remote-definition fetcher owning its own TTL cache. Each fetcher's
+ * cache is independent, so one per process shares warm bytes while test fetchers
+ * stay isolated.
+ */
+export declare function createRemoteDefinitionFetcher(config: RemoteDefinitionConfig): RemoteDefinitionFetcher;
+//# sourceMappingURL=remote-definition.d.ts.map

package/dist/compute/remote-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-definition.d.ts","sourceRoot":"","sources":["../../src/compute/remote-definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,qFAAqF;AACrF,MAAM,WAAW,sBAAsB;IACtC,mFAAmF;IACnF,QAAQ,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,cAAc,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,GAAG,EAAE,MAAM,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACvC;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CACvC;AAMD;;;;;GAKG;AACH,wBAAsB,eAAe,CACpC,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,eAAe,GACzB,OAAO,CAAC,UAAU,CAAC,CA4BrB;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC5C,MAAM,EAAE,sBAAsB,GAC5B,uBAAuB,CAqDzB"}