@tyndall/core 0.0.1

package/dist/manifest.d.ts

@@ -0,0 +1,81 @@
+export type RouteType = "static" | "dynamic" | "catchAll";
+export interface RouteEntry {
+    type: RouteType;
+    html?: string;
+    clientEntry: string;
+    serverEntry?: string;
+}
+export interface ChunkInfo {
+    file: string;
+    imports?: string[];
+}
+export interface Manifest {
+    version: string;
+    basePath: string;
+    routes: Record<string, RouteEntry>;
+    chunks: Record<string, ChunkInfo>;
+    assets?: Record<string, string>;
+}
+export declare const manifestSchema: {
+    readonly $schema: "http://json-schema.org/draft-07/schema#";
+    readonly type: "object";
+    readonly required: readonly ["version", "basePath", "routes", "chunks"];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly version: {
+            readonly type: "string";
+        };
+        readonly basePath: {
+            readonly type: "string";
+        };
+        readonly routes: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "object";
+                readonly required: readonly ["type", "clientEntry"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly type: {
+                        readonly enum: readonly ["static", "dynamic", "catchAll"];
+                    };
+                    readonly html: {
+                        readonly type: "string";
+                    };
+                    readonly clientEntry: {
+                        readonly type: "string";
+                    };
+                    readonly serverEntry: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+        readonly chunks: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "object";
+                readonly required: readonly ["file"];
+                readonly additionalProperties: false;
+                readonly properties: {
+                    readonly file: {
+                        readonly type: "string";
+                    };
+                    readonly imports: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+            };
+        };
+        readonly assets: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
+        };
+    };
+};
+export declare const validateManifest: (input: unknown) => Manifest;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;AAE1D,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAClC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCjB,CAAC;AAsGX,eAAO,MAAM,gBAAgB,GAAI,OAAO,OAAO,KAAG,QAuDjD,CAAC"}

package/dist/manifest.js

