@selvajs/server 0.2.0 → 1.0.0-beta.0

package/dist/compute/solve-cache-key.d.ts

@@ -1,64 +0,0 @@
-/**
- * Durable L2 cache-key derivation (H2 / R8 / R13).
- *
- * The in-process L1 cache keys on a 32-bit FNV hash — fine for a 20-entry Map,
- * unsafe for a durable, cross-user cache where a collision serves user A's
- * geometry to user B (CONTEXT.md L92–97 records exactly this bug shipping once).
- * So the L2 key is a wide SHA-256 hash (SHA-256 collisions aren't a realistic
- * threat, so hash-to-hash comparison at hit time is defense-in-depth enough —
- * no byte-for-byte preimage comparison is done or needed).
- *
- * What goes into the key:
- *   - The **transformed** input tree (R13) — the exact tree handed to the
- *     scheduler, canonicalized with the package's exported `stableStringify` so
- *     the L2 key parity-matches the L1 canonicalization path.
- *   - A **config subset** (R8): everything OTHER than definition+inputs that
- *     changes a solve's result — model units, tolerances, `dataversion`, the
- *     compute contract version, and (when known) the Rhino server identity. A
- *     durable key of `(versionId, inputHash)` alone would collide across
- *     differing server configs or Rhino versions.
- *
- * `versionId`, `definitionId`, and `orgId` are NOT hashed in here — they're
- * separate parts of the {@link SolveCacheKey} tuple so the backend can scope its
- * keyspace (per-definition quota, per-org isolation) without unpacking the hash.
- */
-/**
- * Solve-affecting configuration folded into the key alongside the input tree.
- * Every field here is something that, if it changed, would legitimately change
- * the solve output for the SAME definition + inputs. Assemble it from the app's
- * resolved solve config; unset fields are simply absent from the canonical form.
- */
-export interface SolveCacheConfigSubset {
-    /** Rhino model unit system, if the app pins one (else the definition/server default). */
-    modelUnits?: string;
-    /** Absolute tolerance, if pinned. */
-    absoluteTolerance?: number;
-    /** Angle tolerance, if pinned. */
-    angleTolerance?: number;
-    /** Grasshopper `dataversion` / data-tree schema version, if pinned. */
-    dataVersion?: number | string;
-    /**
-     * Compute-server identity (id or URL). Folds in because two servers can run
-     * different Rhino/plugin versions that yield different geometry for the same
-     * inputs. Optional — omit for a single-pool deployment where it's constant.
-     */
-    computeServerId?: string;
-}
-/** The SHA-256 digest of the canonical preimage — the `inputKey` part of the storage key. */
-export interface SolveCacheInputKey {
-    /** SHA-256 hex of the canonical `{ v, tree, config }` string. */
-    hash: string;
-}
-/**
- * Derive the durable `inputKey` from the transformed input tree and the solve
- * config subset. Deterministic and stable across processes/instances: the same
- * tree + config always produce the same hash, which is what lets a shared cache
- * hit across app instances.
- *
- * @param transformedTree the tree AFTER `transformInputParameter`/`TreeBuilder`
- *   (R13) — the exact object handed to `scheduler.solve`.
- * @param config solve-affecting config (R8); `COMPUTE_CONTRACT_VERSION` is folded
- *   in automatically so a wire-contract bump invalidates old entries for free.
- */
-export declare function deriveSolveCacheInputKey(transformedTree: unknown, config: SolveCacheConfigSubset): SolveCacheInputKey;
-//# sourceMappingURL=solve-cache-key.d.ts.map

package/dist/compute/solve-cache-key.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"solve-cache-key.d.ts","sourceRoot":"","sources":["../../src/compute/solve-cache-key.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAMH;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACtC,yFAAyF;IACzF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qCAAqC;IACrC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kCAAkC;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,6FAA6F;AAC7F,MAAM,WAAW,kBAAkB;IAClC,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CACvC,eAAe,EAAE,OAAO,EACxB,MAAM,EAAE,sBAAsB,GAC5B,kBAAkB,CAWpB"}

package/dist/compute/solve-cache-key.js

