foldkit 0.147.0 → 0.148.0

package/dist/domReflection.js

@@ -0,0 +1,557 @@
+import { CSS_STYLE_PROPERTIES } from './cssStyleProperties.js';
+// The one description of how a typed attribute builder's DOM property relates
+// to the HTML attribute it is named after.
+//
+// Two mechanisms read this. A server render turns the property into attribute
+// text a parser will read back, and a client render assigns the property to a
+// live element. They agree only where the property is a reflecting IDL
+// attribute of that element, so the same tables decide what the serializer
+// emits and what the builders refuse to build. Keeping one copy is what stops
+// the two from drifting: a property added to the serializer alone would be
+// served as markup no client render reproduces.
+/** DOM properties whose attribute is present or absent rather than valued.
+ *
+ * @internal */
+export const BOOLEAN_PROPERTIES = new Set([
+    'autofocus',
+    'autoplay',
+    'checked',
+    'controls',
+    'disabled',
+    'formNoValidate',
+    'hidden',
+    'inert',
+    'isMap',
+    'loop',
+    'multiple',
+    'muted',
+    'noValidate',
+    'open',
+    'playsInline',
+    'readOnly',
+    'required',
+    'reversed',
+    'selected',
+]);
+/** DOM properties whose name differs from the attribute they reflect.
+ *
+ * @internal */
+export const RENAMED_PROPERTY_ATTRIBUTES = {
+    colSpan: 'colspan',
+    dateTime: 'datetime',
+    formAction: 'formaction',
+    formEnctype: 'formenctype',
+    formMethod: 'formmethod',
+    formNoValidate: 'formnovalidate',
+    formTarget: 'formtarget',
+    htmlFor: 'for',
+    isMap: 'ismap',
+    maxLength: 'maxlength',
+    minLength: 'minlength',
+    noValidate: 'novalidate',
+    playsInline: 'playsinline',
+    readOnly: 'readonly',
+    rowSpan: 'rowspan',
+    tabIndex: 'tabindex',
+};
+/** DOM properties whose value is written as the same-named attribute verbatim.
+ *
+ * @internal */
+export const PASSTHROUGH_PROPERTIES = new Set([
+    'accept',
+    'action',
+    'alt',
+    'autocomplete',
+    'cite',
+    'cols',
+    'dir',
+    'download',
+    'enctype',
+    'high',
+    'href',
+    'id',
+    'label',
+    'lang',
+    'low',
+    'max',
+    'method',
+    'min',
+    'name',
+    'optimum',
+    'pattern',
+    'placeholder',
+    'poster',
+    'preload',
+    'rel',
+    'rows',
+    'size',
+    'span',
+    'src',
+    'start',
+    'step',
+    'target',
+    'title',
+    'type',
+    'value',
+    'wrap',
+]);
+/** The property names that are universal HTML global attributes.
+ *
+ * @internal */
+export const GLOBAL_ATTRIBUTE_PROPERTIES = new Set([
+    'autofocus',
+    'id',
+    'title',
+    'lang',
+    'dir',
+    'tabIndex',
+    'hidden',
+    'inert',
+    'draggable',
+]);
+// The properties an SVG or MathML element carries as reflecting IDL attributes,
+// so that assigning one on the client leaves the element in the state parsing
+// the served attribute produces.
+//
+// Everything else is an HTML interface member the foreign element does not
+// have. Assigning `title` or `href` to an SVG element sets an expando or, since
+// bundled code is strict, throws on a readonly `SVGAnimatedString`, while the
+// serializer would have written an attribute; the two never agree. Measured in
+// Chromium across the whole table above on `svg:a`, `svg:rect`, and
+// `math:mtext`: these three reflect on all of them and nothing else reflects on
+// any of them.
+/** @internal */
+export const FOREIGN_REPRESENTABLE_PROPERTIES = new Set([
+    'autofocus',
+    'id',
+    'tabIndex',
+]);
+/** The HTML attribute a typed builder's DOM property reflects, or `undefined`
+ *  when the property is not one the tables above describe.
+ *
+ * @internal */
+export const reflectedAttributeName = (propertyName) => {
+    const renamed = RENAMED_PROPERTY_ATTRIBUTES[propertyName];
+    if (renamed !== undefined) {
+        return renamed;
+    }
+    if (BOOLEAN_PROPERTIES.has(propertyName) ||
+        PASSTHROUGH_PROPERTIES.has(propertyName) ||
+        propertyName === 'draggable') {
+        return propertyName;
+    }
+    return undefined;
+};
+// HTML attribute names are ASCII case-insensitive: a parser lowercases them,
+// and `setAttribute` on an HTML element does the same. `h.Attribute('MULTIPLE',
+// '')` and `h.Attribute('multiple', '')` therefore name one attribute, and any
+// analysis that compares names verbatim reads the first as an unrelated one.
+// Foreign content is left alone, where `viewBox` and `preserveAspectRatio` are
+// case-sensitive names of their own.
+const ASCII_UPPER = /[A-Z]/g;
+/** @internal */
+export const toHtmlAttributeName = (name) => name.replace(ASCII_UPPER, letter => letter.toLowerCase());
+const SVG_ATTRIBUTE_ADJUSTMENTS = {
+    attributename: 'attributeName',
+    attributetype: 'attributeType',
+    basefrequency: 'baseFrequency',
+    baseprofile: 'baseProfile',
+    calcmode: 'calcMode',
+    clippathunits: 'clipPathUnits',
+    diffuseconstant: 'diffuseConstant',
+    edgemode: 'edgeMode',
+    filterunits: 'filterUnits',
+    glyphref: 'glyphRef',
+    gradienttransform: 'gradientTransform',
+    gradientunits: 'gradientUnits',
+    kernelmatrix: 'kernelMatrix',
+    kernelunitlength: 'kernelUnitLength',
+    keypoints: 'keyPoints',
+    keysplines: 'keySplines',
+    keytimes: 'keyTimes',
+    lengthadjust: 'lengthAdjust',
+    limitingconeangle: 'limitingConeAngle',
+    markerheight: 'markerHeight',
+    markerunits: 'markerUnits',
+    markerwidth: 'markerWidth',
+    maskcontentunits: 'maskContentUnits',
+    maskunits: 'maskUnits',
+    numoctaves: 'numOctaves',
+    pathlength: 'pathLength',
+    patterncontentunits: 'patternContentUnits',
+    patterntransform: 'patternTransform',
+    patternunits: 'patternUnits',
+    pointsatx: 'pointsAtX',
+    pointsaty: 'pointsAtY',
+    pointsatz: 'pointsAtZ',
+    preservealpha: 'preserveAlpha',
+    preserveaspectratio: 'preserveAspectRatio',
+    primitiveunits: 'primitiveUnits',
+    refx: 'refX',
+    refy: 'refY',
+    repeatcount: 'repeatCount',
+    repeatdur: 'repeatDur',
+    requiredextensions: 'requiredExtensions',
+    requiredfeatures: 'requiredFeatures',
+    specularconstant: 'specularConstant',
+    specularexponent: 'specularExponent',
+    spreadmethod: 'spreadMethod',
+    startoffset: 'startOffset',
+    stddeviation: 'stdDeviation',
+    stitchtiles: 'stitchTiles',
+    surfacescale: 'surfaceScale',
+    systemlanguage: 'systemLanguage',
+    tablevalues: 'tableValues',
+    targetx: 'targetX',
+    targety: 'targetY',
+    textlength: 'textLength',
+    viewbox: 'viewBox',
+    viewtarget: 'viewTarget',
+    xchannelselector: 'xChannelSelector',
+    ychannelselector: 'yChannelSelector',
+    zoomandpan: 'zoomAndPan',
+};
+export const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
+export const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+export const MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+/** The attribute name produced by parsing HTML source in the given namespace.
+ *
+ * @internal
+ */
+export const parsedAttributeName = (namespace, name) => {
+    const lowerName = toHtmlAttributeName(name);
+    if (namespace === SVG_NAMESPACE) {
+        return SVG_ATTRIBUTE_ADJUSTMENTS[lowerName] ?? lowerName;
+    }
+    if (namespace === MATHML_NAMESPACE && lowerName === 'definitionurl') {
+        return 'definitionURL';
+    }
+    return lowerName;
+};
+const HTML_PROPERTY_ELEMENTS = {
+    accept: new Set(['input']),
+    action: new Set(['form']),
+    alt: new Set(['area', 'img', 'input']),
+    autocomplete: new Set(['form', 'input', 'select', 'textarea']),
+    autoplay: new Set(['audio', 'video']),
+    checked: new Set(['input']),
+    cite: new Set(['blockquote', 'del', 'ins', 'q']),
+    cols: new Set(['textarea']),
+    colSpan: new Set(['td', 'th']),
+    controls: new Set(['audio', 'video']),
+    dateTime: new Set(['del', 'ins', 'time']),
+    disabled: new Set([
+        'button',
+        'fieldset',
+        'input',
+        'link',
+        'optgroup',
+        'option',
+        'select',
+        'textarea',
+    ]),
+    download: new Set(['a', 'area']),
+    enctype: new Set(['form']),
+    formAction: new Set(['button', 'input']),
+    formEnctype: new Set(['button', 'input']),
+    formMethod: new Set(['button', 'input']),
+    formNoValidate: new Set(['button', 'input']),
+    formTarget: new Set(['button', 'input']),
+    high: new Set(['meter']),
+    href: new Set(['a', 'area', 'base', 'link']),
+    htmlFor: new Set(['label', 'output', 'script']),
+    isMap: new Set(['img']),
+    label: new Set(['optgroup', 'option', 'track']),
+    loop: new Set(['audio', 'video']),
+    low: new Set(['meter']),
+    max: new Set(['input', 'meter', 'progress']),
+    maxLength: new Set(['input', 'textarea']),
+    method: new Set(['form']),
+    min: new Set(['input', 'meter']),
+    minLength: new Set(['input', 'textarea']),
+    multiple: new Set(['input', 'select']),
+    muted: new Set(['audio', 'video']),
+    name: new Set([
+        'a',
+        'button',
+        'details',
+        'embed',
+        'fieldset',
+        'form',
+        'iframe',
+        'img',
+        'input',
+        'map',
+        'meta',
+        'object',
+        'output',
+        'param',
+        'select',
+        'slot',
+        'textarea',
+    ]),
+    noValidate: new Set(['form']),
+    open: new Set(['details', 'dialog']),
+    optimum: new Set(['meter']),
+    pattern: new Set(['input']),
+    placeholder: new Set(['input', 'textarea']),
+    playsInline: new Set(['video']),
+    poster: new Set(['video']),
+    preload: new Set(['audio', 'video']),
+    readOnly: new Set(['input', 'textarea']),
+    rel: new Set(['a', 'area', 'form', 'link']),
+    required: new Set(['input', 'select', 'textarea']),
+    reversed: new Set(['ol']),
+    rows: new Set(['textarea']),
+    rowSpan: new Set(['td', 'th']),
+    selected: new Set(['option']),
+    size: new Set(['hr', 'input', 'select']),
+    span: new Set(['col', 'colgroup']),
+    src: new Set([
+        'audio',
+        'embed',
+        'iframe',
+        'img',
+        'input',
+        'script',
+        'source',
+        'track',
+        'video',
+    ]),
+    start: new Set(['ol']),
+    step: new Set(['input']),
+    target: new Set(['a', 'area', 'base', 'form', 'link']),
+    type: new Set([
+        'a',
+        'button',
+        'embed',
+        'input',
+        'li',
+        'link',
+        'object',
+        'ol',
+        'param',
+        'script',
+        'source',
+        'style',
+        'ul',
+    ]),
+    value: new Set([
+        'button',
+        'data',
+        'input',
+        'li',
+        'meter',
+        'option',
+        'output',
+        'param',
+        'progress',
+        'select',
+        'textarea',
+    ]),
+    wrap: new Set(['textarea']),
+};
+/** Whether assigning a typed property can be represented by parsed HTML for
+ * the target element.
+ *
+ * @internal
+ */
+export const isHtmlPropertyRepresentable = (tagName, propertyName) => GLOBAL_ATTRIBUTE_PROPERTIES.has(propertyName) ||
+    (Object.hasOwn(HTML_PROPERTY_ELEMENTS, propertyName) &&
+        HTML_PROPERTY_ELEMENTS[propertyName]?.has(tagName.toLowerCase()) === true);
+const CANONICAL_NUMBER_PROPERTIES = {
+    li: new Set(['value']),
+    meter: new Set(['high', 'low', 'max', 'min', 'optimum', 'value']),
+    progress: new Set(['max', 'value']),
+};
+/** The attribute spelling produced by assigning a typed property on a fresh
+ * element.
+ *
+ * @internal
+ */
+export const serializedHtmlPropertyValue = (tagName, propertyName, value) => {
+    const lowerTagName = tagName.toLowerCase();
+    if (lowerTagName === 'textarea' && propertyName === 'cols' && value === 0) {
+        return '20';
+    }
+    if (lowerTagName === 'textarea' && propertyName === 'rows' && value === 0) {
+        return '2';
+    }
+    if (CANONICAL_NUMBER_PROPERTIES[lowerTagName]?.has(propertyName) === true) {
+        return String(Number(value));
+    }
+    return String(value);
+};
+const STYLE_LIFECYCLE_KEYS = new Set([
+    'delayed',
+    'destroy',
+    'remove',
+]);
+const CUSTOM_STYLE_PROPERTY_NAME = /^--(?:[A-Za-z0-9_-]|[^\u0000-\u007f])+$/;
+const STYLE_PROPERTY_NAME = /^-?[A-Za-z_][A-Za-z0-9_-]*$/;
+const canonicalStylePropertyName = (name) => name.startsWith('Webkit') ? `webkit${name.slice('Webkit'.length)}` : name;
+const cssDeclarationName = (name) => {
+    if (name.startsWith('--')) {
+        return name;
+    }
+    if (name === 'cssFloat') {
+        return 'float';
+    }
+    const canonicalName = canonicalStylePropertyName(name);
+    const kebabName = canonicalName
+        .replace(ASCII_UPPER, letter => `-${letter}`)
+        .toLowerCase();
+    if (kebabName.startsWith('webkit-') || kebabName.startsWith('ms-')) {
+        return `-${kebabName}`;
+    }
+    return kebabName;
+};
+const CSS_DECLARATION_PROPERTIES = new Set(Array.from(CSS_STYLE_PROPERTIES, cssDeclarationName));
+const hasUnsafeStyleSyntax = (value) => {
+    let quote;
+    let parentheses = 0;
+    let isComment = false;
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value.charAt(index);
+        const next = value.charAt(index + 1);
+        if (isComment) {
+            if (character === '*' && next === '/') {
+                isComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (character === '\\') {
+            if (next === '') {
+                return true;
+            }
+            index += 1;
+            continue;
+        }
+        if (quote !== undefined) {
+            if (character === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (character === '/' && next === '*') {
+            isComment = true;
+            index += 1;
+        }
+        else if (character === '"' || character === "'") {
+            quote = character;
+        }
+        else if (character === '(') {
+            parentheses += 1;
+        }
+        else if (character === ')') {
+            if (parentheses === 0) {
+                return true;
+            }
+            parentheses -= 1;
+        }
+        else if (parentheses === 0 && (character === ';' || character === '!')) {
+            return true;
+        }
+    }
+    return quote !== undefined || parentheses !== 0 || isComment;
+};
+/** Refuses style entries whose property assignment and serialized declaration
+ * can describe different CSS.
+ *
+ * @internal
+ */
+export const assertStyleIsRepresentable = (style) => {
+    const declarationOwners = new Map();
+    for (const name of Object.keys(style)) {
+        if (STYLE_LIFECYCLE_KEYS.has(name)) {
+            throw new Error(`[foldkit] h.Style property ${JSON.stringify(name)} is a Snabbdom ` +
+                'lifecycle control rather than a CSS property. Foldkit h.Style ' +
+                'accepts only declarations applied while the element exists.');
+        }
+        if (name === 'cssText' ||
+            (name.startsWith('--')
+                ? !CUSTOM_STYLE_PROPERTY_NAME.test(name)
+                : !STYLE_PROPERTY_NAME.test(name))) {
+            throw new Error(`[foldkit] h.Style property ${JSON.stringify(name)} cannot be ` +
+                'represented as one inline CSS declaration. Use a CSS property ' +
+                'name without declaration delimiters.');
+        }
+        const canonicalName = canonicalStylePropertyName(name);
+        if (!name.startsWith('--') &&
+            !CSS_STYLE_PROPERTIES.has(canonicalName) &&
+            !CSS_DECLARATION_PROPERTIES.has(name)) {
+            throw new Error(`[foldkit] h.Style property ${JSON.stringify(name)} is not a ` +
+                'CSSStyleDeclaration property supported by Foldkit. Use a known ' +
+                'camel-case or declaration name, or a custom property beginning --.');
+        }
+        const declarationName = cssDeclarationName(name);
+        const existingOwner = declarationOwners.get(declarationName);
+        if (existingOwner !== undefined) {
+            throw new Error(`[foldkit] h.Style properties ${JSON.stringify(existingOwner)} and ` +
+                `${JSON.stringify(name)} both name the ${JSON.stringify(declarationName)} ` +
+                'CSS declaration. Keep one spelling so the server, fresh client, ' +
+                'and hydration have one owner for it.');
+        }
+        declarationOwners.set(declarationName, name);
+        const value = style[name];
+        if (typeof value !== 'string') {
+            throw new Error(`[foldkit] h.Style value for ${JSON.stringify(name)} must be a ` +
+                'string. Browser CSSOM assignment coerces other values while server ' +
+                'serialization cannot preserve the same authored declaration.');
+        }
+        if (hasUnsafeStyleSyntax(value)) {
+            throw new Error(`[foldkit] h.Style value for ${JSON.stringify(name)} contains a ` +
+                'unsafe CSS declaration syntax. Assigning one DOM style ' +
+                'property rejects that value, while serializing it into a style ' +
+                'attribute could activate additional or !important declarations. ' +
+                'Keep the value to one declaration.');
+        }
+    }
+};
+/** The CSS declaration name corresponding to a CSSStyleDeclaration property.
+ *
+ * @internal
+ */
+export const serializedStylePropertyName = (name) => {
+    return cssDeclarationName(name);
+};
+/** A style object keyed by the declaration names shared by CSSOM and HTML.
+ *
+ * @internal
+ */
+export const normalizedStyleProperties = (style) => {
+    assertStyleIsRepresentable(style);
+    return Object.fromEntries(Object.entries(style).map(([name, value]) => [
+        cssDeclarationName(name),
+        String(value),
+    ]));
+};
+/** Inline style source whose parsed declarations match fresh CSSOM property
+ * assignment, excluding Snabbdom lifecycle controls.
+ *
+ * @internal
+ */
+export const serializedStyleAttribute = (style) => {
+    const declarations = Object.entries(style).flatMap(([name, value]) => STYLE_LIFECYCLE_KEYS.has(name) || typeof value !== 'string' || value === ''
+        ? []
+        : [`${cssDeclarationName(name)}: ${value}`]);
+    const serialized = declarations.join('; ');
+    return serialized === '' ? undefined : serialized;
+};
+/** The value of an HTML attribute written under any ASCII casing, or
+ *  `undefined` when no spelling of it is present.
+ *
+ * @internal */
+export const htmlAttributeValue = (attributes, name) => {
+    if (attributes === undefined) {
+        return undefined;
+    }
+    let value;
+    for (const written of Object.keys(attributes)) {
+        if (toHtmlAttributeName(written) === name) {
+            value = attributes[written];
+        }
+    }
+    return value;
+};

package/dist/experimental/server/host.d.ts

@@ -13,21 +13,82 @@
  */
 export declare const acceptsHtml: (acceptHeader: string | undefined) => boolean;
 /**
- * Merges the `Accept` field name into an existing `Vary` header value, parsing
- * it as a comma-separated, case-insensitive list of field names. `Vary: *`
- * already varies on everything and is returned unchanged, an existing `Accept`
- * token (in any case, and distinct from `Accept-Language` or `Accept-Encoding`)
- * is not duplicated, and otherwise `Accept` is appended.
+ * Merges a field name into an existing `Vary` header value, parsing it as a
+ * comma-separated, case-insensitive list of field names. `Vary: *` already
+ * varies on everything and is returned unchanged, a token already present (in
+ * any case, and distinct from a longer name that merely starts with it, such as
+ * `Accept-Language` beside `Accept`) is not duplicated, and otherwise the field
+ * name is appended.
+ *
+ * A host whose response depends on a request header must declare that header in
+ * `Vary` so a shared cache does not serve one client's representation to
+ * another. The dev host, reference server, and scaffold merge through this one
+ * helper rather than assigning `Vary`, which would drop the fields already
+ * there.
+ *
+ * @experimental Ships from `foldkit/experimental/server`; expect breaking changes while the API settles.
+ */
+export declare const varyWith: (existing: string | undefined, fieldName: string) => string;
+/**
+ * Merges the `Accept` field name into an existing `Vary` header value.
  *
  * A page host that negotiates HTML on the `Accept` header must declare that in
  * `Vary` so a shared cache does not serve one representation in place of the
- * other. The dev host, reference server, and scaffold merge through this one
- * helper so a comma-joined field-name string like `Accept-Language` is never
- * mistaken for the `Accept` field.
+ * other.
  *
  * @experimental Ships from `foldkit/experimental/server`; expect breaking changes while the API settles.
  */
 export declare const varyWithAccept: (existing: string | undefined) => string;
+/**
+ * Resolves a request target against the origin the host serves, returning the
+ * absolute URL to hand the server entry, or `undefined` when the target names
+ * a different origin.
+ *
+ * A request target is not a URL. HTTP allows origin-form (`/page?q=1`) and
+ * absolute-form (`http://host/page`), and a client can send a network-path
+ * reference (`//elsewhere.example/page`) that resolves against no scheme at
+ * all. Resolving one of those against the host origin silently adopts the
+ * origin the client wrote, so an entry that derives redirects, canonical URLs,
+ * cookie domains, or tenant selection from `Request.url` would take them from
+ * the request rather than from the deployment. Only a target that resolves to
+ * the host's own origin is accepted; a host behind a proxy that must serve a
+ * different public origin passes that origin in explicitly.
+ *
+ * @experimental Ships from `foldkit/experimental/server`; expect breaking changes while the API settles.
+ */
+export declare const resolveRequestUrl: (requestTarget: string, origin: string) => string | undefined;
+/** How a host should read a request that no static file answered.
+ *
+ * `PathAsset`: the path names an asset, whatever the request headers say, so a
+ * refusal is the same for every client and needs no `Vary`.
+ *
+ * `DestinationAsset`: the path could be a page, and only the request's
+ * `Sec-Fetch-Dest` says otherwise. A refusal here depends on that header, so it
+ * has to declare it in `Vary` before a shared cache may store it: a cross-site
+ * script request would otherwise seed a cached 404 for a real page.
+ *
+ * `Page`: nothing marks it as an asset, so the usual `Accept` negotiation
+ * decides.
+ *
+ * @experimental Ships from `foldkit/experimental/server`; expect breaking changes while the API settles.
+ */
+export type RequestClassification = 'PathAsset' | 'DestinationAsset' | 'Page';
+/**
+ * Classifies a request that no static file answered, from its path and, when
+ * the client sent one, its `Sec-Fetch-Dest`.
+ *
+ * A host answers a static miss by content negotiation, and a browser requests
+ * scripts, stylesheets, and images with `Accept: *​/*`, which accepts HTML. A
+ * request for a hashed asset that is no longer deployed would therefore be
+ * answered with the application shell at 200, so a stale bundle reads as a
+ * blank page rather than the 404 it is.
+ *
+ * The path is read first, so a request the URL alone settles is never made to
+ * depend on a header the client may or may not send.
+ *
+ * @experimental Ships from `foldkit/experimental/server`; expect breaking changes while the API settles.
+ */
+export declare const classifyRequest: (requestUrl: string, fetchDestination?: string) => RequestClassification;
 /**
  * Decides whether a request path resolves to the `index.html` template, the
  * way a static file server resolves it: percent-decoded, backslashes and
@@ -39,4 +100,37 @@ export declare const varyWithAccept: (existing: string | undefined) => string;
  * @experimental Ships from `foldkit/experimental/server`; expect breaking changes while the API settles.
  */
 export declare const resolvesToIndexHtml: (requestUrl: string) => boolean;
+/**
+ * The answer a host gives for the methods it cannot hand to a server entry.
+ *
+ * The WHATWG `Request` constructor rejects `CONNECT`, `TRACE`, and `TRACK`, so
+ * an entry can never be handed one: forwarding it turns a malformed request
+ * into a 500. A host refuses them itself, with `405` and an `Allow` header
+ * naming what it does forward.
+ *
+ * On Node only `TRACE` reaches this rule. The HTTP parser rejects `TRACK` with
+ * a 400 before any handler runs, and `CONNECT` arrives on its own event rather
+ * than as an ordinary request. Both are named anyway, so a host on another
+ * runtime refuses them rather than handing one to `new Request`.
+ *
+ * Every other method reaches the entry, `OPTIONS` included. A preflight is a
+ * question about a resource, so the application answers it: the entry can allow
+ * one origin for one route and refuse it for another, which no host-level
+ * policy could express. The Vite dev host applies Vite's CORS option only to
+ * Vite-owned modules and assets. An application preflight therefore reaches
+ * the entry rather than middleware a deployed host has no counterpart for.
+ *
+ * @experimental Ships from `foldkit/experimental/server`; expect breaking changes while the API settles.
+ */
+export declare const HOST_METHOD_ANSWERS: Readonly<{
+    refusedStatus: number;
+    allow: string;
+}>;
+/**
+ * Whether a host refuses this method itself instead of calling the server
+ * entry. See {@link HOST_METHOD_ANSWERS}.
+ *
+ * @experimental Ships from `foldkit/experimental/server`; expect breaking changes while the API settles.
+ */
+export declare const isHostSettledMethod: (method: string) => boolean;
 //# sourceMappingURL=host.d.ts.map

package/dist/experimental/server/host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../../src/experimental/server/host.ts"],"names":[],"mappings":"AA+DA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GAAI,cAAc,MAAM,GAAG,SAAS,KAAG,OAqB9D,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,MAAM,GAAG,SAAS,KAAG,MAgB7D,CAAA;AAiBD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,KAAG,OAkBxD,CAAA"}
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../../src/experimental/server/host.ts"],"names":[],"mappings":"AA+DA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GAAI,cAAc,MAAM,GAAG,SAAS,KAAG,OAqB9D,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,GACnB,UAAU,MAAM,GAAG,SAAS,EAC5B,WAAW,MAAM,KAChB,MAgBF,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,MAAM,GAAG,SAAS,KAAG,MAChC,CAAA;AAE9B;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iBAAiB,GAC5B,eAAe,MAAM,EACrB,QAAQ,MAAM,KACb,MAAM,GAAG,SAqBX,CAAA;AA4ED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,qBAAqB,GAAG,WAAW,GAAG,kBAAkB,GAAG,MAAM,CAAA;AAE7E;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,GAC1B,YAAY,MAAM,EAClB,mBAAmB,MAAM,KACxB,qBA+BF,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,KAAG,OAkBxD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC;IACzC,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;CACd,CAGA,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,MAAM,KAAG,OAKpD,CAAA"}