@@ -0,0 +1,139 @@
+import { HyperError } from "./errors.js";
+export const manifestSchema = {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    type: "object",
+    required: ["version", "basePath", "routes", "chunks"],
+    additionalProperties: false,
+    properties: {
+        version: { type: "string" },
+        basePath: { type: "string" },
+        routes: {
+            type: "object",
+            additionalProperties: {
+                type: "object",
+                required: ["type", "clientEntry"],
+                additionalProperties: false,
+                properties: {
+                    type: { enum: ["static", "dynamic", "catchAll"] },
+                    html: { type: "string" },
+                    clientEntry: { type: "string" },
+                    serverEntry: { type: "string" },
+                },
+            },
+        },
+        chunks: {
+            type: "object",
+            additionalProperties: {
+                type: "object",
+                required: ["file"],
+                additionalProperties: false,
+                properties: {
+                    file: { type: "string" },
+                    imports: { type: "array", items: { type: "string" } },
+                },
+            },
+        },
+        assets: {
+            type: "object",
+            additionalProperties: { type: "string" },
+        },
+    },
+};
+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("MANIFEST_UNKNOWN_KEY", `Unknown manifest key: ${path}${key}`, {
+                path: `${path}${key}`,
+            });
+        }
+    }
+};
+const ensureString = (value, path) => {
+    if (typeof value !== "string") {
+        throw new HyperError("MANIFEST_INVALID", `Invalid manifest value at ${path}: expected string`, { path, expected: "string" });
+    }
+    return value;
+};
+const ensureStringArray = (value, path) => {
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+        throw new HyperError("MANIFEST_INVALID", `Invalid manifest value at ${path}: expected string[]`, { path, expected: "string[]" });
+    }
+    return value;
+};
+const ensureRouteEntry = (value, path) => {
+    if (!isRecord(value)) {
+        throw new HyperError("MANIFEST_INVALID", `Invalid manifest value at ${path}: expected object`, { path, expected: "object" });
+    }
+    // Critical: enforce exact route entry keys so build/runtime stay in sync.
+    assertKnownKeys(value, new Set(["type", "html", "clientEntry", "serverEntry"]), `${path}.`);
+    const type = ensureString(value.type, `${path}.type`);
+    if (type !== "static" && type !== "dynamic" && type !== "catchAll") {
+        throw new HyperError("MANIFEST_INVALID", `Invalid manifest value at ${path}.type: ${type}`, { path: `${path}.type`, expected: "static | dynamic | catchAll" });
+    }
+    const entry = {
+        type,
+        clientEntry: ensureString(value.clientEntry, `${path}.clientEntry`),
+    };
+    if ("html" in value) {
+        entry.html = ensureString(value.html, `${path}.html`);
+    }
+    else if (type === "static") {
+        throw new HyperError("MANIFEST_INVALID", `Missing manifest value at ${path}.html for static route`, { path: `${path}.html` });
+    }
+    if ("serverEntry" in value) {
+        entry.serverEntry = ensureString(value.serverEntry, `${path}.serverEntry`);
+    }
+    return entry;
+};
+const ensureChunkInfo = (value, path) => {
+    if (!isRecord(value)) {
+        throw new HyperError("MANIFEST_INVALID", `Invalid manifest value at ${path}: expected object`, { path, expected: "object" });
+    }
+    assertKnownKeys(value, new Set(["file", "imports"]), `${path}.`);
+    const chunk = {
+        file: ensureString(value.file, `${path}.file`),
+    };
+    if ("imports" in value) {
+        chunk.imports = ensureStringArray(value.imports, `${path}.imports`);
+    }
+    return chunk;
+};
+export const validateManifest = (input) => {
+    if (!isRecord(input)) {
+        throw new HyperError("MANIFEST_INVALID", "Manifest must be an object.", {
+            expected: "object",
+        });
+    }
+    // Critical: fail on unknown top-level keys to avoid mismatch with schema consumers.
+    assertKnownKeys(input, new Set(["version", "basePath", "routes", "chunks", "assets"]), "");
+    const manifest = {
+        version: ensureString(input.version, "version"),
+        basePath: ensureString(input.basePath, "basePath"),
+        routes: {},
+        chunks: {},
+    };
+    if (!isRecord(input.routes)) {
+        throw new HyperError("MANIFEST_INVALID", "Invalid manifest value at routes: expected object", { path: "routes", expected: "object" });
+    }
+    for (const [route, entry] of Object.entries(input.routes)) {
+        manifest.routes[route] = ensureRouteEntry(entry, `routes.${route}`);
+    }
+    if (!isRecord(input.chunks)) {
+        throw new HyperError("MANIFEST_INVALID", "Invalid manifest value at chunks: expected object", { path: "chunks", expected: "object" });
+    }
+    for (const [key, info] of Object.entries(input.chunks)) {
+        manifest.chunks[key] = ensureChunkInfo(info, `chunks.${key}`);
+    }
+    if ("assets" in input) {
+        if (!isRecord(input.assets)) {
+            throw new HyperError("MANIFEST_INVALID", "Invalid manifest value at assets: expected object", { path: "assets", expected: "object" });
+        }
+        const assets = {};
+        for (const [key, value] of Object.entries(input.assets)) {
+            assets[key] = ensureString(value, `assets.${key}`);
+        }
+        manifest.assets = assets;
+    }
+    return manifest;
+};

package/dist/page-api.d.ts

@@ -0,0 +1,56 @@
+export type RouteParams = Record<string, string | string[]>;
+export interface PageContextBase {
+    routeId: string;
+    params?: RouteParams;
+    locale?: string;
+    preview?: boolean;
+    previewData?: unknown;
+}
+export interface StaticPropsContext extends PageContextBase {
+}
+export interface StaticPropsResult<Props = Record<string, unknown>> {
+    props: Props;
+    revalidate?: number | false;
+}
+export interface StaticPathEntry {
+    params: RouteParams;
+}
+export interface StaticPathsResult {
+    paths: StaticPathEntry[];
+    fallback?: boolean | "blocking";
+}
+export interface ServerPropsContext extends PageContextBase {
+    request?: unknown;
+    response?: unknown;
+}
+export interface ServerPropsResult<Props = Record<string, unknown>> {
+    props: Props;
+    headers?: Record<string, string>;
+    status?: number;
+}
+export interface HeadDescriptor {
+    title?: string;
+    meta?: Array<Record<string, string>>;
+    link?: Array<Record<string, string>>;
+    script?: Array<Record<string, string>>;
+}
+export type PageComponent<Props = Record<string, unknown>> = (props: Props) => unknown;
+export type GetStaticProps<Props = Record<string, unknown>> = (ctx: StaticPropsContext) => Promise<StaticPropsResult<Props>> | StaticPropsResult<Props>;
+export type GetStaticPaths = () => Promise<StaticPathsResult> | StaticPathsResult;
+export type GetServerProps<Props = Record<string, unknown>> = (ctx: ServerPropsContext) => Promise<ServerPropsResult<Props>> | ServerPropsResult<Props>;
+export type Head<Props = Record<string, unknown>> = (props: Props) => HeadDescriptor;
+export interface PageModule<Props = Record<string, unknown>> {
+    default: PageComponent<Props>;
+    getStaticProps?: GetStaticProps<Props>;
+    getStaticPaths?: GetStaticPaths;
+    getServerProps?: GetServerProps<Props>;
+    head?: Head<Props>;
+}
+export declare const resolvePageModule: <Props = Record<string, unknown>>(module: unknown) => PageModule<Props>;
+export declare const validateStaticPropsResult: <Props = Record<string, unknown>>(result: unknown) => StaticPropsResult<Props>;
+export declare const validateStaticPathsResult: (result: unknown) => StaticPathsResult;
+export declare const validateServerPropsResult: <Props = Record<string, unknown>>(result: unknown) => ServerPropsResult<Props>;
+export declare const runGetStaticProps: <Props = Record<string, unknown>>(hook: GetStaticProps<Props>, ctx: StaticPropsContext) => Promise<StaticPropsResult<Props>>;
+export declare const runGetStaticPaths: (hook: GetStaticPaths) => Promise<StaticPathsResult>;
+export declare const runGetServerProps: <Props = Record<string, unknown>>(hook: GetServerProps<Props>, ctx: ServerPropsContext) => Promise<ServerPropsResult<Props>>;
+//# sourceMappingURL=page-api.d.ts.map

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

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