@@ -1,51 +0,0 @@
-/**
- * Durable L2 cache-key derivation (H2 / R8 / R13).
- *
- * The in-process L1 cache keys on a 32-bit FNV hash — fine for a 20-entry Map,
- * unsafe for a durable, cross-user cache where a collision serves user A's
- * geometry to user B (CONTEXT.md L92–97 records exactly this bug shipping once).
- * So the L2 key is a wide SHA-256 hash (SHA-256 collisions aren't a realistic
- * threat, so hash-to-hash comparison at hit time is defense-in-depth enough —
- * no byte-for-byte preimage comparison is done or needed).
- *
- * What goes into the key:
- *   - The **transformed** input tree (R13) — the exact tree handed to the
- *     scheduler, canonicalized with the package's exported `stableStringify` so
- *     the L2 key parity-matches the L1 canonicalization path.
- *   - A **config subset** (R8): everything OTHER than definition+inputs that
- *     changes a solve's result — model units, tolerances, `dataversion`, the
- *     compute contract version, and (when known) the Rhino server identity. A
- *     durable key of `(versionId, inputHash)` alone would collide across
- *     differing server configs or Rhino versions.
- *
- * `versionId`, `definitionId`, and `orgId` are NOT hashed in here — they're
- * separate parts of the {@link SolveCacheKey} tuple so the backend can scope its
- * keyspace (per-definition quota, per-org isolation) without unpacking the hash.
- */
-import { createHash } from 'node:crypto';
-import { stableStringify } from '@selvajs/compute';
-import { COMPUTE_CONTRACT_VERSION } from './solve-pipeline.js';
-/**
- * Derive the durable `inputKey` from the transformed input tree and the solve
- * config subset. Deterministic and stable across processes/instances: the same
- * tree + config always produce the same hash, which is what lets a shared cache
- * hit across app instances.
- *
- * @param transformedTree the tree AFTER `transformInputParameter`/`TreeBuilder`
- *   (R13) — the exact object handed to `scheduler.solve`.
- * @param config solve-affecting config (R8); `COMPUTE_CONTRACT_VERSION` is folded
- *   in automatically so a wire-contract bump invalidates old entries for free.
- */
-export function deriveSolveCacheInputKey(transformedTree, config) {
-    // stableStringify sorts keys deterministically — same content, same string,
-    // regardless of property insertion order. Tag each part so a value can't shift
-    // across the tree/config boundary and collide (e.g. tree "]" meeting config "[").
-    const canonical = stableStringify({
-        v: COMPUTE_CONTRACT_VERSION,
-        tree: transformedTree,
-        config
-    });
-    const hash = createHash('sha256').update(canonical).digest('hex');
-    return { hash };
-}
-//# sourceMappingURL=solve-cache-key.js.map

package/dist/compute/solve-cache-key.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"solve-cache-key.js","sourceRoot":"","sources":["../../src/compute/solve-cache-key.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AA+B/D;;;;;;;;;;GAUG;AACH,MAAM,UAAU,wBAAwB,CACvC,eAAwB,EACxB,MAA8B;IAE9B,4EAA4E;IAC5E,+EAA+E;IAC/E,kFAAkF;IAClF,MAAM,SAAS,GAAG,eAAe,CAAC;QACjC,CAAC,EAAE,wBAAwB;QAC3B,IAAI,EAAE,eAAe;QACrB,MAAM;KACN,CAAC,CAAC;IACH,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAClE,OAAO,EAAE,IAAI,EAAE,CAAC;AACjB,CAAC"}

package/dist/compute/solve-cache-single-flight.d.ts

