@tyndall/core 0.0.1

package/dist/dynamic-manifest.js

@@ -0,0 +1,189 @@
+import { HyperError } from "./errors.js";
+export const dynamicManifestSchema = {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    type: "object",
+    required: ["pageId", "version", "mode", "definition"],
+    additionalProperties: false,
+    properties: {
+        pageId: { type: "string" },
+        version: { type: ["string", "number"] },
+        mode: { enum: ["meta", "program"] },
+        cache: { type: "object" },
+        policy: { type: "object" },
+        pageProps: { type: "object" },
+        definition: { type: "object" },
+    },
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const assertKnownKeys = (value, allowed, path) => {
+    for (const key of Object.keys(value)) {
+        if (!allowed.has(key)) {
+            throw new HyperError("DYNAMIC_MANIFEST_UNKNOWN_KEY", `Unknown dynamic manifest key: ${path}${key}`, { path: `${path}${key}` });
+        }
+    }
+};
+const ensureString = (value, path) => {
+    if (typeof value !== "string") {
+        throw new HyperError("DYNAMIC_MANIFEST_INVALID", `Invalid dynamic manifest value at ${path}: expected string`, { path, expected: "string" });
+    }
+    return value;
+};
+const ensureNumber = (value, path) => {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        throw new HyperError("DYNAMIC_MANIFEST_INVALID", `Invalid dynamic manifest value at ${path}: expected number`, { path, expected: "number" });
+    }
+    return value;
+};
+const ensureStringOrNumber = (value, path) => {
+    if (typeof value !== "string" && typeof value !== "number") {
+        throw new HyperError("DYNAMIC_MANIFEST_INVALID", `Invalid dynamic manifest value at ${path}: expected string | number`, { path, expected: "string | number" });
+    }
+    return value;
+};
+const ensureRecord = (value, path) => {
+    if (!isRecord(value)) {
+        throw new HyperError("DYNAMIC_MANIFEST_INVALID", `Invalid dynamic manifest value at ${path}: expected object`, { path, expected: "object" });
+    }
+    return value;
+};
+const ensureCache = (value, path) => {
+    const record = ensureRecord(value, path);
+    assertKnownKeys(record, new Set(["ttlSeconds", "etag", "swrSeconds"]), `${path}.`);
+    const cache = {};
+    if ("ttlSeconds" in record) {
+        cache.ttlSeconds = ensureNumber(record.ttlSeconds, `${path}.ttlSeconds`);
+    }
+    if ("etag" in record) {
+        cache.etag = ensureString(record.etag, `${path}.etag`);
+    }
+    if ("swrSeconds" in record) {
+        cache.swrSeconds = ensureNumber(record.swrSeconds, `${path}.swrSeconds`);
+    }
+    return cache;
+};
+const ensurePolicy = (value, path) => {
+    const record = ensureRecord(value, path);
+    assertKnownKeys(record, new Set(["render", "auth", "seo", "headers", "redirect"]), `${path}.`);
+    const policy = {};
+    if ("render" in record) {
+        const render = ensureString(record.render, `${path}.render`);
+        if (!["csr", "ssr", "redirect", "auto"].includes(render)) {
+            throw new HyperError("DYNAMIC_MANIFEST_INVALID", `Invalid dynamic manifest value at ${path}.render: ${render}`, { path: `${path}.render`, expected: "csr | ssr | redirect | auto" });
+        }
+        policy.render = render;
+    }
+    if ("auth" in record) {
+        policy.auth = ensureString(record.auth, `${path}.auth`);
+    }
+    if ("seo" in record) {
+        policy.seo = ensureString(record.seo, `${path}.seo`);
+    }
+    if ("redirect" in record) {
+        policy.redirect = ensureString(record.redirect, `${path}.redirect`);
+    }
+    if ("headers" in record) {
+        const headers = ensureRecord(record.headers, `${path}.headers`);
+        const normalized = {};
+        for (const [key, value] of Object.entries(headers)) {
+            normalized[key] = ensureString(value, `${path}.headers.${key}`);
+        }
+        policy.headers = normalized;
+    }
+    return policy;
+};
+const ensureMetaNode = (value, path) => {
+    const record = ensureRecord(value, path);
+    assertKnownKeys(record, new Set(["type", "props", "children"]), `${path}.`);
+    const node = {
+        type: ensureString(record.type, `${path}.type`),
+    };
+    if ("props" in record) {
+        node.props = ensureRecord(record.props, `${path}.props`);
+    }
+    if ("children" in record) {
+        if (!Array.isArray(record.children)) {
+            throw new HyperError("DYNAMIC_MANIFEST_INVALID", `Invalid dynamic manifest value at ${path}.children: expected array`, { path: `${path}.children`, expected: "array" });
+        }
+        node.children = record.children.map((child, index) => {
+            if (typeof child === "string") {
+                return child;
+            }
+            return ensureMetaNode(child, `${path}.children[${index}]`);
+        });
+    }
+    return node;
+};
+const ensureDefinition = (value, path, mode) => {
+    const record = ensureRecord(value, path);
+    const kind = ensureString(record.kind, `${path}.kind`);
+    if (kind === "meta") {
+        assertKnownKeys(record, new Set(["kind", "root"]), `${path}.`);
+        // Important: meta definitions must align with the declared mode.
+        if (mode !== "meta") {
+            throw new HyperError("DYNAMIC_MANIFEST_INVALID", `Dynamic manifest mode mismatch: expected ${mode} definition`, { path, expected: mode });
+        }
+        return { kind: "meta", root: ensureMetaNode(record.root, `${path}.root`) };
+    }
+    if (kind === "program") {
+        assertKnownKeys(record, new Set(["kind", "entry", "integrity", "sandbox"]), `${path}.`);
+        if (mode !== "program") {
+            throw new HyperError("DYNAMIC_MANIFEST_INVALID", `Dynamic manifest mode mismatch: expected ${mode} definition`, { path, expected: mode });
+        }
+        const entry = ensureRecord(record.entry, `${path}.entry`);
+        assertKnownKeys(entry, new Set(["code"]), `${path}.entry.`);
+        const program = {
+            kind: "program",
+            entry: {
+                code: ensureString(entry.code, `${path}.entry.code`),
+            },
+        };
+        if ("integrity" in record) {
+            const integrity = ensureRecord(record.integrity, `${path}.integrity`);
+            assertKnownKeys(integrity, new Set(["alg", "signature"]), `${path}.integrity.`);
+            program.integrity = {};
+            if ("alg" in integrity) {
+                program.integrity.alg = ensureString(integrity.alg, `${path}.integrity.alg`);
+            }
+            if ("signature" in integrity) {
+                program.integrity.signature = ensureString(integrity.signature, `${path}.integrity.signature`);
+            }
+        }
+        if ("sandbox" in record) {
+            const sandbox = ensureRecord(record.sandbox, `${path}.sandbox`);
+            assertKnownKeys(sandbox, new Set(["timeoutMs", "memoryMb"]), `${path}.sandbox.`);
+            program.sandbox = {};
+            if ("timeoutMs" in sandbox) {
+                program.sandbox.timeoutMs = ensureNumber(sandbox.timeoutMs, `${path}.sandbox.timeoutMs`);
+            }
+            if ("memoryMb" in sandbox) {
+                program.sandbox.memoryMb = ensureNumber(sandbox.memoryMb, `${path}.sandbox.memoryMb`);
+            }
+        }
+        return program;
+    }
+    throw new HyperError("DYNAMIC_MANIFEST_INVALID", `Invalid dynamic manifest value at ${path}.kind: ${kind}`, { path: `${path}.kind`, expected: "meta | program" });
+};
+export const validateDynamicManifest = (input) => {
+    const record = ensureRecord(input, "manifest");
+    assertKnownKeys(record, new Set(["pageId", "version", "mode", "cache", "policy", "pageProps", "definition"]), "");
+    const mode = ensureString(record.mode, "mode");
+    if (mode !== "meta" && mode !== "program") {
+        throw new HyperError("DYNAMIC_MANIFEST_INVALID", `Invalid dynamic manifest value at mode: ${mode}`, { path: "mode", expected: "meta | program" });
+    }
+    const envelope = {
+        pageId: ensureString(record.pageId, "pageId"),
+        version: ensureStringOrNumber(record.version, "version"),
+        mode,
+        definition: ensureDefinition(record.definition, "definition", mode),
+    };
+    if ("cache" in record) {
+        envelope.cache = ensureCache(record.cache, "cache");
+    }
+    if ("policy" in record) {
+        envelope.policy = ensurePolicy(record.policy, "policy");
+    }
+    if ("pageProps" in record) {
+        envelope.pageProps = ensureRecord(record.pageProps, "pageProps");
+    }
+    return envelope;
+};