package/dist/page-api.js

@@ -0,0 +1,100 @@
+import { HyperError } from "./errors.js";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const ensureFunction = (value, path) => {
+    if (typeof value !== "function") {
+        throw new HyperError("PAGE_API_INVALID", `Invalid page module export at ${path}: expected function`, { path, expected: "function" });
+    }
+    return value;
+};
+export const resolvePageModule = (module) => {
+    if (!isRecord(module)) {
+        throw new HyperError("PAGE_API_INVALID", "Page module must be an object.", {
+            expected: "object",
+        });
+    }
+    const defaultExport = ensureFunction(module.default, "default");
+    const page = { default: defaultExport };
+    if ("getStaticProps" in module) {
+        page.getStaticProps = ensureFunction(module.getStaticProps, "getStaticProps");
+    }
+    if ("getStaticPaths" in module) {
+        page.getStaticPaths = ensureFunction(module.getStaticPaths, "getStaticPaths");
+    }
+    if ("getServerProps" in module) {
+        page.getServerProps = ensureFunction(module.getServerProps, "getServerProps");
+    }
+    if (!page.getServerProps && "getServerSideProps" in module) {
+        page.getServerProps = ensureFunction(module.getServerSideProps, "getServerSideProps");
+    }
+    if ("head" in module) {
+        page.head = ensureFunction(module.head, "head");
+    }
+    return page;
+};
+const ensureRecord = (value, path) => {
+    if (!isRecord(value)) {
+        throw new HyperError("PAGE_API_INVALID", `Invalid page API result at ${path}`, {
+            path,
+            expected: "object",
+        });
+    }
+    return value;
+};
+export const validateStaticPropsResult = (result) => {
+    const record = ensureRecord(result, "getStaticProps");
+    if (!("props" in record)) {
+        throw new HyperError("PAGE_API_INVALID", "Invalid getStaticProps result: missing props", { path: "getStaticProps.props" });
+    }
+    const revalidate = record.revalidate;
+    if (revalidate !== undefined && revalidate !== false && typeof revalidate !== "number") {
+        throw new HyperError("PAGE_API_INVALID", "Invalid getStaticProps result: revalidate must be number or false", { path: "getStaticProps.revalidate" });
+    }
+    return record;
+};
+export const validateStaticPathsResult = (result) => {
+    const record = ensureRecord(result, "getStaticPaths");
+    if (!Array.isArray(record.paths)) {
+        throw new HyperError("PAGE_API_INVALID", "Invalid getStaticPaths result: paths must be array", { path: "getStaticPaths.paths" });
+    }
+    for (const entry of record.paths) {
+        const entryRecord = ensureRecord(entry, "getStaticPaths.paths[]");
+        if (!isRecord(entryRecord.params)) {
+            throw new HyperError("PAGE_API_INVALID", "Invalid getStaticPaths result: params must be object", { path: "getStaticPaths.paths[].params" });
+        }
+    }
+    const fallback = record.fallback;
+    if (fallback !== undefined &&
+        fallback !== "blocking" &&
+        typeof fallback !== "boolean") {
+        throw new HyperError("PAGE_API_INVALID", "Invalid getStaticPaths result: fallback must be boolean or 'blocking'", { path: "getStaticPaths.fallback" });
+    }
+    return record;
+};
+export const validateServerPropsResult = (result) => {
+    const record = ensureRecord(result, "getServerProps");
+    if (!("props" in record)) {
+        throw new HyperError("PAGE_API_INVALID", "Invalid getServerProps result: missing props", { path: "getServerProps.props" });
+    }
+    if (record.status !== undefined && typeof record.status !== "number") {
+        throw new HyperError("PAGE_API_INVALID", "Invalid getServerProps result: status must be number", { path: "getServerProps.status" });
+    }
+    if (record.headers !== undefined) {
+        if (!isRecord(record.headers)) {
+            throw new HyperError("PAGE_API_INVALID", "Invalid getServerProps result: headers must be object", { path: "getServerProps.headers" });
+        }
+    }
+    return record;
+};
+export const runGetStaticProps = async (hook, ctx) => {
+    const result = await hook(ctx);
+    // Important: validate return shape to keep build/runtime behavior consistent.
+    return validateStaticPropsResult(result);
+};
+export const runGetStaticPaths = async (hook) => {
+    const result = await hook();
+    return validateStaticPathsResult(result);
+};
+export const runGetServerProps = async (hook, ctx) => {
+    const result = await hook(ctx);
+    return validateServerPropsResult(result);
+};

