@jimhoyd/urlcode 0.5.6 → 0.5.9

package/dist/http-response.js

@@ -5,18 +5,27 @@ import { HttpError } from './errors.js';
                                                                   
 /** What a handler, policy or asset produced; every host turns it into a wire response here. */
                                                                                                                      
-                                                                                                                  
-                                                                                                
-                                                                      
+                                                                                                           
+                                                                                         
+                                                               
 /** The node:http ServerResponse surface this module writes to, kept structural so the module stays Node-free. */
                                  
                                            
                                                                                                                            
                                                         
+                                
  
 
 // Hop-by-hop and runtime-owned headers a handler must never set on the wire.
 const forbiddenHeaders = new Set(['connection','keep-alive','transfer-encoding','content-length','upgrade','trailer','proxy-authenticate','proxy-authorization','te']);
+// Unlike Cache-Control (a real default a handler may explicitly override),
+// these two are always the runtime's own value, appended once below. A
+// handler-set copy of either (defense-in-depth code setting nosniff itself,
+// say) is dropped here rather than kept alongside the runtime's: now that
+// repeated headers are sent as separate wire lines instead of silently
+// collapsing to the last `setHeader` call, keeping both would put two
+// X-Content-Type-Options or X-Request-Id lines on the wire instead of one.
+const runtimeOwnedHeaders = new Set(['x-content-type-options','x-request-id']);
 
 // One place decides what a URLCode response *is*, independent of how a host
 // delivers it. A Node server writes it to a socket; a Lambda returns it as