package/dist/dynamic-page-api.d.ts

@@ -0,0 +1,34 @@
+import type { DynamicPageEnvelope } from "./dynamic-manifest.js";
+export interface DynamicPageResolveInput {
+    path: string;
+    locale?: string;
+    variant?: string;
+    device?: string;
+    ctxHash?: string;
+}
+export interface DynamicPageComponentDescriptor {
+    type: string;
+    version?: string;
+    schema?: unknown;
+}
+export interface DynamicPageComponentRegistry {
+    types: DynamicPageComponentDescriptor[];
+}
+export interface DynamicPageApiProvider {
+    resolveByPath: (input: DynamicPageResolveInput) => Promise<DynamicPageEnvelope | null>;
+    resolveById: (pageId: string) => Promise<DynamicPageEnvelope | null>;
+    listComponents?: (filters: Record<string, string>) => Promise<DynamicPageComponentRegistry | null>;
+}
+export interface DynamicPageApiRequest {
+    method: string;
+    pathname: string;
+    query: URLSearchParams;
+    headers: Record<string, string | string[] | undefined>;
+}
+export interface DynamicPageApiResult {
+    status: number;
+    headers: Record<string, string>;
+    body?: string;
+}
+export declare const handleDynamicPageApiRequest: (request: DynamicPageApiRequest, provider: DynamicPageApiProvider) => Promise<DynamicPageApiResult | null>;
+//# sourceMappingURL=dynamic-page-api.d.ts.map