package/dist/plugin.d.ts

@@ -0,0 +1,35 @@
+import type { Plugin, ResolvedConfig } from "./config.js";
+import type { RouteGraph } from "./router.js";
+export type MiddlewareNext = (error?: unknown) => void;
+export type Middleware = (req: unknown, res: unknown, next: MiddlewareNext) => void | Promise<void>;
+export interface BundleContext {
+    [key: string]: unknown;
+}
+export interface BundleResult {
+    [key: string]: unknown;
+}
+export interface RenderContext {
+    routeId?: string;
+    params?: Record<string, string | string[]>;
+    [key: string]: unknown;
+}
+export interface PluginHooks {
+    configResolved?: (config: ResolvedConfig) => void | ResolvedConfig | Promise<void | ResolvedConfig>;
+    routesResolved?: (routes: RouteGraph) => void | RouteGraph | Promise<void | RouteGraph>;
+    beforeBundle?: (ctx: BundleContext) => void | Promise<void>;
+    afterBundle?: (result: BundleResult) => void | Promise<void>;
+    beforeRender?: (routeCtx: RenderContext) => void | Promise<void>;
+    afterRender?: (html: string, routeCtx: RenderContext) => string | void | Promise<string | void>;
+    devMiddleware?: Middleware;
+    runtimeMiddleware?: Middleware;
+}
+export type HyperPlugin = Plugin & PluginHooks;
+export declare const runConfigResolvedHooks: (plugins: readonly HyperPlugin[], config: ResolvedConfig) => Promise<ResolvedConfig>;
+export declare const runRoutesResolvedHooks: (plugins: readonly HyperPlugin[], routeGraph: RouteGraph) => Promise<RouteGraph>;
+export declare const runBeforeBundleHooks: (plugins: readonly HyperPlugin[], ctx: BundleContext) => Promise<void>;
+export declare const runAfterBundleHooks: (plugins: readonly HyperPlugin[], result: BundleResult) => Promise<void>;
+export declare const runBeforeRenderHooks: (plugins: readonly HyperPlugin[], routeCtx: RenderContext) => Promise<void>;
+export declare const runAfterRenderHooks: (plugins: readonly HyperPlugin[], html: string, routeCtx: RenderContext) => Promise<string>;
+export declare const collectDevMiddlewares: (plugins: readonly HyperPlugin[]) => Middleware[];
+export declare const collectRuntimeMiddlewares: (plugins: readonly HyperPlugin[]) => Middleware[];
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

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

package/dist/plugin.js

