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

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 = 2;
 export interface ManifestRoute {
     path: string;
     methods: string[];
@@ -63,8 +63,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,13 @@ 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;
+    /** 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 +43,6 @@ export interface AuditableApp {
     address: AddressInfo;
     root: string;
     testPlan(): ProjectPlan & {
-        dynamicLinks?: boolean;
         policies?: Record<string, PolicyInventory>;
     };
 }
@@ -51,7 +53,6 @@ export interface AuditOptions {
     compliance?: ComplianceOptions | undefined;
 }
 export interface AuditReport {
-    dynamicLinks: boolean | undefined;
     elapsedMs: number;
     ready: boolean;
     counts: {
@@ -74,6 +75,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;
@@ -384,6 +392,5 @@ 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>;

package/dist/types.js

@@ -34,7 +34,6 @@
                                                                      
 /** A route as YAML may spell it before normalization: `function` and middleware entries may be short-form module paths. */
                                                                                                                                                                     
-                                                                  
                                                                                          
                                                                         
                                                                                                                 
@@ -67,19 +66,33 @@
                                                                                                                                                                                   
                               
                                                    
+                                                                                                                                             
+                      
                                               
                                                       
                                                                                 
+                                                                                             
+                                                                                       
+                                                                                  
+                                                                                       
+                    
+                                                                                       
+                                                                                     
+                                                                                          
+                                                                                          
+                                                                                      
+                                                                            
+                         
                                                                                        
                                                                             
                                                                       
                                                                                                      
-                                                                                                       
+                                                                                    
                                                                                        
                      
  
                                   
-                                                                                                                                                  
+                                                                                                                          
                                                                                        
  
 /** What config.ts returns: the entry document, the merged route table and the files it came from. */
@@ -192,5 +205,5 @@
  
                            
                                                                                                 
-                                                                     
+