package/dist/dynamic-page-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-page-api.d.ts","sourceRoot":"","sources":["../src/dynamic-page-api.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,8BAA8B;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,8BAA8B,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAAC;IACvF,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAAC;IACrE,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC,CAAC;CACpG;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,eAAe,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC;CACxD;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAyGD,eAAO,MAAM,2BAA2B,GACtC,SAAS,qBAAqB,EAC9B,UAAU,sBAAsB,KAC/B,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAoDrC,CAAC"}

package/dist/dynamic-page-api.js

@@ -0,0 +1,136 @@
+import { hash, stableStringify } from "@tyndall/shared";
+const DEFAULT_TTL_SECONDS = 60;
+const REGISTRY_TTL_SECONDS = 3600;
+const getHeaderValue = (headers, name) => {
+    const value = headers[name.toLowerCase()] ?? headers[name];
+    if (Array.isArray(value)) {
+        return value.join(", ");
+    }
+    return value;
+};
+const formatEtag = (etag) => {
+    if (!etag) {
+        return etag;
+    }
+    if (etag.startsWith("W/") || etag.startsWith("\"")) {
+        return etag;
+    }
+    return `W/\"${etag}\"`;
+};
+const matchesEtag = (candidate, etag) => {
+    if (!candidate) {
+        return false;
+    }
+    if (candidate.trim() === "*") {
+        return true;
+    }
+    return candidate
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean)
+        .includes(etag);
+};
+const jsonResponse = (status, body) => ({
+    status,
+    headers: { "content-type": "application/json; charset=utf-8" },
+    body: JSON.stringify(body),
+});
+const buildEnvelopeResponse = (envelope, headers, ttlSeconds = DEFAULT_TTL_SECONDS) => {
+    const rawEtag = envelope.cache?.etag ?? hash(stableStringify(envelope));
+    const etag = formatEtag(rawEtag);
+    const cacheControl = `public, max-age=${ttlSeconds}`;
+    const ifNoneMatch = getHeaderValue(headers, "if-none-match");
+    // Honor cache validation to avoid sending full payloads when unchanged.
+    if (matchesEtag(ifNoneMatch, etag)) {
+        return {
+            status: 304,
+            headers: {
+                etag,
+                "cache-control": cacheControl,
+            },
+        };
+    }
+    return {
+        status: 200,
+        headers: {
+            "content-type": "application/json; charset=utf-8",
+            etag,
+            "cache-control": cacheControl,
+        },
+        body: JSON.stringify(envelope),
+    };
+};
+const buildRegistryResponse = (registry, headers) => {
+    const rawEtag = hash(stableStringify(registry));
+    const etag = formatEtag(rawEtag);
+    const cacheControl = `public, max-age=${REGISTRY_TTL_SECONDS}`;
+    const ifNoneMatch = getHeaderValue(headers, "if-none-match");
+    // Honor cache validation to avoid sending full payloads when unchanged.
+    if (matchesEtag(ifNoneMatch, etag)) {
+        return {
+            status: 304,
+            headers: {
+                etag,
+                "cache-control": cacheControl,
+            },
+        };
+    }
+    return {
+        status: 200,
+        headers: {
+            "content-type": "application/json; charset=utf-8",
+            etag,
+            "cache-control": cacheControl,
+        },
+        body: JSON.stringify(registry),
+    };
+};
+export const handleDynamicPageApiRequest = async (request, provider) => {
+    const method = request.method.toUpperCase();
+    if (method !== "GET") {
+        return jsonResponse(405, { error: "Method Not Allowed" });
+    }
+    if (request.pathname === "/api/pages/resolve") {
+        const path = request.query.get("path");
+        if (!path) {
+            return jsonResponse(400, { error: "Missing path" });
+        }
+        const envelope = await provider.resolveByPath({
+            path,
+            locale: request.query.get("locale") ?? undefined,
+            variant: request.query.get("variant") ?? undefined,
+            device: request.query.get("device") ?? undefined,
+            ctxHash: request.query.get("ctxHash") ?? undefined,
+        });
+        if (!envelope) {
+            return jsonResponse(404, { error: "Not Found" });
+        }
+        return buildEnvelopeResponse(envelope, request.headers, envelope.cache?.ttlSeconds);
+    }
+    if (request.pathname.startsWith("/api/pages/")) {
+        const pageId = request.pathname.replace("/api/pages/", "");
+        if (!pageId) {
+            return jsonResponse(400, { error: "Missing pageId" });
+        }
+        const envelope = await provider.resolveById(decodeURIComponent(pageId));
+        if (!envelope) {
+            return jsonResponse(404, { error: "Not Found" });
+        }
+        return buildEnvelopeResponse(envelope, request.headers, envelope.cache?.ttlSeconds);
+    }
+    if (request.pathname === "/api/components/registry") {
+        if (!provider.listComponents) {
+            return jsonResponse(404, { error: "Not Found" });
+        }
+        const filters = {};
+        for (const [key, value] of request.query.entries()) {
+            filters[key] = value;
+        }
+        const registry = await provider.listComponents(filters);
+        if (!registry) {
+            return jsonResponse(404, { error: "Not Found" });
+        }
+        return buildRegistryResponse(registry, request.headers);
+    }
+    return null;
+};