@@ -0,0 +1,133 @@
+import { HyperError } from "./errors.js";
+const pluginLabel = (plugin) => {
+    const label = typeof plugin.name === "string" ? plugin.name.trim() : "";
+    return label.length > 0 ? label : "anonymous";
+};
+const wrapHookError = (hook, plugin, error) => {
+    const detail = error instanceof Error ? error.message : String(error);
+    return new HyperError("PLUGIN_HOOK", `Plugin "${pluginLabel(plugin)}" failed in ${hook}: ${detail}`, { hook, plugin: pluginLabel(plugin) }, error);
+};
+const normalizePlugins = (plugins) => plugins ?? [];
+export const runConfigResolvedHooks = async (plugins, config) => {
+    let nextConfig = config;
+    for (const plugin of normalizePlugins(plugins)) {
+        const hook = plugin.configResolved;
+        if (!hook) {
+            continue;
+        }
+        try {
+            const result = await hook(nextConfig);
+            if (result !== undefined) {
+                nextConfig = result;
+            }
+        }
+        catch (error) {
+            throw wrapHookError("configResolved", plugin, error);
+        }
+    }
+    return nextConfig;
+};
+export const runRoutesResolvedHooks = async (plugins, routeGraph) => {
+    let nextGraph = routeGraph;
+    for (const plugin of normalizePlugins(plugins)) {
+        const hook = plugin.routesResolved;
+        if (!hook) {
+            continue;
+        }
+        try {
+            const result = await hook(nextGraph);
+            if (result !== undefined) {
+                nextGraph = result;
+            }
+        }
+        catch (error) {
+            throw wrapHookError("routesResolved", plugin, error);
+        }
+    }
+    return nextGraph;
+};
+export const runBeforeBundleHooks = async (plugins, ctx) => {
+    for (const plugin of normalizePlugins(plugins)) {
+        const hook = plugin.beforeBundle;
+        if (!hook) {
+            continue;
+        }
+        try {
+            await hook(ctx);
+        }
+        catch (error) {
+            throw wrapHookError("beforeBundle", plugin, error);
+        }
+    }
+};
+export const runAfterBundleHooks = async (plugins, result) => {
+    for (const plugin of normalizePlugins(plugins)) {
+        const hook = plugin.afterBundle;
+        if (!hook) {
+            continue;
+        }
+        try {
+            await hook(result);
+        }
+        catch (error) {
+            throw wrapHookError("afterBundle", plugin, error);
+        }
+    }
+};
+export const runBeforeRenderHooks = async (plugins, routeCtx) => {
+    for (const plugin of normalizePlugins(plugins)) {
+        const hook = plugin.beforeRender;
+        if (!hook) {
+            continue;
+        }
+        try {
+            await hook(routeCtx);
+        }
+        catch (error) {
+            throw wrapHookError("beforeRender", plugin, error);
+        }
+    }
+};
+export const runAfterRenderHooks = async (plugins, html, routeCtx) => {
+    let nextHtml = html;
+    // Important: apply hooks sequentially for deterministic HTML output.
+    for (const plugin of normalizePlugins(plugins)) {
+        const hook = plugin.afterRender;
+        if (!hook) {
+            continue;
+        }
+        try {
+            const result = await hook(nextHtml, routeCtx);
+            if (typeof result === "string") {
+                nextHtml = result;
+            }
+        }
+        catch (error) {
+            throw wrapHookError("afterRender", plugin, error);
+        }
+    }
+    return nextHtml;
+};
+const wrapMiddleware = (hookName, plugin, middleware) => {
+    return async (req, res, next) => {
+        try {
+            await middleware(req, res, next);
+        }
+        catch (error) {
+            next(wrapHookError(hookName, plugin, error));
+        }
+    };
+};
+const collectMiddlewares = (plugins, hookName) => {
+    const middlewares = [];
+    for (const plugin of normalizePlugins(plugins)) {
+        const hook = plugin[hookName];
+        if (!hook) {
+            continue;
+        }
+        middlewares.push(wrapMiddleware(hookName, plugin, hook));
+    }
+    return middlewares;
+};
+export const collectDevMiddlewares = (plugins) => collectMiddlewares(plugins, "devMiddleware");
+export const collectRuntimeMiddlewares = (plugins) => collectMiddlewares(plugins, "runtimeMiddleware");

package/dist/program-sandbox.d.ts

@@ -0,0 +1,18 @@
+import type { ProgramDefinition } from "./dynamic-manifest.js";
+export interface ProgramSandboxPolicyInput {
+    integrityRequired?: boolean;
+    allow?: string[];
+    timeoutMs?: number;
+    memoryMb?: number;
+}
+export interface ProgramSandboxPolicy {
+    integrityRequired: boolean;
+    allow: string[];
+    timeoutMs: number;
+    memoryMb: number;
+}
+export declare const DEFAULT_PROGRAM_SANDBOX_POLICY: ProgramSandboxPolicy;
+export declare const resolveProgramSandboxPolicy: (input?: ProgramSandboxPolicyInput) => ProgramSandboxPolicy;
+export declare const validateProgramIntegrity: (definition: ProgramDefinition, policy: ProgramSandboxPolicy) => void;
+export declare const buildProgramSandboxContext: (policy: ProgramSandboxPolicy) => Record<string, unknown>;
+//# sourceMappingURL=program-sandbox.d.ts.map