@@ -27,7 +36,7 @@ export function prepareResponse(result               , { requestId, method }
   if (!Number.isInteger(status) || status < 200 || status > 599) throw new HttpError(502, 'Invalid function response');
   const headers               = [], cookies           = [];
   for (const [key,value] of result.headers) {
-    if (forbiddenHeaders.has(key.toLowerCase())) continue;
+    if (forbiddenHeaders.has(key.toLowerCase()) || runtimeOwnedHeaders.has(key.toLowerCase())) continue;
     validateHeaderName(key); validateHeaderValue(key,value);
     if (key.toLowerCase() === 'set-cookie') cookies.push(value);
     else headers.push([key,value]);
@@ -39,16 +48,57 @@ export function prepareResponse(result               , { requestId, method }
   // State the length rather than leaving a host to infer it. A Node server
   // computes this itself, but a host that returns JSON does not, so the policy
   // has to say it for every host to agree.
-  // HEAD states the length GET would send (RFC 9110 §8.6), so it is measured
-  // on the result's body before the body is dropped.
-  if (!bodyless) headers.push(['content-length', String(result.contentLength ?? (result.body?.length ?? 0))]);
+  // A response that carries its body is framed by the bytes it carries, never
+  // by a stated length. Only HEAD may state one, because it sends no body and
+  // reports the length GET would send (RFC 9110 §8.6); without a stated
+  // length it is measured on the result's body before the body is dropped.
+  if (!bodyless) headers.push(['content-length', String(method === 'HEAD' ? headLength(result) : byteLength(result.body))]);
   headers.push(['x-request-id',requestId],['x-content-type-options','nosniff']);
   if (!headers.some(([key]) => key.toLowerCase() === 'cache-control')) headers.push(['cache-control','no-store']);
   return { status, headers, cookies, body };
 }
+function headLength(result               )         {
+  if (result.contentLength === undefined) return byteLength(result.body);
+  if (!Number.isSafeInteger(result.contentLength) || result.contentLength < 0) throw new HttpError(502, 'Invalid function response');
+  return result.contentLength;
+}
+/** The UTF-8 bytes a body occupies on the wire; a string's `.length` counts UTF-16 units, not bytes. */
+export function byteLength(body              )         {
+  if (body === null || body === undefined) return 0;
+  if (typeof body !== 'string') return body.byteLength;
+  let bytes = 0;
+  for (let i = 0; i < body.length; i++) {
+    const code = body.charCodeAt(i);
+    if (code < 0x80) bytes += 1;
+    else if (code < 0x800) bytes += 2;
+    else if (code >= 0xd800 && code <= 0xdbff && i + 1 < body.length && (body.charCodeAt(i + 1) & 0xfc00) === 0xdc00) { bytes += 4; i++; }
+    else bytes += 3; // other BMP characters, and a lone surrogate encoded as U+FFFD
+  }
+  return bytes;
+}
+// `res.setHeader(name, value)` called twice for the same name (case
+// insensitively) replaces the first call rather than adding to it, so a
+// handler, policy or profile that legitimately repeats a header (`Link`,
+// `WWW-Authenticate`, a second `Vary` fragment produced upstream of this
+// module) would otherwise lose every value but the last on the wire. Group
+// by name first, in the case first seen, and hand Node the whole array; that
+// is the one call shape ResponseWriter#setHeader accepts for a repeated
+// header on every host this module writes to.
+function setGroupedHeaders(res                , headers                       )       {
+  const order           = [], grouped = new Map                  ();
+  for (const [key, value] of headers) {
+    const lower = key.toLowerCase();
+    const values = grouped.get(lower);
+    if (values) values.push(value);
+    else { grouped.set(lower, [value]); order.push(key); }
+  }
+  for (const key of order) { const values = grouped.get(key.toLowerCase()) ; res.setHeader(key, values.length === 1 ? values[0]  : values); }
+}
 export function writeResponse(res                , result               , options                 )         {
   const prepared = prepareResponse(result, options);
-  for (const [key,value] of prepared.headers) res.setHeader(key,value);
+  // Node then refuses to send a body whose size differs from the stated length.
+  res.strictContentLength = true;
+  setGroupedHeaders(res, prepared.headers);
   if (prepared.cookies.length) res.setHeader('set-cookie',prepared.cookies);
   res.statusCode = prepared.status;
   res.end(prepared.body);
@@ -70,14 +120,15 @@ export function errorResponse(error         , { requestId, method, headers = []
   const text = error instanceof HttpError && error.answer ? error.answer.text + '\n' : `${error instanceof HttpError ? String(error.message).replace(/[<>&"']/g, '') : 'Internal server error'}\n`;
   const body = method === 'HEAD' ? undefined : text;
   // Stated explicitly so every host agrees, as prepareResponse does for results.
-  return { status, headers: [...fixed, ['content-length', String(new TextEncoder().encode(text).length)], ...extra], body };
+  return { status, headers: [...fixed, ['content-length', String(byteLength(text))], ...extra], body };
 }
 export function writeError(res                , error         , options                                              )         {
   const prepared = errorResponse(error, options);
   if (res.headersSent) { res.destroy(); return prepared.status; }
   for (const key of res.getHeaderNames()) res.removeHeader(key);
-  for (const [key,value] of prepared.headers) res.setHeader(key,value);
+  setGroupedHeaders(res, prepared.headers);
   res.setHeader('connection','close');
+  res.strictContentLength = true;
   res.statusCode = prepared.status;
   res.end(prepared.body);
   return prepared.status;

package/dist/init-with.js

@@ -12,12 +12,13 @@ import { collectDependencySet, installSteps, renderPackageManifest } from './pro
                                                                               
 import { ConfigError, assert } from './errors.js';
 import { installBundle, loadExtensionBundle,                      } from './extension-bundles.js';
+import { isRecord as record, isCode } from './object-guards.js';
 
 /** Directory names inside the generated site. The route project lives under `app/`; everything else is operator-owned. */
 const PROJECT_DIRECTORY = 'app', HOST_FILE = 'host.mjs', ROUTES_FILE = 'routes/extensions.yaml';
 const acknowledgementPattern = /^[a-z][a-z0-9-]{0,63}:[a-z][a-z0-9-]{0,63}$/;
 const namePattern = /^[a-z][a-z0-9-]{0,63}$/, capabilityPattern = /^[a-z][a-z0-9.:-]{0,63}$/;
-                                  
+                           
                            
                                                                                                  
                                  
@@ -30,7 +31,7 @@ const namePattern = /^[a-z][a-z0-9-]{0,63}$/, capabilityPattern = /^[a-z][a-z0-9
                                                                                         
                                                 
  
-                                                                                                                                                                                         
+                                                                                                                                                                                  
 
 export function parseWithNames(value        )           {
   const names = value.split(',').map(name => name.trim());
@@ -39,16 +40,14 @@ export function parseWithNames(value        )           {
   return names;
 }
 const packageName = (name        )         => `@jimhoyd/urlcode-${name}`;
-const isCode = (error         , code        )          => error instanceof Error && 'code' in error && error.code === code;
 const strings = (value         )                    => Array.isArray(value) && value.every(item => typeof item === 'string');
-const record = (value         )                                   => value !== null && typeof value === 'object' && !Array.isArray(value);
 
 /**
  * Orders the requested set from the scaffolds' declared `requires`, `after`, `provides` and `conflicts`, never from
  * the `--with` spelling. Kahn's algorithm with the lexically smallest ready extension first, so the result is
  * deterministic and identical for every permutation. Refuses a missing requirement, a conflict or a cycle by name.
  */
-export function orderScaffolds(results                           )                   {
+function orderScaffolds(results                           )                   {
   const byName = new Map                        (), providers = new Map                ();
   for (const result of results) byName.set(result.name, result);
   for (const result of results) for (const capability of result.provides ?? []) {
@@ -248,10 +247,11 @@ export async function initProjectWith(destination        , requested
       for (const key of Object.keys(extensions)) assert(!Object.hasOwn(loaded.document.extensions ?? {}, key), `Extension ${key} from ${owners.get('e:' + key)} already exists in the starter`);
       const yamlFile = join(project, 'urlcode.yaml'), original = await readFile(yamlFile, 'utf8');
       const doc = parseDocument(original);
-      // Extensions are declared in the entry file; their routes go into a last include so the starter's own routes
-      // stay first in the loaded order and the entry file stays small.
+      // Extensions are declared in the entry file; their routes go into a last include.
+      // The bare starter has no includes until an extension needs one.
       doc.set('extensions', { ...loaded.document.extensions, ...extensions });
-      doc.addIn(['includes'], ROUTES_FILE);
+      if (doc.has('includes')) doc.addIn(['includes'], ROUTES_FILE);
+      else doc.set('includes', [ROUTES_FILE]);
       const fragment = stringify({ version: '1', routes });
       validateDocument(doc.toJS()); validateDocument(parseYaml(fragment));
       const notes = results.flatMap(result => (result.routeNotes ?? []).map(note => `# ${result.name}: ${note}\n`)).join('');

package/dist/interchange.js

@@ -1,6 +1,7 @@
 import { stringify } from 'yaml';
 import { parseYaml, validateDocument, MAX_CONFIG_BYTES } from './config.js';
 import { compileRoutes } from './router.js';
+import { isRecord } from './object-guards.js';
                                                                                
 
                                                                                                                
@@ -17,8 +18,8 @@ const formats = new Set(['csv','json','yaml','netlify','cloudflare','vercel','ne
 const providers = new Set(['netlify','cloudflare','vercel','netlify-toml']);
 const statuses = new Set([301,302,303,307,308]);
 function record(value         )                          {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Expected an object');
-  return value                           ;
+  if (!isRecord(value)) throw new Error('Expected an object');
+  return value;
 }
 function keys(value                         , allowed          )       {
   if (Object.keys(value).some(key => !allowed.includes(key))) throw new Error('Unsupported field; conversion would discard behavior');

package/dist/logging.js

@@ -1,9 +1,5 @@
-                                                 
-/** What the logger needs from its sink: the members of a Writable it touches. process.stdout satisfies it. */
-                                                                                                                                                           
 // Bound buffered operational output when the log collector cannot keep up.
 // Dropped records are counted and reported when output becomes writable again.
-const sinkStates = new WeakMap                              ();
 export function createJsonLogger(stream          = process.stdout, maxBufferBytes = 1048576)             {
   let state=sinkStates.get(stream);
   if(!state){const created={failed:false};state=created;sinkStates.set(stream,created);stream.on?.('error',()=>{created.failed=true;});}
@@ -20,3 +16,7 @@ export function createJsonLogger(stream          = process.stdout, maxBufferByte
     } catch {sink.failed=true;dropped++;}
   };
 }
+                                          
+/** What the logger needs from its sink: the members of a Writable it touches. process.stdout satisfies it. */
+                                                                                                                                                    
+const sinkStates = new WeakMap                              ();

package/dist/match.js

@@ -5,7 +5,7 @@
 import { HttpError } from './errors.js';
 
                                                             
-                                                                     
+                                                              
                                                
 /** A parsed scalar, a parsed array, or a schema default (which the schema may shape freely). */
                                                          

package/dist/mcp-authoring.js

@@ -8,6 +8,7 @@ import {compileRoutes} from './router.js';
 import {prepareFunctionSnapshot,requestedPermissions} from './policy.js';
 import {validateProject} from './tooling.js';
 import {scaffoldProject} from './scaffold.js';
+import {isRecord as object, isCode} from './object-guards.js';
 import {addRecipe} from './recipes.js';
 import {authoringPath} from './authoring-files.js';
 import {assert} from './errors.js';
@@ -31,7 +32,6 @@ export const authoringDefinitions=[
  {name:'run_test',description:'Run `urlcode test` against the project (activates the local runtime and executes fixtures); returns exit code and bounded output.',properties:{},required:[]},
  {name:'run_audit',description:'Run `urlcode audit` against the project; returns exit code and bounded output.',properties:{},required:[]},
 ];
-const isCode=(error        ,code       )        =>error instanceof Error&&'code' in error&&error.code===code;
 // Operator-owned material never lives under an authoring write, even when an
 // operator mistakenly placed it in the checkout.
 const operatorFile=/^(?:.*policy.*\.json|.*compliance.*\.(?:json|mjs|js|cjs|ts)|host(?:-file)?\.(?:mjs|js|cjs|ts)|.*\.(?:sqlite3?|db)(?:-wal|-shm|-journal)?|urlcode\.yaml\.lock)$/i;
@@ -53,7 +53,6 @@ async function verdict(root       ,origin        ) {
  try{return await validateProject(root,origin?{origin}:{});}
  catch{return {valid:false         ,note:'Project does not validate; call run_validate for the CLI report.'};}
 }
-function object(value        )                                {return value!==null&&typeof value==='object'&&!Array.isArray(value);}
 function expandHandler(handler        )                        {
  if(object(handler))return handler;
  assert(typeof handler==='string','Handler must be a route object or a short form');

package/dist/mcp.js

@@ -7,7 +7,11 @@ import {loadOperatorHost} from './operator-host.js';
 import {buildManifest} from './manifest.js';
                                                         
 import {authoringDefinitions,callAuthoringTool} from './mcp-authoring.js';
-import {listSkills,getSkill,searchDocs,getExample,validateYaml,explainError} from './agent-context.js';
+// Imported through the public subpath, not a relative path into this module's own
+// package, to prove @jimhoyd/urlcode/agent-context is sufficient for the framework's
+// own MCP server rather than a documentation-only promise (see docs/TOOLING.md).
+import {listSkills,getSkill,searchDocs,getExample,validateYaml,explainError} from '@jimhoyd/urlcode/agent-context';
+import {isRecord as object} from './object-guards.js';
 import {describeArtifactCache,readArtifactMember} from './extension-artifacts.js';
 const protocolVersion='2025-11-25';
 const maxBytes=1048576;
@@ -46,7 +50,6 @@ const readTools=definitions.map(def=>({name:def.name,description:def.description
 const hostTool={name:hostDefinition.name,description:hostDefinition.description,inputSchema:{type:'object',properties:hostDefinition.properties,required:[],additionalProperties:false},annotations:{readOnlyHint:true,destructiveHint:false,openWorldHint:false}};
 const authoringTools=authoringDefinitions.map(def=>({name:def.name,description:def.description,inputSchema:{type:'object',properties:def.properties,required:def.required,additionalProperties:false},annotations:{readOnlyHint:false,destructiveHint:false,openWorldHint:false}}));
 const validators=new Map([...readTools,hostTool,...authoringTools].map(tool=>[tool.name,ajv.compile(tool.inputSchema)]));
-function object(value        )                                {return value!==null&&typeof value==='object'&&!Array.isArray(value);}
 /** `allowAuthoring` and `hostFile` are set only by the `--allow-authoring` and `--host-file` command-line flags; tool arguments and the environment never enable them. */
                                                                                                                                      
 /** Operator selects the only project root. Read tools have no path, credential, write or execution authority; authoring tools write inside that root only. */
@@ -102,7 +105,7 @@ export async function serveMcp(options           )               {
   if(message.method==='initialize') {
    if(initialized){await error(id,-32600,'Already initialized');return;}
    if(typeof params.protocolVersion!=='string'||!object(params.capabilities)||!object(params.clientInfo)||typeof params.clientInfo.name!=='string'||typeof params.clientInfo.version!=='string'){await error(id,-32602,'Invalid initialize params');return;}
-   initialized=true;await send({jsonrpc:'2.0',id,result:{protocolVersion,capabilities:{tools:{}},serverInfo:{name:'urlcode',version:'0.5.6'}}});return;
+   initialized=true;await send({jsonrpc:'2.0',id,result:{protocolVersion,capabilities:{tools:{}},serverInfo:{name:'urlcode',version:'0.5.9'}}});return;
   }
   if(message.method==='ping'){await send({jsonrpc:'2.0',id,result:{}});return;}
   if(!ready){await error(id,-32002,'Initialize first');return;}

package/dist/object-guards.js

@@ -0,0 +1,17 @@
+// Small, dependency-free predicates shared across the runtime and its
+// scripts. Kept separate from extension-transport.ts, which owns GitHub
+// release/cache/lockfile plumbing (and imports Node-only modules) rather
+// than generic object checks; router.ts and body-schema.ts reach this file
+// instead so a Worker/edge bundle never pulls in Node builtins through it.
+
+                                                    
+/** True for a non-null, non-array object -- the shape most parsed JSON/YAML fields expect. */
+export const isRecord = (value         )                         =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+/** True for a `key` that `object` itself declares (not inherited). */
+export const own = (object        , key        )          => Object.hasOwn(object, key);
+
+/** True when `error` is a Node `Error` carrying the given `code` (e.g. `'ENOENT'`). */
+export const isCode = (error         , code        )          =>
+  error instanceof Error && 'code' in error && error.code === code;

package/dist/pattern-guard.js

@@ -1,6 +1,6 @@
 import { assert } from './errors.js';
 
-export const maxPatternLength = 128;
+const maxPatternLength = 128;
 export const maxPatternInputLength = 128;
 const maxUnboundedQuantifiers = 3;
 
@@ -15,6 +15,14 @@ export function assertSafePattern(pattern        )       {
   assert(pattern.length > 0 && pattern.length <= maxPatternLength, `Pattern must be 1 to ${maxPatternLength} characters`);
   try { new RegExp(pattern, 'u'); } catch { assert(false, 'Invalid pattern'); }
   let unbounded = 0, inClass = false;
+  // One entry per currently open group, true once its body has shown a
+  // quantifier (`*+?{n,m}`) or a top-level alternation `|`. A *bounded*
+  // repeat of such a group (`(a+){2,3}`, `(a|b){2,3}`) still lets the
+  // backtracker retry each of the `n` copies against every inner
+  // possibility, which is super-linear even though the outer bound is
+  // finite; only a group with a genuinely flat body may be bound-repeated.
+  const groups            = [];
+  const markQuantifier = ()       => { if (groups.length) groups[groups.length - 1] = true; };
   for (let i = 0; i < pattern.length; i++) {
     const char = pattern[i] ;
     if (char === '\\') {
@@ -24,8 +32,30 @@ export function assertSafePattern(pattern        )       {
     }
     if (inClass) { if (char === ']') inClass = false; continue; }
     if (char === '[') { inClass = true; continue; }
-    if (char === '(') assert(!/^\(\?<?[=!]/.test(pattern.slice(i, i + 4)), 'Pattern lookaround is not supported');
-    if (char === ')') assert(!/^(?:[*+]|\{\d+,\})/.test(pattern.slice(i + 1)), 'Pattern cannot repeat a group without a bound');
+    if (char === '|') { markQuantifier(); continue; }
+    if (char === '(') {
+      assert(!/^\(\?<?[=!]/.test(pattern.slice(i, i + 4)), 'Pattern lookaround is not supported');
+      groups.push(false);
+      // Skip past `(?:` and `(?<name>` group syntax so its `?` (and the
+      // name's own characters) are never mistaken for a body quantifier.
+      if (pattern[i + 1] === '?') {
+        if (pattern[i + 2] === ':') i += 2;
+        else if (pattern[i + 2] === '<') { const end = pattern.indexOf('>', i + 3); i = end === -1 ? i + 2 : end; }
+        else i += 1;
+      }
+      continue;
+    }
+    if (char === ')') {
+      const hadInnerQuantifier = groups.pop() ?? false;
+      const rest = pattern.slice(i + 1);
+      const unboundedRepeat = /^(?:[*+]|\{\d+,\})/.test(rest);
+      const boundedRepeat = !unboundedRepeat && /^\{\d+(,\d+)?\}/.test(rest);
+      assert(!unboundedRepeat, 'Pattern cannot repeat a group without a bound');
+      assert(!(boundedRepeat && hadInnerQuantifier), 'Pattern cannot bound-repeat a group that contains a quantifier or alternation');
+      if (boundedRepeat) markQuantifier();
+      continue;
+    }
+    if (char === '*' || char === '+' || char === '?' || (char === '{' && /^\{\d+(,\d*)?\}/.test(pattern.slice(i)))) markQuantifier();
     if (char === '*' || char === '+' || (char === '{' && /^\{\d+,\}/.test(pattern.slice(i)))) unbounded++;
   }
   assert(unbounded <= maxUnboundedQuantifiers, `Pattern allows at most ${maxUnboundedQuantifiers} unbounded quantifiers`);

package/dist/policies/cache.js

@@ -14,15 +14,15 @@ import { assert, ConfigError } from '../errors.js';
 export const name = 'cache';
 export const phases                    = ['request','response'];
 
-                                                                                                                             
+                                                                                                                      
                               
                                                                                                                                     
                                                                                                 
  
 /** A stored 200 representation: the result minus its body and headers, which are kept separately. */
-                                                                                                                                                             
+                                                                                                                                                      
 /** The in-flight fill for one key; waiters share its promise up to MAX_WAITERS. */
-                                                                                                                                                             
+                                                                                                                                                      
 /** The one origin cache per runtime, shared by every route with an origin-caching strategy. */
                                                                                                                                                   
                              
@@ -240,6 +240,14 @@ export function onResponse(state            , req               , result
   // no-store (a personalized answer under a public route stays private).
   const restrictive = directive(handlerControl, 'no-store') || directive(handlerControl, 'private');
   const owned = !state.yamlCacheControl && !state.inheritedAsset && !restrictive;
+  // The handler's own Vary, read before the declared names are merged in: the
+  // cache key only ever covers `state.vary`, so a handler that names another
+  // header (or `*`) has a representation this key cannot distinguish, and
+  // storing it would serve that variant to every caller regardless of what
+  // they actually sent for the undeclared header.
+  const handlerVaryNames = (header(result.headers, 'vary') || '').split(',').map(v => v.trim().toLowerCase()).filter(Boolean);
+  const declaredVary = new Set(state.vary);
+  const undeclaredVary = handlerVaryNames.some(name => name === '*' || !declaredVary.has(name));
   let headers = result.headers;
   if (owned) {
     headers = [...without(headers, 'cache-control', 'cdn-cache-control'), ['cache-control', state.cacheControl]];
@@ -255,7 +263,7 @@ export function onResponse(state            , req               , result
   // released either way, with the entry or with nothing.
   const { store } = state, body = bodyOf(out);
   const storable = !req.secrets && state.statuses.has(out.status) && !restrictive && body.length <= state.maxBytes
-    && !out.headers.some(([k]) => String(k).toLowerCase() === 'set-cookie');
+    && !out.headers.some(([k]) => String(k).toLowerCase() === 'set-cookie') && !undeclaredVary;
   let entry                    = null;
   if (storable) {
     const previous = store.entries.get(flight.key);
@@ -265,6 +273,10 @@ export function onResponse(state            , req               , result
     store.entries.set(flight.key, entry); store.bytes += body.length;
     evict(store, state.maxEntries);
     log(state, 'store');
+  } else if (undeclaredVary) {
+    // A distinct bypass reason from a plain miss/no-store, so an operator can
+    // see a route whose handler needs its own `Vary` name added to the policy.
+    log(state, 'vary-bypass');
   }
   store.pending.delete(flight.key);
   flight.flight.resolve(entry);

package/dist/policies/compression.js

@@ -14,7 +14,7 @@ import { assert, ConfigError } from '../errors.js';
 export const name = 'compression';
 export const phases                    = ['response'];
 
-                                                        
+                                                 
                                                                                                                                             
                                                     
                                    

package/dist/policies/throttle.js

@@ -11,7 +11,7 @@ import { assert } from '../errors.js';
 // group; multi-instance sharing is a plugin concern.
 export const name = 'throttle';
 export const phases                    = ['request','response'];
-                                                            
+                                                     
                                                                                                                                                         
                                                                     
 /** The one counter table per runtime, shared by every route that declares a throttle. */

package/dist/policy.js

@@ -8,12 +8,12 @@ import { collectFunctionSources, collectTrustedSources, routeFunctions } from '.
 import { assert } from './errors.js';
                                                  
 
-                                                                    
-                                                                                      
+                                                             
+                                                                               
 /** The operator's binding grants: which env and secret names each route may read, pinned to a project hash. */
                                                                                                          
 /** The function snapshot plus the hash operator grants are pinned to. */
-                                                                                   
+                                                                            
 
 export async function prepareFunctionSnapshot(loaded                )                            {
   // Only `sandbox: true` routes are bundled into the QuickJS module snapshot

package/dist/prerender.js

@@ -5,6 +5,7 @@ import {loadDocument, functionFile} from './config.js';
 import {applySite} from './site.js';
 import {collectFunctionSources, routeFunctions, MODULE_LIMIT, TOTAL_BYTE_LIMIT} from './function-sources.js';
 import {ConfigError, assert} from './errors.js';
+import {isCode} from './object-guards.js';
                                                                 
                                       
 
@@ -38,8 +39,6 @@ const overlaps = (first        , second        )          => {
   const rel = relative(first, second);
   return rel === '' || !(isAbsolute(rel) || rel === '..' || rel.startsWith('..' + sep));
 };
-const isCode = (error         , code        )          => error instanceof Error && 'code' in error && error.code === code;
-
 // One route path to one flat filename, deterministically. `~` cannot occur in a
 // route segment, so it separates segments unambiguously: `/a/b` and `/a-b` are
 // distinct names rather than a silent collision. The root becomes `index`, and a

package/dist/project-dependencies.js

@@ -2,6 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ConfigError, assert } from './errors.js';
+import { isRecord as record } from './object-guards.js';
 
 /**
  * Exact dependency pins for a generated application.
@@ -17,13 +18,13 @@ import { ConfigError, assert } from './errors.js';
  * a name the caller supplied -- so core's generic extension boundary is unchanged.
  */
 
-export const CORE_PACKAGE = '@jimhoyd/urlcode';
+const CORE_PACKAGE = '@jimhoyd/urlcode';
 const namePattern = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
 
                                                                                                     
 const versionPattern = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
 
-export function parseVersion(value        )                 {
+function parseVersion(value        )                 {
   const match = versionPattern.exec(value.trim());
   if (!match) return null;
   const pre = match[4] === undefined ? [] : match[4].split('.').map(part => /^\d+$/.test(part) ? Number(part) : part);
@@ -44,7 +45,7 @@ function comparePre(a                              , b
   }
   return 0;
 }
-export function compareVersions(a         , b         )         {
+function compareVersions(a         , b         )         {
   for (const key of ['major', 'minor', 'patch']         ) if (a[key] !== b[key]) return a[key] < b[key] ? -1 : 1;
   return comparePre(a.pre, b.pre);
 }
@@ -101,12 +102,11 @@ export function satisfiesRange(version        , range        , context = 'peer r
   });
 }
 
-                                   
+                            
                                                    
                                                                                               
  
                                                                                                                                           
-const record = (value         )                                   => value !== null && typeof value === 'object' && !Array.isArray(value);
 const strings = (value         )                         => {
   const out                         = {};
   if (record(value)) for (const [key, item] of Object.entries(value)) if (typeof item === 'string') out[key] = item;
@@ -128,7 +128,7 @@ async function readManifest(file        )                                   {
  * means a package whose `exports` does not expose `./package.json` is still inspectable, and nothing in the
  * package is loaded or executed.
  */
-export async function findInstalledPackage(name        , from        )                                   {
+async function findInstalledPackage(name        , from        )                                   {
   assert(namePattern.test(name), `Invalid package name: ${name}`);
   let directory = resolve(from);
   for (;;) {
@@ -140,7 +140,7 @@ export async function findInstalledPackage(name        , from        )
   }
 }
 /** The version of the runtime executing this command; that is the version a generated site is pinned to. */
-export async function runningCore()                            {
+async function runningCore()                            {
   const file = fileURLToPath(new URL('../package.json', import.meta.url));
   const manifest = await readManifest(file);
   assert(manifest && manifest.name === CORE_PACKAGE, `Could not read the running runtime manifest at ${file}`);
@@ -185,7 +185,7 @@ async function localSpecifiers(cwd        )                               {
                                                              
                  
  
-                                    
+                             
                            
                                                                                                      
                                                       

package/dist/proxy.js

@@ -1,7 +1,7 @@
 import { EgressError, egressUrl, safeEgressHeaders } from './egress.js';
                                                                  
                                                                                                                                                      
-                                                                                                                                                                            
+                                                                                                                                                                     
                                                                                          
 const sensitive=new Set(['authorization','cookie','set-cookie','proxy-authorization','forwarded','x-forwarded-for','x-forwarded-host','x-forwarded-proto']);
 export function validateProxy(definition                )      {