package/dist/errors.d.ts

@@ -0,0 +1,10 @@
+export type HyperErrorCode = "CONFIG_INVALID" | "CONFIG_UNKNOWN_KEY" | "MANIFEST_INVALID" | "MANIFEST_UNKNOWN_KEY" | "DYNAMIC_MANIFEST_INVALID" | "DYNAMIC_MANIFEST_UNKNOWN_KEY" | "PROGRAM_POLICY_INVALID" | "PAGE_API_INVALID" | "ROUTE_INVALID" | "ROUTE_DUPLICATE" | "ROUTE_META_INVALID" | "ROUTE_META_LOAD_FAILED" | "PLUGIN_HOOK";
+export type HyperErrorDetails = Record<string, unknown>;
+export declare class HyperError extends Error {
+    readonly code: HyperErrorCode;
+    readonly details?: HyperErrorDetails;
+    constructor(code: HyperErrorCode, message: string, details?: HyperErrorDetails, cause?: unknown);
+}
+export declare const isHyperError: (error: unknown) => error is HyperError;
+export declare const formatHyperError: (error: HyperError) => string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GACtB,gBAAgB,GAChB,oBAAoB,GACpB,kBAAkB,GAClB,sBAAsB,GACtB,0BAA0B,GAC1B,8BAA8B,GAC9B,wBAAwB,GACxB,kBAAkB,GAClB,eAAe,GACf,iBAAiB,GACjB,oBAAoB,GACpB,wBAAwB,GACxB,aAAa,CAAC;AAElB,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAExD,qBAAa,UAAW,SAAQ,KAAK;IACnC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC;gBAEzB,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,EAAE,KAAK,CAAC,EAAE,OAAO;CAQhG;AAED,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,UAAyC,CAAC;AAajG,eAAO,MAAM,gBAAgB,GAAI,OAAO,UAAU,KAAG,MAQpD,CAAC"}