package/dist/program-sandbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"program-sandbox.d.ts","sourceRoot":"","sources":["../src/program-sandbox.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,MAAM,WAAW,yBAAyB;IACxC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,8BAA8B,EAAE,oBAK5C,CAAC;AAmCF,eAAO,MAAM,2BAA2B,GACtC,QAAO,yBAA8B,KACpC,oBAiBF,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,YAAY,iBAAiB,EAC7B,QAAQ,oBAAoB,KAC3B,IAWF,CAAC;AAoBF,eAAO,MAAM,0BAA0B,GACrC,QAAQ,oBAAoB,KAC3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAuBxB,CAAC"}

package/dist/program-sandbox.js

@@ -0,0 +1,84 @@
+import { HyperError } from "./errors.js";
+export const DEFAULT_PROGRAM_SANDBOX_POLICY = {
+    integrityRequired: true,
+    allow: [],
+    timeoutMs: 50,
+    memoryMb: 32,
+};
+const KNOWN_ALLOWLIST = new Set(["Math", "Math.random", "Date", "Intl", "JSON", "console"]);
+const ensureNumber = (value, path) => {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        throw new HyperError("PROGRAM_POLICY_INVALID", `Invalid program policy value at ${path}: expected number`, { path, expected: "number" });
+    }
+    return value;
+};
+const ensureAllowList = (value, path) => {
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+        throw new HyperError("PROGRAM_POLICY_INVALID", `Invalid program policy value at ${path}: expected string[]`, { path, expected: "string[]" });
+    }
+    for (const entry of value) {
+        if (!KNOWN_ALLOWLIST.has(entry)) {
+            throw new HyperError("PROGRAM_POLICY_INVALID", `Unknown program policy allow entry: ${entry}`, { path, entry });
+        }
+    }
+    return value;
+};
+export const resolveProgramSandboxPolicy = (input = {}) => {
+    const policy = {
+        ...DEFAULT_PROGRAM_SANDBOX_POLICY,
+        integrityRequired: input.integrityRequired ?? DEFAULT_PROGRAM_SANDBOX_POLICY.integrityRequired,
+    };
+    if ("allow" in input) {
+        policy.allow = ensureAllowList(input.allow, "modules.dynamicManifest.program.allow");
+    }
+    if ("timeoutMs" in input && input.timeoutMs !== undefined) {
+        policy.timeoutMs = ensureNumber(input.timeoutMs, "modules.dynamicManifest.program.timeoutMs");
+    }
+    if ("memoryMb" in input && input.memoryMb !== undefined) {
+        policy.memoryMb = ensureNumber(input.memoryMb, "modules.dynamicManifest.program.memoryMb");
+    }
+    return policy;
+};
+export const validateProgramIntegrity = (definition, policy) => {
+    if (!policy.integrityRequired) {
+        return;
+    }
+    if (!definition.integrity?.alg || !definition.integrity.signature) {
+        throw new HyperError("PROGRAM_POLICY_INVALID", "Program integrity is required but missing.", { path: "definition.integrity" });
+    }
+};
+const buildSafeMath = (allowRandom) => {
+    const safeMath = {};
+    const source = Math;
+    for (const key of Object.getOwnPropertyNames(Math)) {
+        safeMath[key] = source[key];
+    }
+    if (!allowRandom) {
+        safeMath.random = () => {
+            throw new HyperError("PROGRAM_POLICY_INVALID", "Math.random is disabled by sandbox policy.", { path: "modules.dynamicManifest.program.allow", expected: "Math.random" });
+        };
+    }
+    return safeMath;
+};
+export const buildProgramSandboxContext = (policy) => {
+    const context = Object.create(null);
+    const allow = new Set(policy.allow);
+    const allowMath = allow.has("Math") || allow.has("Math.random");
+    if (allowMath) {
+        context.Math = buildSafeMath(allow.has("Math.random"));
+    }
+    if (allow.has("Date")) {
+        context.Date = Date;
+    }
+    if (allow.has("Intl")) {
+        context.Intl = Intl;
+    }
+    if (allow.has("JSON")) {
+        context.JSON = JSON;
+    }
+    if (allow.has("console")) {
+        context.console = console;
+    }
+    context.globalThis = context;
+    return context;
+};