@@ -1,42 +0,0 @@
-/**
- * In-process single-flight (R4) — dogpile protection above the L2 cache.
- *
- * N identical live solves arriving while the first is still running would each
- * enqueue and each hit Rhino (the scheduler has no in-flight coalescing, and
- * Rhino's `cachesolve` still costs a round trip per repeat). The classic cold-key
- * stampede: a hot public definition + a deploy = a thundering herd onto compute.
- *
- * This coalesces them: the first caller for a key runs the work; concurrent
- * callers for the SAME key await the same promise and share its result. Once the
- * work settles (resolve OR reject), the key is released so the next request runs
- * fresh — the map never retains a settled entry, so it can't serve a stale
- * result or leak memory.
- *
- * It sits ABOVE the `ISolveResultCache` interface (in-process, per app instance).
- * A cross-instance lease (Redis `SET NX`) is a later backend capability; this is
- * the free first slice that covers the common same-instance burst.
- *
- * Correctness note: the shared promise resolves to ONE value for all waiters, so
- * the wrapped work must return an immutable / independently-serializable result
- * (the solve pipeline returns a fresh envelope object — safe to share by
- * reference here because the app serializes it per response).
- */
-export interface SolveCacheSingleFlight {
-    /**
-     * Run `work` under `key`, coalescing concurrent identical calls. The first
-     * caller executes; overlapping callers for the same key await the same promise.
-     * The key is freed as soon as the promise settles (success or failure).
-     */
-    run<T>(key: string, work: () => Promise<T>): Promise<T>;
-    /** Number of keys currently in flight (observability / tests). */
-    inFlight(): number;
-}
-export interface SolveCacheSingleFlightOptions {
-    /**
-     * Fired when a caller joins an already-in-flight key instead of running its
-     * own work — the coalescing win this module exists for, otherwise invisible.
-     */
-    onJoin?: (key: string) => void;
-}
-export declare function createSolveCacheSingleFlight(options?: SolveCacheSingleFlightOptions): SolveCacheSingleFlight;
-//# sourceMappingURL=solve-cache-single-flight.d.ts.map

package/dist/compute/solve-cache-single-flight.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"solve-cache-single-flight.d.ts","sourceRoot":"","sources":["../../src/compute/solve-cache-single-flight.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,WAAW,sBAAsB;IACtC;;;;OAIG;IACH,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACxD,kEAAkE;IAClE,QAAQ,IAAI,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,6BAA6B;IAC7C;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/B;AAED,wBAAgB,4BAA4B,CAC3C,OAAO,GAAE,6BAAkC,GACzC,sBAAsB,CA0BxB"}

package/dist/compute/solve-cache-single-flight.js

@@ -1,50 +0,0 @@
-/**
- * In-process single-flight (R4) — dogpile protection above the L2 cache.
- *
- * N identical live solves arriving while the first is still running would each
- * enqueue and each hit Rhino (the scheduler has no in-flight coalescing, and
- * Rhino's `cachesolve` still costs a round trip per repeat). The classic cold-key
- * stampede: a hot public definition + a deploy = a thundering herd onto compute.
- *
- * This coalesces them: the first caller for a key runs the work; concurrent
- * callers for the SAME key await the same promise and share its result. Once the
- * work settles (resolve OR reject), the key is released so the next request runs
- * fresh — the map never retains a settled entry, so it can't serve a stale
- * result or leak memory.
- *
- * It sits ABOVE the `ISolveResultCache` interface (in-process, per app instance).
- * A cross-instance lease (Redis `SET NX`) is a later backend capability; this is
- * the free first slice that covers the common same-instance burst.
- *
- * Correctness note: the shared promise resolves to ONE value for all waiters, so
- * the wrapped work must return an immutable / independently-serializable result
- * (the solve pipeline returns a fresh envelope object — safe to share by
- * reference here because the app serializes it per response).
- */
-export function createSolveCacheSingleFlight(options = {}) {
-    const inflight = new Map();
-    return {
-        run(key, work) {
-            const existing = inflight.get(key);
-            if (existing) {
-                options.onJoin?.(key);
-                return existing;
-            }
-            // `.finally` releases the key on both settle paths. Start the work inside
-            // the promise chain so a synchronous throw in `work` still rejects the
-            // shared promise (and still frees the key) rather than escaping.
-            const p = (async () => work())().finally(() => {
-                // Only delete if it's still OUR promise — a key freed and re-taken by a
-                // later caller must not be clobbered.
-                if (inflight.get(key) === p)
-                    inflight.delete(key);
-            });
-            inflight.set(key, p);
-            return p;
-        },
-        inFlight() {
-            return inflight.size;
-        }
-    };
-}
-//# sourceMappingURL=solve-cache-single-flight.js.map