package/dist/errors.js

@@ -0,0 +1,31 @@
+export class HyperError extends Error {
+    constructor(code, message, details, cause) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        if (cause !== undefined) {
+            this.cause = cause;
+        }
+    }
+}
+export const isHyperError = (error) => error instanceof HyperError;
+const formatDetailValue = (value) => {
+    if (typeof value === "string") {
+        return value;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+};
+export const formatHyperError = (error) => {
+    const lines = [`[hyper] ${error.code}: ${error.message}`];
+    if (error.details) {
+        for (const [key, value] of Object.entries(error.details)) {
+            lines.push(`- ${key}: ${formatDetailValue(value)}`);
+        }
+    }
+    return lines.join("\n");
+};

package/dist/head.d.ts

@@ -0,0 +1,3 @@
+import type { HeadDescriptor } from "./page-api.js";
+export declare const mergeHeadDescriptors: (...descriptors: HeadDescriptor[]) => HeadDescriptor;
+//# sourceMappingURL=head.d.ts.map

package/dist/head.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"head.d.ts","sourceRoot":"","sources":["../src/head.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,eAAO,MAAM,oBAAoB,GAAI,GAAG,aAAa,cAAc,EAAE,KAAG,cAmCvE,CAAC"}

package/dist/head.js

@@ -0,0 +1,33 @@
+export const mergeHeadDescriptors = (...descriptors) => {
+    const merged = {};
+    const meta = [];
+    const link = [];
+    const script = [];
+    for (const descriptor of descriptors) {
+        if (!descriptor) {
+            continue;
+        }
+        if (descriptor.title) {
+            merged.title = descriptor.title;
+        }
+        if (descriptor.meta) {
+            meta.push(...descriptor.meta);
+        }
+        if (descriptor.link) {
+            link.push(...descriptor.link);
+        }
+        if (descriptor.script) {
+            script.push(...descriptor.script);
+        }
+    }
+    if (meta.length) {
+        merged.meta = meta;
+    }
+    if (link.length) {
+        merged.link = link;
+    }
+    if (script.length) {
+        merged.script = script;
+    }
+    return merged;
+};

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+export { loadConfig } from "./config.js";
+export type { HyperConfig, ResolvedConfig, RenderMode, ProjectMode, JsxRuntime, Engine, Bundler, TranspileStrategy, LintTool, FormatTool, RuntimeAdapter, LegacyPolyfills, LegacyChunking, NavigationMode, ClientRenderMode, LoggingLevel, Plugin, } from "./config.js";
+export { resolveUIAdapter } from "./ui-adapter.js";
+export type { HmrIntegration, HmrOverlayHandler, HmrRefreshBoundary, UIAdapter, EntrySpec, UIAdapterEntryContext, UIAdapterFactory, UIAdapterRegistry, UIAdapterRenderContext, UIAdapterRenderResult, UIAdapterRenderStreamResult, UIAdapterStream, UIAdapterStreamTarget, } from "./ui-adapter.js";
+export { resolveHmrIntegration } from "./ui-adapter.js";
+export { manifestSchema, validateManifest } from "./manifest.js";
+export type { Manifest, RouteEntry, RouteType, ChunkInfo } from "./manifest.js";
+export { HyperError, formatHyperError, isHyperError } from "./errors.js";
+export type { HyperErrorCode, HyperErrorDetails } from "./errors.js";
+export { mergeHeadDescriptors } from "./head.js";
+export { evaluateRenderPolicy } from "./render-policy.js";
+export { resolveRouteWithFallback, resolveRouteWithPolicyFallback, shouldForceDynamicFallback, } from "./resolver-fallback.js";
+export type { DynamicFallbackPolicy, DynamicManifestResolver, ResolverFallbackPolicy, RouteFallbackResult, RoutePolicyFallbackResult, } from "./resolver-fallback.js";
+export { handleDynamicPageApiRequest } from "./dynamic-page-api.js";
+export type { DynamicPageApiProvider, DynamicPageApiRequest, DynamicPageApiResult, DynamicPageComponentDescriptor, DynamicPageComponentRegistry, DynamicPageResolveInput, } from "./dynamic-page-api.js";
+export { dynamicManifestSchema, validateDynamicManifest } from "./dynamic-manifest.js";
+export type { DynamicPageCache, DynamicPageDefinition, DynamicPageEnvelope, DynamicPageMode, DynamicPagePolicy, MetaDefinition, MetaNode, ProgramDefinition, } from "./dynamic-manifest.js";
+export { DEFAULT_PROGRAM_SANDBOX_POLICY, buildProgramSandboxContext, resolveProgramSandboxPolicy, validateProgramIntegrity, } from "./program-sandbox.js";
+export type { ProgramSandboxPolicy, ProgramSandboxPolicyInput } from "./program-sandbox.js";
+export { serializeProps } from "./props.js";
+export { CLIENT_ROUTER_BOOTSTRAP_PATH, renderClientRouterBootstrap, } from "./client-router-bootstrap.js";
+export type { ClientRouterBootstrapOptions, LinkInterceptionMode, } from "./client-router-bootstrap.js";
+export { resolvePageModule, validateStaticPropsResult, validateStaticPathsResult, validateServerPropsResult, runGetStaticProps, runGetStaticPaths, runGetServerProps, } from "./page-api.js";
+export type { RouteParams, PageContextBase, StaticPropsContext, StaticPropsResult, StaticPathEntry, StaticPathsResult, ServerPropsContext, ServerPropsResult, HeadDescriptor, PageComponent, GetStaticProps, GetStaticPaths, GetServerProps, Head, PageModule, } from "./page-api.js";
+export { matchRoute } from "./router.js";
+export type { RouteGraph, RouteRecord, RouteSegment, MatchResult, RoutePolicy } from "./router.js";
+export { collectRouteLayouts, composeLayouts } from "./layouts.js";
+export type { LayoutNode, LayoutResolution } from "./layouts.js";
+export { createRouteGraph } from "./route-graph.js";
+export type { RouteGraphOptions } from "./route-graph.js";
+export { runConfigResolvedHooks, runRoutesResolvedHooks, runBeforeBundleHooks, runAfterBundleHooks, runBeforeRenderHooks, runAfterRenderHooks, collectDevMiddlewares, collectRuntimeMiddlewares, } from "./plugin.js";
+export type { BundleContext, BundleResult, RenderContext, PluginHooks, HyperPlugin, Middleware, MiddlewareNext, } from "./plugin.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -0,0 +1,18 @@
+export { loadConfig } from "./config.js";
+export { resolveUIAdapter } from "./ui-adapter.js";
+export { resolveHmrIntegration } from "./ui-adapter.js";
+export { manifestSchema, validateManifest } from "./manifest.js";
+export { HyperError, formatHyperError, isHyperError } from "./errors.js";
+export { mergeHeadDescriptors } from "./head.js";
+export { evaluateRenderPolicy } from "./render-policy.js";
+export { resolveRouteWithFallback, resolveRouteWithPolicyFallback, shouldForceDynamicFallback, } from "./resolver-fallback.js";
+export { handleDynamicPageApiRequest } from "./dynamic-page-api.js";
+export { dynamicManifestSchema, validateDynamicManifest } from "./dynamic-manifest.js";
+export { DEFAULT_PROGRAM_SANDBOX_POLICY, buildProgramSandboxContext, resolveProgramSandboxPolicy, validateProgramIntegrity, } from "./program-sandbox.js";
+export { serializeProps } from "./props.js";
+export { CLIENT_ROUTER_BOOTSTRAP_PATH, renderClientRouterBootstrap, } from "./client-router-bootstrap.js";
+export { resolvePageModule, validateStaticPropsResult, validateStaticPathsResult, validateServerPropsResult, runGetStaticProps, runGetStaticPaths, runGetServerProps, } from "./page-api.js";
+export { matchRoute } from "./router.js";
+export { collectRouteLayouts, composeLayouts } from "./layouts.js";
+export { createRouteGraph } from "./route-graph.js";
+export { runConfigResolvedHooks, runRoutesResolvedHooks, runBeforeBundleHooks, runAfterBundleHooks, runBeforeRenderHooks, runAfterRenderHooks, collectDevMiddlewares, collectRuntimeMiddlewares, } from "./plugin.js";

package/dist/layouts.d.ts

@@ -0,0 +1,14 @@
+export type LayoutNode = {
+    type: "layout";
+    filePath: string;
+    child: LayoutNode;
+} | {
+    type: "page";
+    filePath: string;
+};
+export interface LayoutResolution {
+    layoutFiles: string[];
+}
+export declare const collectRouteLayouts: (routeFilePath: string, routesDir: string, extensions?: string[]) => LayoutResolution;
+export declare const composeLayouts: (layoutFiles: string[], pageFilePath: string) => LayoutNode;
+//# sourceMappingURL=layouts.d.ts.map

package/dist/layouts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layouts.d.ts","sourceRoot":"","sources":["../src/layouts.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,GACvD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvC,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAmBD,eAAO,MAAM,mBAAmB,GAC9B,eAAe,MAAM,EACrB,WAAW,MAAM,EACjB,aAAY,MAAM,EAAsB,KACvC,gBA4BF,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,aAAa,MAAM,EAAE,EAAE,cAAc,MAAM,KAAG,UAS5E,CAAC"}

package/dist/layouts.js

@@ -0,0 +1,51 @@
+import { statSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+import { HyperError } from "./errors.js";
+const defaultExtensions = [".tsx", ".ts", ".jsx", ".js"];
+const findLayoutFile = (dir, extensions) => {
+    for (const ext of extensions) {
+        const candidate = join(dir, `_layout${ext}`);
+        try {
+            const stats = statSync(candidate);
+            if (stats.isFile()) {
+                return candidate;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+};
+export const collectRouteLayouts = (routeFilePath, routesDir, extensions = defaultExtensions) => {
+    const relativePath = relative(routesDir, routeFilePath);
+    if (!relativePath || relativePath.startsWith("..") || relativePath.includes(`..${sep}`)) {
+        throw new HyperError("ROUTE_INVALID", "Route file is outside of routesDir.", {
+            routeFilePath,
+            routesDir,
+        });
+    }
+    const segments = relativePath.split(sep);
+    segments.pop();
+    const layoutFiles = [];
+    const rootLayout = findLayoutFile(routesDir, extensions);
+    if (rootLayout) {
+        layoutFiles.push(rootLayout);
+    }
+    let currentDir = routesDir;
+    for (const segment of segments) {
+        currentDir = join(currentDir, segment);
+        const layoutFile = findLayoutFile(currentDir, extensions);
+        if (layoutFile) {
+            layoutFiles.push(layoutFile);
+        }
+    }
+    return { layoutFiles };
+};
+export const composeLayouts = (layoutFiles, pageFilePath) => {
+    // Important: compose outer→inner so root layout wraps leaf layout wraps page.
+    return layoutFiles
+        .slice()
+        .reverse()
+        .reduce((child, layoutFile) => ({ type: "layout", filePath: layoutFile, child }), { type: "page", filePath: pageFilePath });
+};