@jimhoyd/urlcode 0.4.0-alpha.1 → 0.4.0-alpha.3

package/dist/types/extensions.d.ts

@@ -6,11 +6,23 @@ export interface ExtensionDeclaration {
     config: Record<string, unknown>;
 }
 export type ExtensionPolicies = Record<string, Record<string, unknown> | false>;
+/**
+ * `root` is the project's resolved absolute directory (the same value
+ * `loadDocument()` computes and `functionFile()`/router.ts resolves
+ * `function`/`middleware` `source` entries against). It is not the process's
+ * `cwd()`: `--project`/`--host-file` are independent paths, a server can be
+ * started from any working directory, and the JS API can load a project
+ * programmatically with no relationship to `cwd()` at all. An extension that
+ * resolves project-relative paths of its own (for example, an alternative
+ * middleware source it loads by convention rather than through core's native
+ * `middleware:` array) must resolve them against this field, never `cwd()`.
+ */
 export interface ExtensionActivation {
     origin: string;
     target: TargetName;
     projectSha256: string;
     mounts: readonly string[];
+    root: string;
 }
 export interface ExtensionRequest {
     method: string;
@@ -28,6 +40,20 @@ export interface ExtensionRequest {
 export interface ExtensionInstance {
     handle(request: ExtensionRequest): HandlerResult | Promise<HandlerResult>;
     authorize?(requirement: Readonly<Record<string, unknown>>, request: ExtensionRequest): HandlerResult | undefined | Promise<HandlerResult | undefined>;
+    /**
+     * Wrap semantics, not gate semantics: attached the same way as `authorize`
+     * (policies.extensions.<name> on a route, `config` the same validated
+     * per-route value `authorize`'s `requirement` receives), but given `next`,
+     * a callable invoking the rest of the pipeline for this route (any other
+     * declared extension `middleware()` after this one, then the route's own
+     * native `middleware:` chain and handler) at most once. Calling it lets
+     * this hook run code before and after the rest of the pipeline, inspecting
+     * or mutating the `HandlerResult` it resolves to; skipping it short-circuits
+     * the rest of the pipeline entirely, the same way `authorize` can. Never
+     * touches the native `middleware:` array or its own sandboxed/trusted
+     * dispatch, and never runs before `authorize` on the same route.
+     */
+    middleware?(config: Readonly<Record<string, unknown>>, request: ExtensionRequest, next: () => Promise<HandlerResult>): HandlerResult | Promise<HandlerResult>;
     close?(): void | Promise<void>;
 }
 /** Trusted operator code only. YAML declares names/configuration, never modules. */
@@ -49,6 +75,23 @@ export interface RuntimeExtension {
     policySchema?: object;
     credentialHeaders?: string[];
     immutableAssets?: ExtensionImmutableAssets;
+    /**
+     * Reviewed, operator-declared cache sensitivity for `policies.extensions.<name>`
+     * routes (never for an `extension:` mount, which is always treated as
+     * sensitive). Omitted or `true`: the current, safe default — the runtime
+     * forces `Cache-Control: no-store`, disables compression and applies the
+     * extension response's header/size caps, exactly like `authorize`-gating
+     * auth/admin extensions. `false` is an explicit, reviewed opt-in a generic,
+     * cache-transparent extension (pure request/response middleware with no
+     * gating semantics of its own) makes to say its
+     * `middleware()` hook never depends on withholding the response from
+     * shared caches: the wrapped route's own declared cache headers pass
+     * through unchanged, exactly as the native `middleware:` array already
+     * does. A route naming more than one extension is treated as sensitive if
+     * any of them is (or leaves this unset) — this can only relax the no-store
+     * floor, never weaken it, and it never changes whether `authorize()` runs.
+     */
+    cacheSensitive?: boolean;
     activate(config: Readonly<Record<string, unknown>>, context: ExtensionActivation): ExtensionInstance | Promise<ExtensionInstance>;
 }
 /** `urlcode init --with <name>` contract: what core hands `@jimhoyd/urlcode-<name>`'s `scaffold` export. Nothing is written by `scaffold`. */
@@ -107,6 +150,18 @@ export declare const immutableCacheControl = "public, max-age=31536000, immutabl
 export declare function inspectExtensionRevision(project: string): Promise<string>;
 export declare function effectiveExtensionPolicies(document: ProjectDocument, route: Pick<RouteConfig, 'policies'>): Record<string, Record<string, unknown>>;
 export declare function hasExtensionPolicy(document: ProjectDocument, route: Pick<RouteConfig, 'policies'>): boolean;
+/**
+ * Whether a route naming these `policies.extensions` names must be treated as
+ * confidential (forced no-store, no compression, extension response caps).
+ * `names` with no entries is never confidential. Without a `registrations`
+ * list to consult (a build path with no operator host loaded), every name is
+ * treated as sensitive: the safe default this can only relax, never weaken.
+ * A name whose registration is missing, or declares no `cacheSensitive` (or
+ * `true`), counts as sensitive; only an explicit `cacheSensitive: false`
+ * excuses it, and one sensitive name among several makes the whole route
+ * confidential.
+ */
+export declare function isSensitiveExtensionPolicy(names: readonly string[], registrations?: readonly Pick<RuntimeExtension, 'name' | 'cacheSensitive'>[]): boolean;
 export declare function prepareExtensions(document: ProjectDocument, routes: Record<string, RouteConfig>, registrations: RuntimeExtension[] | undefined, context: Omit<ExtensionActivation, 'mounts'>): {
     activate(): Promise<ExtensionRegistry>;
 };

package/dist/types/function-sources.d.ts

@@ -23,4 +23,8 @@ export declare const MODULE_LIMIT = 128;
 export declare const MODULE_BYTE_LIMIT = 1048576;
 export declare const TOTAL_BYTE_LIMIT = 4194304;
 export declare function routeFunctions<D>(route: FunctionRoute<D>): D[];
+export declare function collectTrustedSources(routes: FunctionRoute[], root: string): Promise<Record<string, string>>;
+export declare function collectSourcesFor(definitions: FunctionDefinition[], root: string): Promise<FunctionSources>;
+/** Route-shaped convenience over `collectSourcesFor`: every existing caller (policy.ts,
+ * prerender.ts, typescript-authoring.ts) keeps working unchanged from `FunctionRoute[]`. */
 export declare function collectFunctionSources(routes: FunctionRoute[], root: string): Promise<FunctionSources>;

package/dist/types/functions.d.ts

@@ -1,12 +1,28 @@
 import { Worker } from 'node:worker_threads';
-import type { FunctionRoute, FunctionSources } from './function-sources.ts';
+import type { FunctionDefinition, FunctionRoute, FunctionSources } from './function-sources.ts';
 import type { HandlerResult, HeaderPair } from './http-response.ts';
 import type { ParameterValue, RequestContext } from './match.ts';
 import type { LogFn } from './types.ts';
 import type { GuestRequestPayload } from './guest-api.ts';
 export type { FunctionDefinition, FunctionRoute } from './function-sources.ts';
 export type { GuestRequestPayload, GuestResponsePayload } from './guest-api.ts';
-export interface FunctionPoolOptions {
+/** A module entry point the sandbox must load: an absolute source file path
+ * (already resolved and validated, e.g. via `functionFile()`) plus which
+ * export of it needs to be reachable. The same shape a `FunctionDefinition`
+ * already uses for `function`/`middleware` routes. */
+export type SandboxEntry = FunctionDefinition;
+/** What one `SandboxPool.execute()` call invokes: the same `{source, export}`
+ * shape as a `SandboxEntry`, naming one of the pool's declared entries. */
+export type SandboxTarget = FunctionDefinition;
+/** `entry` runs last (the route's `function`/handler); `chain` runs first, in
+ * order, each with `(request, context, next)` — the same wrap/middleware
+ * semantics `__invokePipeline` already gives sandboxed routes. Neither is
+ * required: an empty invocation with a `native` reply just returns it. */
+export interface SandboxInvocation {
+    entry?: SandboxTarget | undefined;
+    chain?: SandboxTarget[] | undefined;
+}
+export interface SandboxPoolOptions {
     root?: string | undefined;
     snapshot?: FunctionSources | undefined;
     workers?: number | undefined;
@@ -14,6 +30,7 @@ export interface FunctionPoolOptions {
     maxBytes?: number | undefined;
     log?: LogFn | undefined;
 }
+export type FunctionPoolOptions = SandboxPoolOptions;
 export interface FunctionWorkerData {
     sources: Record<string, string>;
     dependencies: Record<string, string[]>;
@@ -52,6 +69,7 @@ export type FunctionWorkerMessage = {
     headers: HeaderPair[];
     body: Uint8Array;
     nativeBody: boolean;
+    contentLength?: number;
 } | {
     id: string;
     error: true;
@@ -67,9 +85,9 @@ interface Slot {
     ready: boolean;
     pending: Pending | null;
 }
-export declare class FunctionPool {
+export declare class SandboxPool {
     root: string | undefined;
-    routes: FunctionRoute[];
+    entries: SandboxEntry[];
     preparedSnapshot: FunctionSources | undefined;
     snapshot: FunctionSources | undefined;
     restarts: Map<number, number>;
@@ -81,12 +99,37 @@ export declare class FunctionPool {
     size: number;
     slots: (Slot | undefined)[];
     closed: boolean;
-    constructor(routes: FunctionRoute[], { root, snapshot, workers, timeoutMs, maxBytes, log }?: FunctionPoolOptions);
+    constructor(entries: SandboxEntry[], { root, snapshot, workers, timeoutMs, maxBytes, log }?: SandboxPoolOptions);
     start(): Promise<this>;
     spawn(index: number): Promise<void>;
     report(status: string, index: number, extra?: object): void;
     scheduleRespawn(index: number): void;
     get healthy(): boolean;
+    /** `invocation.entry` runs last (chain-wrapped), `invocation.chain` first, in
+     * declared order — the same `__invokePipeline` wrap/middleware discipline
+     * (`next()` callable at most once) the sandboxed route path already
+     * enforces; there is no second dispatch mechanism for this. Every entry and
+     * chain source named here must already be one of this pool's declared
+     * `entries` (constructor), or the worker's own module allowlist denies it. */
+    execute(invocation: SandboxInvocation, request: GuestRequestPayload, context: FunctionContext, native: HandlerResult | undefined): Promise<FunctionResult>;
+    close(): Promise<void>;
+}
+export declare class FunctionPool {
+    routes: FunctionRoute[];
+    private pool;
+    constructor(routes: FunctionRoute[], options?: FunctionPoolOptions);
+    start(): Promise<this>;
     execute(route: FunctionRoute, request: GuestRequestPayload, context: FunctionContext, native: HandlerResult | undefined): Promise<FunctionResult>;
+    scheduleRespawn(index: number): void;
     close(): Promise<void>;
+    get healthy(): boolean;
+    get restarts(): Map<number, number>;
+    get restartTimers(): Set<NodeJS.Timeout>;
+    get slots(): (Slot | undefined)[];
+    get size(): number;
+    get closed(): boolean;
+    get snapshot(): FunctionSources | undefined;
+    get log(): LogFn;
+    get timeoutMs(): number;
+    get maxBytes(): number;
 }

package/dist/types/guest-api.d.ts

@@ -12,5 +12,6 @@ export interface GuestResponsePayload {
     headers: HeaderPair[];
     body: string;
     nativeBody?: boolean;
+    contentLength?: number;
 }
 export declare const guestBootstrap: string;

package/dist/types/index.d.ts

@@ -1,13 +1,8 @@
 export { createRuntime } from './runtime.ts';
-export type { Runtime, RuntimeOptions, RuntimeRequest, RequestTrace, LinkReader, LinkStoreBinding, HostPlugin, Observer, TestPlan } from './runtime.ts';
+export type { Runtime, RuntimeOptions, RuntimeRequest, RequestTrace, HostPlugin, Observer, TestPlan } from './runtime.ts';
 export { startServer } from './server.ts';
 export type { Server, ServerOptions } from './server.ts';
 export { loadDocument, validateDocument, parseYaml } from './config.ts';
-export { openLinkStore } from './link-store.ts';
-export type { LinkStore, LinkRow, LinkStoreOptions } from './link-store.ts';
-export { startLinkApi } from './link-api.ts';
-export type { LinkApi, LinkApiOptions } from './link-api.ts';
-export type { LinkEvent, LinkObserverOptions, LinkObserverStats } from './link-events.ts';
 export { events as observabilityEvents, validateObservers, createObserverSink, createMetrics, renderPrometheus } from './observability.ts';
 export { getCapabilities, routeCapabilities, analyzeProjectCapabilities, analyzeCompiledCapabilities, assertTargetCompatibility, normalizeCapabilityTarget } from './capabilities.ts';
 export { capabilityDetails } from './capabilities.ts';
@@ -35,6 +30,8 @@ export { normalizeMatch, assertDisjointMatches, matchesRoute } from './condition
 export type { RouteMatch, ConditionRequest } from './conditions.ts';
 export { buildCloudflare } from './build-cloudflare.ts';
 export type { BuildOptions as CloudflareBuildOptions, BuildReport as CloudflareBuildReport } from './build-cloudflare.ts';
+export { buildStatic } from './build-static.ts';
+export type { BuildOptions as StaticBuildOptions, BuildReport as StaticBuildReport, StaticRedirect, StaticObject, RedirectManifest, ObjectManifest } from './build-static.ts';
 export { runProjectTests } from './project-tests.ts';
 export type { ProjectTestOptions, ProjectTestResult } from './project-tests.ts';
 export { scaffoldProject } from './scaffold.ts';

package/dist/types/manifest.d.ts

@@ -1,7 +1,7 @@
 import type { CapabilityName, CapabilityTarget } from './capabilities.ts';
 import type { InspectOptions } from './tooling.ts';
 import type { RouteExplanation } from './explain.ts';
-export declare const MANIFEST_SCHEMA_VERSION = 1;
+export declare const MANIFEST_SCHEMA_VERSION = 3;
 export interface ManifestRoute {
     path: string;
     methods: string[];
@@ -10,6 +10,10 @@ export interface ManifestRoute {
     expires?: string;
     generated?: string;
     description?: string;
+    /** Execution mode for the route's whole `function`/`middleware` chain: `true` for the
+     * QuickJS sandbox, `false` for trusted in-process execution. */
+    sandbox: boolean;
+    sandboxReason?: string;
     middleware: {
         source: string;
         export: string;
@@ -63,8 +67,6 @@ export interface Manifest {
             signals: string[];
         };
         extensions: string[];
-        linkStores: string[];
-        dynamicLinks: boolean;
     };
     functions: ManifestModule[];
     middleware: ManifestModule[];

package/dist/types/observability.d.ts

@@ -4,12 +4,8 @@ export declare const events: Readonly<{
     reload: readonly string[];
     watch: readonly string[];
     function_worker: readonly string[];
-    link_store_worker: readonly string[];
-    link_request: readonly string[];
-    link_observer: readonly string[];
     logs_dropped: readonly string[];
     observer: readonly string[];
-    management_request: readonly string[];
     throttle: readonly string[];
     agents: readonly string[];
     cache: readonly string[];
@@ -62,21 +58,12 @@ export interface MetricsSnapshot {
         healthySlots: number;
         slots: number;
     };
-    linkStoreWorkers: {
-        started: number;
-        restarts: number;
-    };
     policies: {
         throttle: Counters;
         agents: Counters;
         cache: Counters;
     };
     signals: Counters;
-    linkRequests: Counters;
-    linkObserver: {
-        failed: number;
-        dropped: number;
-    };
     logsDropped: number;
     observers: {
         errors: number;
@@ -99,7 +86,7 @@ export type ObserverSink = ((event: ObserverEvent, context?: RecordContext) => v
     close(): Promise<void>;
 };
 export declare function validateObservers(observers?: unknown): Observer[];
-export declare const SNAPSHOT_VERSION = 1;
+export declare const SNAPSHOT_VERSION = 2;
 export declare function createMetrics(): Metrics;
 export declare function createObserverSink(observers?: unknown, fallbackLog?: (event: ObserverEvent) => void, metrics?: Metrics): ObserverSink;
 export declare function renderPrometheus(snapshot: Partial<MetricsSnapshot>): string;

package/dist/types/project-tests.d.ts

@@ -5,11 +5,10 @@ export interface ProjectTestOptions {
     plugins?: ServerOptions['plugins'];
     log?: LogFn | undefined;
     permissions?: ServerOptions['permissions'];
-    linkStore?: ServerOptions['linkStore'];
     origin?: string | undefined;
 }
 export interface ProjectTestResult {
     total: number;
     failed: number;
 }
-export declare function runProjectTests(project: string, { log, permissions, linkStore, origin, extensions, plugins }?: ProjectTestOptions): Promise<ProjectTestResult>;
+export declare function runProjectTests(project: string, { log, permissions, origin, extensions, plugins }?: ProjectTestOptions): Promise<ProjectTestResult>;

package/dist/types/readiness.d.ts

@@ -4,10 +4,15 @@ import type { CompiledRedirect, CompiledRoute, LogFn, PlanInventoryEntry, Policy
 import type { ComplianceOptions, ComplianceReport } from './compliance.ts';
 import type { CompiledRoutes } from './match.ts';
 export type { RouteState } from './types.ts';
-export type HandlerName = 'extension' | 'proxy' | 'conditional' | 'redirect' | 'function' | 'page' | 'static' | 'download' | 'respond' | 'link';
+export type HandlerName = 'extension' | 'proxy' | 'conditional' | 'redirect' | 'function' | 'page' | 'static' | 'download' | 'respond';
 /** One configured route as the inventory reports it: a PlanInventoryEntry with the handler kind named. */
 export interface RouteInventory extends PlanInventoryEntry {
     handler: HandlerName | undefined;
+    /** Always reported here, so a trust change is visible in `routes` and its diff. */
+    sandbox: boolean;
+    /** Non-blocking `audit` observations about this route (e.g. a webhook-shaped
+     * route with no declared `sandbox`/`sandboxReason`); never affects `ready`. */
+    advisories?: string[];
 }
 /** One request case: a generated probe or a `tests/requests.json` fixture. */
 export interface RequestCase {
@@ -40,7 +45,6 @@ export interface AuditableApp {
     address: AddressInfo;
     root: string;
     testPlan(): ProjectPlan & {
-        dynamicLinks?: boolean;
         policies?: Record<string, PolicyInventory>;
     };
 }
@@ -51,7 +55,6 @@ export interface AuditOptions {
     compliance?: ComplianceOptions | undefined;
 }
 export interface AuditReport {
-    dynamicLinks: boolean | undefined;
     elapsedMs: number;
     ready: boolean;
     counts: {
@@ -74,6 +77,12 @@ export interface AuditReport {
     }[];
     policies: Record<string, PolicyInventory>;
     compliance: ComplianceReport | null;
+    /** Non-blocking `audit` observations, e.g. a route that looks webhook-shaped
+     * but declares neither `sandbox: true` nor `sandboxReason`. Never affects `ready`. */
+    advisories: {
+        route: string;
+        message: string;
+    }[];
 }
 export interface BenchmarkOptions {
     requests?: number | undefined;

package/dist/types/router.d.ts

@@ -1,3 +1,4 @@
+import type { RuntimeExtension } from './extensions.ts';
 import type { CompiledRouteTable, LoadedDocument } from './types.ts';
 export { parseTarget, matchRoute, contextFor, resolveValue, redirectLocation } from './match.ts';
 /** The grants compileRoutes consults: a validated OperatorPolicy (policy.ts) or nothing, which denies every binding. */
@@ -8,4 +9,4 @@ export interface BindingPermissions {
         secrets?: string[];
     }>;
 }
-export declare function compileRoutes(loaded: LoadedDocument, bindings: Record<string, string | undefined>, permissions?: BindingPermissions, projectSha256?: string): Promise<CompiledRouteTable>;
+export declare function compileRoutes(loaded: LoadedDocument, bindings: Record<string, string | undefined>, permissions?: BindingPermissions, projectSha256?: string, extensions?: readonly Pick<RuntimeExtension, 'name' | 'cacheSensitive'>[]): Promise<CompiledRouteTable>;

package/dist/types/runtime.d.ts

@@ -2,34 +2,15 @@ import type { RuntimeExtension } from './extensions.ts';
 import type { EgressDependencies } from './egress.ts';
 import type { ProjectPlan } from './readiness.ts';
 import type { OperatorPolicy } from './policy.ts';
-import type { LinkStoreOptions } from './link-store.ts';
 import type { Plugin } from './plugins.ts';
 import type { MetricsSnapshot, Observer } from './observability.ts';
 import type { HandlerResult, HeaderPair } from './http-response.ts';
 import type { LogFn, PolicyInventory, TargetName } from './types.ts';
-/** A stored link as a link store returns it; the runtime validates the fields it uses. */
-export interface LinkLookup {
-    url?: unknown;
-    status?: unknown;
-    enabled?: unknown;
-    expires?: unknown;
-}
-/** What a `linkStores` binding must provide: a reader and, optionally, its health. */
-export interface LinkReader {
-    get(collection: string, code: string): Promise<LinkLookup | null | undefined>;
-    readonly readHealthy?: boolean;
-    readonly healthy?: boolean;
-}
-/** An operator-owned SQLite link store the runtime opens read-only for one collection. */
-export interface LinkStoreBinding extends LinkStoreOptions {
-    collection: string;
-}
 export type { OperatorPolicy } from './policy.ts';
 /** An operator plugin (src/plugins.ts). */
 export type HostPlugin = Plugin;
 export type { Observer, MetricsSnapshot } from './observability.ts';
 export interface TestPlan extends ProjectPlan {
-    dynamicLinks: boolean;
     policies: Record<string, PolicyInventory>;
 }
 export interface RuntimeOptions {
@@ -42,8 +23,6 @@ export interface RuntimeOptions {
     local?: boolean | undefined;
     environment?: NodeJS.ProcessEnv | undefined;
     permissions?: OperatorPolicy | undefined;
-    linkStore?: LinkStoreBinding | undefined;
-    linkStores?: Record<string, LinkReader> | undefined;
     target?: TargetName | undefined;
     plugins?: HostPlugin[] | undefined;
     workers?: number | undefined;
@@ -57,16 +36,10 @@ export interface RuntimeOptions {
     only?: readonly string[] | undefined;
 }
 /** Per-request facts the host may read after handle() settles; never request text. */
-export interface LinkTrace {
-    collection: string;
-    code: string | null;
-    result: string;
-}
 export interface RequestTrace {
     route?: string;
     probe?: boolean;
     client?: string | null;
-    link?: LinkTrace;
 }
 export interface RuntimeRequest {
     target: string;

package/dist/types/sandbox.d.ts

@@ -0,0 +1,12 @@
+export { SandboxPool } from './functions.ts';
+export type { SandboxEntry, SandboxTarget, SandboxInvocation, SandboxPoolOptions, FunctionContext, FunctionResult, } from './functions.ts';
+export type { GuestRequestPayload, GuestResponsePayload } from './guest-api.ts';
+export type { HandlerResult, HeaderPair } from './http-response.ts';
+/**
+ * Resolves a project-relative hook source string the same way a native
+ * `function`/`middleware` route's `source` is resolved (`.mjs`/`.js` only, no
+ * path traversal outside the project root) into the absolute path
+ * `SandboxPool`'s entries and `execute()` targets expect. `root` must be the
+ * project's resolved directory (`ExtensionActivation.root`, never `cwd()`).
+ */
+export { functionFile } from './config.ts';

package/dist/types/scaffold.d.ts

@@ -1,11 +1,9 @@
 export interface Unresolved {
     path?: string;
     reason: string;
-    collection?: string;
 }
 export interface ScaffoldReport {
     dryRun: boolean;
-    dynamicLinks: boolean;
     created: string[];
     preserved: string[];
     unresolved: Unresolved[];

package/dist/types/server.d.ts

@@ -1,7 +1,6 @@
 import http from 'node:http';
 import type { AddressInfo } from 'node:net';
 import type { RuntimeOptions, TestPlan } from './runtime.ts';
-import type { LinkObserverStats } from './link-events.ts';
 import type { MetricsSnapshot, Observer } from './observability.ts';
 export interface ServerOptions extends Omit<RuntimeOptions, 'observers'> {
     project?: string | undefined;
@@ -13,7 +12,6 @@ export interface ServerOptions extends Omit<RuntimeOptions, 'observers'> {
     maxInFlightHealthRequests?: number | undefined;
     requestLog?: string | undefined;
     trustRequestId?: boolean | undefined;
-    linkEvents?: unknown;
     trustedProxies?: string | string[] | undefined;
     observers?: Observer[] | undefined;
     metrics?: boolean | undefined;
@@ -25,7 +23,6 @@ export interface Server {
     address: AddressInfo;
     root: string;
     testPlan(): TestPlan;
-    linkEventStats(): LinkObserverStats | undefined;
     metrics(): MetricsSnapshot;
     readonly observers: {
         name: string;
@@ -34,4 +31,4 @@ export interface Server {
     origin: string;
     close(): Promise<void>;
 }
-export declare function startServer({ project, host, port, watch, local, log, maxBodyBytes, maxInFlightRequests, maxInFlightHealthRequests, requestLog, trustRequestId, origin, linkEvents, trustedProxies, observers, metrics, metricsIntervalMs, ...runtimeOptions }?: ServerOptions): Promise<Server>;
+export declare function startServer({ project, host, port, watch, local, log, maxBodyBytes, maxInFlightRequests, maxInFlightHealthRequests, requestLog, trustRequestId, origin, trustedProxies, observers, metrics, metricsIntervalMs, ...runtimeOptions }?: ServerOptions): Promise<Server>;

package/dist/types/tooling.d.ts

@@ -39,14 +39,14 @@ export declare function inspectProject(project: string, options?: InspectOptions
         path: string;
         methods: string[];
         enabled: boolean;
-        capabilities: ("function" | "link" | "expires" | "middleware" | "extension" | "proxy" | "signals" | "conditional" | "methods" | "enabled" | "parameters" | "redirect" | "page" | "download" | "static" | "respond" | "dynamicLinks" | "policies.extensions" | "conditions" | "request.body" | "response.headers" | "bindings" | "policies.agents" | "policies.security" | "policies.cache" | "policies.compression" | "policies.throttle")[];
+        capabilities: ("function" | "expires" | "middleware" | "extension" | "proxy" | "signals" | "conditional" | "methods" | "enabled" | "parameters" | "redirect" | "page" | "download" | "static" | "respond" | "policies.extensions" | "conditions" | "request.body" | "response.headers" | "bindings" | "policies.agents" | "policies.security" | "policies.cache" | "policies.compression" | "policies.throttle")[];
     }[];
     compatibility: {
         offset: number;
         limit: number;
         hasMore: boolean;
         issues: import("./capabilities.ts").CapabilityRequirement[];
-        target: "vercel" | "aws" | "cloudflare" | "self-hosted";
+        target: "vercel" | "aws" | "cloudflare" | "static" | "self-hosted";
         compatible: boolean;
         deployment: "local-runtime" | "unverified";
         requirementCount: number;
@@ -58,7 +58,7 @@ export declare function validateProject(project: string, options?: InspectOption
     projectSha256: string;
     routeCount: number;
     compatibility: {
-        target: "vercel" | "aws" | "cloudflare" | "self-hosted";
+        target: "vercel" | "aws" | "cloudflare" | "static" | "self-hosted";
         compatible: boolean;
         deployment: "local-runtime" | "unverified";
         requirementCount: number;

package/dist/types/trusted-functions.d.ts

@@ -0,0 +1,29 @@
+import type { FunctionRoute } from './function-sources.ts';
+import type { FunctionContext, FunctionResult } from './functions.ts';
+import type { GuestRequestPayload } from './guest-api.ts';
+import type { HandlerResult } from './http-response.ts';
+import type { LogFn } from './types.ts';
+export interface TrustedFunctionsOptions {
+    timeoutMs?: number | undefined;
+    maxBytes?: number | undefined;
+    log?: LogFn | undefined;
+}
+interface TrustedDefinition {
+    source: string;
+    export: string;
+}
+export type TrustedRoute = FunctionRoute<TrustedDefinition>;
+export declare class TrustedFunctions {
+    timeoutMs: number;
+    maxBytes: number;
+    log: LogFn;
+    private readonly epoch;
+    constructor({ timeoutMs, maxBytes, log }?: TrustedFunctionsOptions);
+    start(routes: TrustedRoute[]): Promise<this>;
+    private loadExport;
+    execute(route: TrustedRoute, request: GuestRequestPayload, context: FunctionContext, native: HandlerResult | undefined): Promise<FunctionResult>;
+    private readBody;
+    private invoke;
+    close(): Promise<void>;
+}
+export {};

package/dist/types/types.d.ts

@@ -42,10 +42,6 @@ export type AuthoredRouteConfig = Omit<RouteConfig, 'function' | 'middleware'> &
     function?: string | FunctionConfig;
     middleware?: (string | MiddlewareConfig)[];
 };
-export interface LinkConfig {
-    collection: string;
-    code: ValueRef;
-}
 export interface PageConfig {
     file: string;
     contentType?: string;
@@ -151,6 +147,8 @@ export interface RouteAuthConfig {
 export interface RouteConfig {
     extension?: string;
     auth?: true | RouteAuthConfig;
+    /** Route-level `cache` short form: the same object accepted by `policies.cache`, expanded to it before anything else reads the project. */
+    cache?: CacheConfig;
     proxy?: ProxyConfig;
     signals?: SignalConfig[];
     match?: RouteMatch;
@@ -159,6 +157,18 @@ export interface RouteConfig {
     enabled?: boolean;
     expires?: string;
     description?: string;
+    /** Opt into the isolated QuickJS/WASM worker pool for this route's `function`/`middleware`
+     * chain (docs/FUNCTION-SECURITY.md). Default false: trusted, in-process, unsandboxed
+     * execution (docs/SPIKE-DEFAULT-TRUST-MODEL.md). Applies uniformly to the whole
+     * chain — `function` and any `middleware` on the same route run in the same mode. */
+    sandbox?: boolean;
+    /** Optional, human-authored justification for this route's sandbox decision — why it
+     * needs isolation when `sandbox: true`, or why it is safe to trust when it is not.
+     * Parsed and schema-validated (max 500 characters, schemas/urlcode.schema.json), stored
+     * on the compiled route and surfaced by `explain`/`context`/manifest next to `sandbox`.
+     * Never inferred or enforced: the trust decision remains the author's judgment call
+     * (docs/AI-AUTHORING.md, "Deciding when a route needs sandbox: true"). */
+    sandboxReason?: string;
     parameters?: ParameterConfig[];
     redirect?: RedirectConfig;
     function?: FunctionConfig;
@@ -175,7 +185,6 @@ export interface RouteConfig {
     };
     respond?: RespondSpec;
     middleware?: MiddlewareConfig[];
-    link?: LinkConfig;
     policies?: PoliciesConfig;
     /** Set by site.ts on a route it generated (`site.<key>`); never declared in YAML. */
     generated?: string;
@@ -185,7 +194,6 @@ export interface ProjectDocument {
     extensions?: Record<string, ExtensionDeclaration>;
     routes: Record<string, RouteConfig>;
     includes?: string[];
-    dynamicLinks?: boolean;
     policies?: PoliciesConfig;
     profiles?: Record<string, PolicyLayer>;
     site?: SiteConfig;
@@ -370,7 +378,7 @@ export type PolicyChain = {
     describe: PolicyInventory;
 } & Partial<PolicyStates>;
 export type RouteState = 'active' | 'disabled' | 'expired';
-/** One route in the audit inventory: its handler kind, methods and lifecycle state. */
+/** One route in the audit inventory: its handler kind, methods, execution mode and lifecycle state. */
 export interface PlanInventoryEntry {
     path: string;
     handler: string | undefined;
@@ -379,11 +387,17 @@ export interface PlanInventoryEntry {
     policies: string[];
     generated?: string;
     state: RouteState;
+    /** The route's execution mode: `true` when its `function`/`middleware` chain runs in the
+     * QuickJS sandbox, `false` when it runs trusted in-process. Route-level, because the mode
+     * applies to the whole chain — a native handler with `middleware` has one too. Optional
+     * only at the report-parsing boundary: reports written before it existed omit it. */
+    sandbox?: boolean;
+    /** The route's declared `sandboxReason`, when it has one. */
+    sandboxReason?: string;
 }
 export interface TestPlan {
     inventory: PlanInventoryEntry[];
     cases: unknown[];
     resolve?(path: string): string | undefined;
-    dynamicLinks?: boolean;
     policies?: Record<string, PolicyInventory>;
 }

package/dist/types/verify-deployment.d.ts

@@ -12,7 +12,7 @@ export interface VerifyFinding {
     expected?: string;
     observed?: string;
 }
-export interface VerifyOptions extends Pick<RuntimeOptions, 'permissions' | 'linkStore'> {
+export interface VerifyOptions extends Pick<RuntimeOptions, 'permissions'> {
     target: string;
     origin?: string | undefined;
     expectRoutes?: number | undefined;
@@ -44,4 +44,4 @@ export interface VerifyReport {
     compliance: ComplianceReport | null;
 }
 export declare const failLevels: readonly FailOn[];
-export declare function verifyDeployment(project: string, { target, origin, expectRoutes, timeoutMs, expectMetrics, failOn, compliance, complianceWarn, log, permissions, linkStore }: VerifyOptions): Promise<VerifyReport>;
+export declare function verifyDeployment(project: string, { target, origin, expectRoutes, timeoutMs, expectMetrics, failOn, compliance, complianceWarn, log, permissions }: VerifyOptions): Promise<VerifyReport>;