package/dist/compute/solve-cache-single-flight.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"solve-cache-single-flight.js","sourceRoot":"","sources":["../../src/compute/solve-cache-single-flight.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAqBH,MAAM,UAAU,4BAA4B,CAC3C,UAAyC,EAAE;IAE3C,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA4B,CAAC;IAErD,OAAO;QACN,GAAG,CAAI,GAAW,EAAE,IAAsB;YACzC,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACnC,IAAI,QAAQ,EAAE,CAAC;gBACd,OAAO,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC;gBACtB,OAAO,QAAsB,CAAC;YAC/B,CAAC;YAED,0EAA0E;YAC1E,uEAAuE;YACvE,iEAAiE;YACjE,MAAM,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE;gBAC7C,wEAAwE;gBACxE,sCAAsC;gBACtC,IAAI,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC;oBAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACnD,CAAC,CAAC,CAAC;YACH,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;YACrB,OAAO,CAAC,CAAC;QACV,CAAC;QACD,QAAQ;YACP,OAAO,QAAQ,CAAC,IAAI,CAAC;QACtB,CAAC;KACD,CAAC;AACH,CAAC"}

package/dist/compute/solve-pipeline.d.ts

@@ -1,221 +0,0 @@
-/**
- * Transport-agnostic solve pipeline — the callable core lifted out of the app's
- * `/api/compute` route (embeddable-server-layer plan, K3).
- *
- * Given an already-resolved solve context — the `.gh` bytes, the input params +
- * user values, and a warm `SolveScheduler` (from `createClientCache`) — this
- * runs the framework-free half of a solve:
- *
- *   input tree build → scheduler.solve (with abort/timeout classification) →
- *   JSON serialize (size-guarded) → optional gzip → Server-Timing envelope.
- *
- * It returns a discriminated {@link SolveOutcome}: `ok` carries the ready-to-send
- * {@link SolveEnvelope} (body + headers + phase metrics), while the error
- * variants (`timeout`, `client_abort`, `too_large`, `compute_error`) name a
- * failure the transport maps to its own status code. Nothing here throws for an
- * expected failure and nothing here touches auth, the database, share tokens,
- * rate limits, or metric sinks — those stay app policy in the route.
- *
- * The Server-Timing string it emits IS the versioned wire contract (audit D5):
- * see {@link COMPUTE_CONTRACT_VERSION} and {@link COMPUTE_VERSION_HEADER}.
- */
-import { type GrasshopperComputeResponse, type SolveDefinition } from '@selvajs/compute';
-import type { SchemaInput } from '@selvajs/schemas';
-import { type ILogger } from '@selvajs/platform';
-import type { CachedClient } from './client-cache.js';
-import type { ByteRefOutcome } from './definition-byte-cache.js';
-import { type SolveCacheConfigSubset } from './solve-cache-key.js';
-/** Current compute-response contract version. Additive header; bump on shape change. */
-export declare const COMPUTE_CONTRACT_VERSION: 1;
-/** Response header carrying {@link COMPUTE_CONTRACT_VERSION}. */
-export declare const COMPUTE_VERSION_HEADER = "X-Selva-Compute-Version";
-/** A schema input carrying the optional numeric bounds the transform reads. */
-export type PipelineInput = SchemaInput & {
-    minimum?: number;
-    maximum?: number;
-    stepSize?: number;
-};
-export interface SolvePipelineArgs {
-    /**
-     * The definition to solve. Either raw `.gh` bytes (remote fetch, or a caller
-     * that resolved them eagerly) or a `DefinitionRef` — an identity-keyed lazy
-     * loader (from the definition-byte cache) whose bytes the scheduler
-     * materializes ONLY when an upload is unavoidable. A pointer-known solve of a
-     * `DefinitionRef` moves zero bytes.
-     */
-    definitionSource: SolveDefinition;
-    /**
-     * When `definitionSource` is a byte-cache `DefinitionRef`, its mutable outcome
-     * so the pipeline can emit the `def_bytes` Server-Timing verdict (skipped =
-     * `load` never ran, hit = warm cache, miss = loader). Omit for raw-bytes solves.
-     */
-    byteRefOutcome?: ByteRefOutcome;
-    /** Persisted input params; only those with a `paramType` are sent to the solve. */
-    inputs: PipelineInput[];
-    /**
-     * Structured logger for pipeline diagnostics (e.g. a corrupt L2 cache entry).
-     * Optional; defaults to `NoopLogger` so this library never writes to stdout
-     * unless the embedder asks for it.
-     */
-    logger?: ILogger;
-    /** User-chosen values keyed by input id; missing keys fall back to the schema default. */
-    values: Record<string, unknown>;
-    /** Warm client bundle from `createClientCache().getClient(...)`. */
-    client: CachedClient;
-    /** Longest a serialized result may be (bytes) before a 413. */
-    responseMaxBytes: number;
-    /** Solve-deadline millis — used only to phrase the timeout message. */
-    maxSolveDurationMs: number;
-    /** Client's `Accept-Encoding`; gzip is applied only when it advertises `gzip`. */
-    acceptEncoding: string;
-    /**
-     * Request abort signal, forwarded to the scheduler so a client disconnect
-     * cancels the upstream compute call. Its `aborted` flag also disambiguates a
-     * client disconnect from the scheduler's own deadline firing.
-     */
-    signal: AbortSignal;
-    /**
-     * Wall-clock origin (`performance.now()` captured at the top of the request)
-     * so the pipeline's `load`/`total` phase timings line up with the caller's
-     * pre-solve prep. The caller owns everything before this and stamps `defLoadMs`.
-     */
-    loadStartMs: number;
-    /** Pre-solve "load" phase duration the caller already measured (auth + DB + fetch). */
-    defLoadMs: number;
-    /**
-     * Pre-solve prep sub-phase marks (`[label, ms]`), surfaced verbatim as `p_*`
-     * Server-Timing entries. The caller assembles these; the pipeline only echoes.
-     */
-    prepMarks?: [string, number][];
-    /**
-     * Optional durable L2 solve cache (H1). Present ONLY for live-channel solves
-     * whose definition has a caching quota > 0 — its presence IS the channel gate
-     * (zero policy conditionals in the pipeline). When set, the pipeline derives
-     * the wide input key from the transformed tree + `configSubset`, checks
-     * `lookup` before solving (a hit skips compute entirely, returning the stored
-     * gzipped envelope), and write-throughs `store` on a successful solve.
-     */
-    solveCache?: SolvePipelineCacheHook;
-}
-/**
- * The app-supplied L2 hook. The app binds `lookup`/`store` to the org/definition/
- * version scope and the definition's quota; the pipeline supplies the SHA-256
- * `inputKey` (derived from the transformed tree + `configSubset`) and the opaque
- * encoded entry bytes. Both are best-effort — `lookup` may miss/throw (treated as
- * a miss), `store` is fire-and-forget.
- */
-export interface SolvePipelineCacheHook {
-    /** Solve-affecting config folded into the key (R8) — model units, tolerances, server id. */
-    configSubset: SolveCacheConfigSubset;
-    /** Fetch a stored entry for `inputKey`, or `null` on miss. Must not reject fatally. */
-    lookup(inputKey: string): Promise<Uint8Array | null>;
-    /** Store the encoded entry for `inputKey`. Fire-and-forget; best-effort. */
-    store(inputKey: string, entry: Uint8Array): void;
-}
-/** Phase timings the pipeline measured; the caller uses them for debug logging. */
-export interface SolvePhaseMetrics {
-    treeBuildMs: number;
-    solveMs: number;
-    serializeMs: number;
-    gzipMs: number;
-    serverTotalMs: number;
-    /** Uncompressed serialized length in bytes. */
-    serializedBytes: number;
-    /** Gzipped length in bytes, or null when compression was skipped. */
-    compressedBytes: number | null;
-    /**
-     * L2 durable-cache verdict: `true` = served from L2 (no solve ran), `false` =
-     * L2 consulted and missed (solved), `null` = L2 not consulted (no hook — draft
-     * or caching off). Drives the `l2_cache` Server-Timing entry.
-     */
-    l2CacheHit: boolean | null;
-}
-/** A ready-to-send response: body + headers + the solve result + phase metrics. */
-export interface SolveEnvelope {
-    /** The response body — a gzip `Uint8Array` when `encoding === 'gzip'`, else the JSON string. */
-    body: string | Uint8Array;
-    /** `'gzip'` when the body is compressed; absent otherwise. */
-    encoding?: 'gzip';
-    /** Fully-assembled response headers (Content-Type/-Length/-Encoding, Vary, Server-Timing, version). */
-    headers: Record<string, string>;
-    /**
-     * The solved definition object, present only on a fresh (non-L2) solve. Absent
-     * on an L2 hit — the pipeline serves the stored gzipped body without ever
-     * materializing the object. The caller reads `errorCount`/`warningCount` off
-     * the `ok` outcome for its metric record, not this field.
-     */
-    result?: GrasshopperComputeResponse;
-    /** Phase timings, for the caller's optional debug breakdown. */
-    metrics: SolvePhaseMetrics;
-}
-/**
- * Discriminated result. `ok` carries the envelope; every other variant names an
- * expected failure the transport maps to a status code (the app route maps
- * timeout→504, client_abort→499, too_large→413, shed→503+Retry-After;
- * `compute_error` re-surfaces the original error for the generic 500/503 path).
- * `durationMs` on the error variants is the solve wall time up to the failure,
- * for the metric record.
- */
-export type SolveOutcome = {
-    kind: 'ok';
-    envelope: SolveEnvelope;
-    solveMs: number;
-    errorCount: number;
-    warningCount: number;
-} | {
-    kind: 'timeout';
-    durationMs: number;
-    message: string;
-} | {
-    kind: 'client_abort';
-    durationMs: number;
-} | {
-    kind: 'too_large';
-}
-/**
- * Scheduler backpressure shed the solve before it executed — the per-server
- * queue was full (`QUEUE_FULL`) or it sat queued past the wait deadline
- * (`QUEUE_TIMEOUT`). Retryable: the route maps this to 503 + `Retry-After`.
- * `retryAfterSeconds` is a suggested backoff hint for the client.
- */
- | {
-    kind: 'shed';
-    durationMs: number;
-    reason: 'queue_full' | 'queue_timeout';
-    retryAfterSeconds: number;
-    message: string;
-} | {
-    kind: 'compute_error';
-    durationMs: number;
-    error: unknown;
-};
-/**
- * Run the framework-free half of a solve and produce a typed outcome. See the
- * module doc for the phase sequence and the app/library boundary.
- */
-export declare function runSolvePipeline(args: SolvePipelineArgs): Promise<SolveOutcome>;
-/**
- * Re-key a coalesced envelope to a single waiter's `Accept-Encoding` (audit C5).
- *
- * The single-flight coalescer (R4) runs ONE pipeline execution for N identical
- * concurrent solves and hands every waiter the same {@link SolveEnvelope}. That
- * envelope's wire form — gzip body + `Content-Encoding: gzip`, or the plain JSON
- * string — is baked from the FIRST caller's `Accept-Encoding`. A later waiter
- * with a different `Accept-Encoding` would otherwise receive a body labelled with
- * the wrong encoding: a non-gzip client joining a gzip flight gets gzip bytes it
- * cannot decode (`Vary` can't help — this is one object shared across waiters,
- * not a cache lookup). Encoding is not in the coalesce key by design, so mixed
- * clients still coalesce; this adapts the shared result to each waiter instead.
- *
- * Returns the body + headers to send THIS waiter. Only the correctness-critical
- * direction is adapted — a gzip envelope served to a non-gzip waiter is gunzipped
- * back to JSON. The reverse (a plain-JSON envelope to a gzip-capable waiter) is
- * left uncompressed: gzip is an optimisation the client advertises, never a
- * requirement, so sending it plain is correct, just not maximally small. The
- * common all-gzip case returns the envelope's own body/headers untouched.
- */
-export declare function adaptEnvelopeToEncoding(envelope: SolveEnvelope, acceptEncoding: string): {
-    body: string | Uint8Array;
-    headers: Record<string, string>;
-};
-//# sourceMappingURL=solve-pipeline.d.ts.map

package/dist/compute/solve-pipeline.d.ts.map

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