@rmc-toolkit/core 0.1.0

package/dist/__fixtures__/dummy-module.d.ts

@@ -0,0 +1,4 @@
+export declare const namedExport = "named-value";
+declare const _default: "default-value";
+export default _default;
+//# sourceMappingURL=dummy-module.d.ts.map

package/dist/__fixtures__/dummy-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dummy-module.d.ts","sourceRoot":"","sources":["../../src/__fixtures__/dummy-module.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,gBAAgB,CAAC;wBAC1B,eAAe;AAA9B,wBAA+B"}

package/dist/__fixtures__/dummy-module.js

@@ -0,0 +1,2 @@
+export const namedExport = "named-value";
+export default "default-value";

package/dist/externals.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeCompositionManifest } from "./types.js";
+export declare const listExternalSpecifiers: (manifest: RuntimeCompositionManifest) => string[];
+export declare const createExternalMatcher: (manifest: RuntimeCompositionManifest) => ((source: string) => boolean);
+//# sourceMappingURL=externals.d.ts.map

package/dist/externals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"externals.d.ts","sourceRoot":"","sources":["../src/externals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,0BAA0B,EAE3B,MAAM,YAAY,CAAC;AAKpB,eAAO,MAAM,sBAAsB,GACjC,UAAU,0BAA0B,KACnC,MAAM,EAiBR,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,UAAU,0BAA0B,KACnC,CAAC,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAW9B,CAAC"}

package/dist/externals.js

@@ -0,0 +1,26 @@
+const isSharedExternal = (config) => typeof config === "string" ? true : config.external !== false;
+export const listExternalSpecifiers = (manifest) => {
+    const prefixes = [
+        `${manifest.namespace}/`,
+        manifest.externalDepsOrigin
+            ? (manifest.externalDepsPrefix ?? "@esm.sh/")
+            : null,
+    ].filter((value) => Boolean(value));
+    const exactImportSpecifiers = Object.entries(manifest.exactImports ?? {})
+        .filter(([, config]) => isSharedExternal(config))
+        .map(([specifier]) => specifier);
+    const sliceOverrideSpecifiers = Object.values(manifest.sliceOverrides ?? {})
+        .filter((slice) => slice.external !== false)
+        .map((slice) => slice.specifier);
+    return [...prefixes, ...exactImportSpecifiers, ...sliceOverrideSpecifiers];
+};
+export const createExternalMatcher = (manifest) => {
+    const exactSpecifiers = new Set(listExternalSpecifiers(manifest));
+    const namespacePrefix = `${manifest.namespace}/`;
+    const externalDepsPrefix = manifest.externalDepsOrigin
+        ? (manifest.externalDepsPrefix ?? "@esm.sh/")
+        : null;
+    return (source) => exactSpecifiers.has(source) ||
+        source.startsWith(namespacePrefix) ||
+        (externalDepsPrefix ? source.startsWith(externalDepsPrefix) : false);
+};

package/dist/host.d.ts

@@ -0,0 +1,15 @@
+import type { DynamicImporter, RuntimeCompositionManifest } from "./types.js";
+export type RuntimeHostOptions = {
+    manifest: RuntimeCompositionManifest;
+    target: Element;
+    onLoading?: (path: string) => void;
+    onError?: (error: unknown, path: string) => void;
+    importer?: DynamicImporter;
+};
+export type RuntimeHost = {
+    resolveAndMount(path: string): Promise<void>;
+    destroy(): Promise<void>;
+};
+export declare const createRuntimeHost: (options: RuntimeHostOptions) => RuntimeHost;
+export declare const notifyInternalNavigation: (path: string) => void;
+//# sourceMappingURL=host.d.ts.map

package/dist/host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../src/host.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,eAAe,EACf,0BAA0B,EAE3B,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,0BAA0B,CAAC;IACrC,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,SAAS,kBAAkB,KAAG,WA2G/D,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,MAAM,MAAM,KAAG,IAGvD,CAAC"}

package/dist/host.js

@@ -0,0 +1,100 @@
+import { importModule, unwrapDefault } from "./loader.js";
+import { resolveRoute } from "./routes.js";
+export const createRuntimeHost = (options) => {
+    const { manifest, target, importer } = options;
+    const onLoading = options.onLoading ?? (() => { });
+    // Reuse one generic message for both "no route matched" and "import/mount
+    // failed" — the default UI's job is "something's wrong", not a diagnostic
+    // surface; pass a custom onError to differentiate them.
+    const onError = options.onError ??
+        ((error, path) => {
+            console.error(`Failed to load slice for ${path}:`, error);
+            target.textContent = `Error: failed to load slice for ${path}`;
+        });
+    let latestToken = 0;
+    let currentSpecifier = null;
+    let currentModule = null;
+    const resetAndReportError = (error, path) => {
+        currentModule = null;
+        currentSpecifier = null;
+        onError(error, path);
+    };
+    const resolveAndMount = async (path) => {
+        const token = ++latestToken;
+        const match = resolveRoute(manifest, path);
+        if (!match) {
+            try {
+                if (currentModule) {
+                    await currentModule.unmount?.();
+                }
+            }
+            catch (error) {
+                if (token === latestToken) {
+                    resetAndReportError(error, path);
+                }
+                return;
+            }
+            if (token === latestToken) {
+                resetAndReportError(new Error(`No slice matches ${path}`), path);
+            }
+            return;
+        }
+        // Same module already mounted: everything past this point is the
+        // module's own responsibility, not the host's (e.g. its own internal
+        // sub-routing) — so there is nothing further to do here.
+        if (match.specifier === currentSpecifier) {
+            return;
+        }
+        onLoading(path);
+        try {
+            const runtimeModule = unwrapDefault(await importModule(match.specifier, importer));
+            if (token !== latestToken) {
+                return;
+            }
+            if (currentModule) {
+                await currentModule.unmount?.();
+            }
+            // Re-check after unmount: it's an arbitrary, user-authored async
+            // function that can take any amount of time, so a newer call may have
+            // become latest while this one was awaiting it. Without this check, a
+            // slow unmount could let this call commit stale state on top of a
+            // newer call's already-mounted module.
+            if (token !== latestToken) {
+                return;
+            }
+            currentSpecifier = match.specifier;
+            currentModule = runtimeModule;
+            // Accepted, narrower limitation: once mount() is actually called,
+            // there's no clean way to cancel it if a still-newer call starts and
+            // reaches its own mount() before this one finishes. Closing that would
+            // require serializing all resolveAndMount() calls behind a queue/lock,
+            // which is out of scope for the specific bug this token fix closes
+            // (the earlier, easily-hit case of an older call clobbering a newer
+            // call's already-*settled* mount).
+            await runtimeModule.mount(target, { route: match, manifest });
+        }
+        catch (error) {
+            if (token === latestToken) {
+                resetAndReportError(error, path);
+            }
+        }
+    };
+    const destroy = async () => {
+        latestToken += 1;
+        if (currentModule) {
+            await currentModule.unmount?.();
+        }
+        currentModule = null;
+        currentSpecifier = null;
+        // Same accepted, narrower limitation as the resolveAndMount-vs-
+        // resolveAndMount case above: if a resolveAndMount() call is already
+        // inside its own (uninterruptible) mount() when destroy() runs, that
+        // mount can still finish after this promise resolves, leaving something
+        // mounted that this host's own bookkeeping no longer reflects.
+    };
+    return { resolveAndMount, destroy };
+};
+export const notifyInternalNavigation = (path) => {
+    window.history.pushState({}, "", path);
+    window.dispatchEvent(new PopStateEvent("popstate"));
+};

package/dist/host.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=host.test.d.ts.map

package/dist/host.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.test.d.ts","sourceRoot":"","sources":["../src/host.test.ts"],"names":[],"mappings":""}

package/dist/host.test.js

@@ -0,0 +1,232 @@
+// @vitest-environment happy-dom
+import { describe, expect, test, vi } from "vitest";
+import { defineManifest } from "./manifest.js";
+import { createRuntimeHost, notifyInternalNavigation } from "./host.js";
+const manifest = defineManifest({
+    namespace: "@acme",
+    assetsOrigin: "https://assets.example.com",
+    sliceOverrides: {
+        search: { route: "/search/*", specifier: "@acme/search/index.mjs", entry: "index.mjs" },
+        cart: { route: "/cart/*", specifier: "@acme/cart/index.mjs", entry: "index.mjs" },
+        wishlist: { route: "/wishlist/*", specifier: "@acme/wishlist/index.mjs", entry: "index.mjs" },
+    },
+});
+const createMockModule = () => ({
+    mount: vi.fn(async () => { }),
+    unmount: vi.fn(async () => { }),
+});
+describe("notifyInternalNavigation", () => {
+    test("pushes the given path and dispatches a popstate event", () => {
+        const pushStateSpy = vi.spyOn(window.history, "pushState");
+        const popstateListener = vi.fn();
+        window.addEventListener("popstate", popstateListener);
+        notifyInternalNavigation("/search/detail");
+        expect(pushStateSpy).toHaveBeenCalledWith({}, "", "/search/detail");
+        expect(popstateListener).toHaveBeenCalledTimes(1);
+        window.removeEventListener("popstate", popstateListener);
+        pushStateSpy.mockRestore();
+    });
+});
+describe("createRuntimeHost", () => {
+    test("resolves a route, imports the module, and mounts it with route + manifest context", async () => {
+        const searchModule = createMockModule();
+        const importer = vi.fn(async () => ({ default: searchModule }));
+        const target = document.createElement("div");
+        const host = createRuntimeHost({ manifest, target, importer });
+        await host.resolveAndMount("/search");
+        expect(importer).toHaveBeenCalledWith("@acme/search/index.mjs");
+        expect(searchModule.mount).toHaveBeenCalledTimes(1);
+        const [mountTarget, mountContext] = searchModule.mount.mock.calls[0];
+        expect(mountTarget).toBe(target);
+        expect(mountContext.manifest).toBe(manifest);
+        expect(mountContext.route.specifier).toBe("@acme/search/index.mjs");
+    });
+    test("unmounts the previous module before mounting a module for a different specifier", async () => {
+        const searchModule = createMockModule();
+        const cartModule = createMockModule();
+        const importer = vi.fn(async (specifier) => ({
+            default: specifier === "@acme/search/index.mjs" ? searchModule : cartModule,
+        }));
+        const target = document.createElement("div");
+        const host = createRuntimeHost({ manifest, target, importer });
+        await host.resolveAndMount("/search");
+        await host.resolveAndMount("/cart");
+        expect(searchModule.unmount).toHaveBeenCalledTimes(1);
+        expect(cartModule.mount).toHaveBeenCalledTimes(1);
+    });
+    test("navigating to the same specifier again is a no-op", async () => {
+        const searchModule = createMockModule();
+        const importer = vi.fn(async () => ({ default: searchModule }));
+        const target = document.createElement("div");
+        const host = createRuntimeHost({ manifest, target, importer });
+        await host.resolveAndMount("/search");
+        await host.resolveAndMount("/search/results");
+        expect(searchModule.mount).toHaveBeenCalledTimes(1);
+        expect(searchModule.unmount).not.toHaveBeenCalled();
+    });
+    test("calls onError with a descriptive message when no route matches", async () => {
+        const onError = vi.fn();
+        const target = document.createElement("div");
+        const importer = vi.fn();
+        const host = createRuntimeHost({ manifest, target, importer, onError });
+        await host.resolveAndMount("/");
+        expect(importer).not.toHaveBeenCalled();
+        expect(onError).toHaveBeenCalledTimes(1);
+        const [error, path] = onError.mock.calls[0];
+        expect(error).toBeInstanceOf(Error);
+        expect(error.message).toBe("No slice matches /");
+        expect(path).toBe("/");
+    });
+    test("default onError logs to console.error and writes a message into target", async () => {
+        const target = document.createElement("div");
+        const importer = vi.fn();
+        const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        const host = createRuntimeHost({ manifest, target, importer });
+        await host.resolveAndMount("/");
+        expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+        expect(target.textContent).toBe("Error: failed to load slice for /");
+        consoleErrorSpy.mockRestore();
+    });
+    test("calls onError when the importer rejects, and resets state so a later navigation isn't blocked", async () => {
+        const onError = vi.fn();
+        const target = document.createElement("div");
+        const importer = vi.fn(async () => {
+            throw new Error("network failure");
+        });
+        const host = createRuntimeHost({ manifest, target, importer, onError });
+        await host.resolveAndMount("/search");
+        expect(onError).toHaveBeenCalledWith(new Error("network failure"), "/search");
+        const searchModule = createMockModule();
+        importer.mockImplementation(async () => ({ default: searchModule }));
+        await host.resolveAndMount("/search");
+        expect(searchModule.mount).toHaveBeenCalledTimes(1);
+    });
+    test("calls onError when mount() throws", async () => {
+        const onError = vi.fn();
+        const target = document.createElement("div");
+        const failingModule = {
+            mount: vi.fn(async () => {
+                throw new Error("mount blew up");
+            }),
+        };
+        const importer = vi.fn(async () => ({ default: failingModule }));
+        const host = createRuntimeHost({ manifest, target, importer, onError });
+        await host.resolveAndMount("/search");
+        expect(onError).toHaveBeenCalledWith(new Error("mount blew up"), "/search");
+    });
+    test("calls onLoading with the path before importing a new module, but not for a same-specifier no-op", async () => {
+        const onLoading = vi.fn();
+        const searchModule = createMockModule();
+        const importer = vi.fn(async () => ({ default: searchModule }));
+        const target = document.createElement("div");
+        const host = createRuntimeHost({ manifest, target, importer, onLoading });
+        await host.resolveAndMount("/search");
+        await host.resolveAndMount("/search/results");
+        expect(onLoading).toHaveBeenCalledTimes(1);
+        expect(onLoading).toHaveBeenCalledWith("/search");
+    });
+    test("calls onError (not the 'no slice matches' message) when unmounting during a no-match navigation itself throws", async () => {
+        const onError = vi.fn();
+        const target = document.createElement("div");
+        const searchModule = {
+            mount: vi.fn(async () => { }),
+            unmount: vi.fn(async () => {
+                throw new Error("unmount blew up");
+            }),
+        };
+        const importer = vi.fn(async () => ({ default: searchModule }));
+        const host = createRuntimeHost({ manifest, target, importer, onError });
+        await host.resolveAndMount("/search");
+        await host.resolveAndMount("/");
+        expect(onError).toHaveBeenCalledTimes(1);
+        expect(onError).toHaveBeenCalledWith(new Error("unmount blew up"), "/");
+    });
+    test("discards a stale import: only the last-requested module ends up mounted", async () => {
+        const searchModule = createMockModule();
+        const cartModule = createMockModule();
+        const target = document.createElement("div");
+        let resolveSearchImport;
+        const searchImportPromise = new Promise((resolve) => {
+            resolveSearchImport = resolve;
+        });
+        const importer = vi.fn(async (specifier) => {
+            if (specifier === "@acme/search/index.mjs") {
+                return searchImportPromise;
+            }
+            return { default: cartModule };
+        });
+        const host = createRuntimeHost({ manifest, target, importer });
+        const firstCall = host.resolveAndMount("/search");
+        const secondCall = host.resolveAndMount("/cart");
+        await secondCall;
+        expect(cartModule.mount).toHaveBeenCalledTimes(1);
+        resolveSearchImport({ default: searchModule });
+        await firstCall;
+        expect(searchModule.mount).not.toHaveBeenCalled();
+        expect(searchModule.unmount).not.toHaveBeenCalled();
+        expect(cartModule.unmount).not.toHaveBeenCalled();
+    });
+    test("discards a stale call even when a newer call starts while this call is still awaiting its own unmount()", async () => {
+        const target = document.createElement("div");
+        const initialModule = createMockModule();
+        const staleModule = createMockModule();
+        const winningModule = createMockModule();
+        let resolveUnmount;
+        const unmountPromise = new Promise((resolve) => {
+            resolveUnmount = resolve;
+        });
+        initialModule.unmount.mockImplementation(() => unmountPromise);
+        const importer = vi.fn(async (specifier) => {
+            if (specifier === "@acme/search/index.mjs") {
+                return { default: initialModule };
+            }
+            if (specifier === "@acme/cart/index.mjs") {
+                return { default: staleModule };
+            }
+            return { default: winningModule };
+        });
+        const host = createRuntimeHost({ manifest, target, importer });
+        await host.resolveAndMount("/search");
+        // Stale call: its own import (cart) resolves immediately, so it passes
+        // the post-import staleness check while it's still the latest call, then
+        // blocks on unmounting `initialModule` (the shared, manually-controlled
+        // promise below).
+        const staleCall = host.resolveAndMount("/cart");
+        await vi.waitFor(() => {
+            expect(initialModule.unmount).toHaveBeenCalled();
+        });
+        // A newer call starts and targets a third slice while the stale call is
+        // still awaiting that same unmount().
+        const winningCall = host.resolveAndMount("/wishlist");
+        resolveUnmount();
+        await Promise.all([staleCall, winningCall]);
+        expect(staleModule.mount).not.toHaveBeenCalled();
+        expect(winningModule.mount).toHaveBeenCalledTimes(1);
+    });
+    test("destroy() unmounts the current module and resets state", async () => {
+        const searchModule = createMockModule();
+        const importer = vi.fn(async () => ({ default: searchModule }));
+        const target = document.createElement("div");
+        const host = createRuntimeHost({ manifest, target, importer });
+        await host.resolveAndMount("/search");
+        await host.destroy();
+        expect(searchModule.unmount).toHaveBeenCalledTimes(1);
+        await host.resolveAndMount("/search");
+        expect(searchModule.mount).toHaveBeenCalledTimes(2);
+    });
+    test("destroy() invalidates an in-flight resolveAndMount call", async () => {
+        const searchModule = createMockModule();
+        const target = document.createElement("div");
+        let resolveImport;
+        const importPromise = new Promise((resolve) => {
+            resolveImport = resolve;
+        });
+        const importer = vi.fn(async () => importPromise);
+        const host = createRuntimeHost({ manifest, target, importer });
+        const pendingCall = host.resolveAndMount("/search");
+        await host.destroy();
+        resolveImport({ default: searchModule });
+        await pendingCall;
+        expect(searchModule.mount).not.toHaveBeenCalled();
+    });
+});

package/dist/import-map.d.ts

@@ -0,0 +1,8 @@
+import type { ImportMap, RuntimeCompositionManifest, RuntimeEnvironment } from "./types.js";
+export type CreateImportMapOptions = {
+    environment?: RuntimeEnvironment;
+    devDeps?: boolean;
+};
+export declare const createImportMap: (manifest: RuntimeCompositionManifest, options?: CreateImportMapOptions) => ImportMap;
+export declare const createImportMapBootstrapScript: (manifest: RuntimeCompositionManifest, options?: CreateImportMapOptions) => string;
+//# sourceMappingURL=import-map.d.ts.map

package/dist/import-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-map.d.ts","sourceRoot":"","sources":["../src/import-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,0BAA0B,EAC1B,kBAAkB,EAGnB,MAAM,YAAY,CAAC;AA4BpB,MAAM,MAAM,sBAAsB,GAAG;IACnC,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AA6BF,eAAO,MAAM,eAAe,GAC1B,UAAU,0BAA0B,EACpC,UAAS,sBAA2B,KACnC,SAiDF,CAAC;AAIF,eAAO,MAAM,8BAA8B,GACzC,UAAU,0BAA0B,EACpC,UAAS,sBAA2B,KACnC,MAwCF,CAAC"}

package/dist/import-map.js

@@ -0,0 +1,106 @@
+import { joinUrl } from "./manifest.js";
+const resolveSharedDependencyUrl = (config, environment) => {
+    if (typeof config === "string") {
+        return config;
+    }
+    return config.environments?.[environment] ?? config.url;
+};
+const resolveSliceUrl = (manifest, slice, environment) => {
+    const entry = slice.environments?.[environment] ?? slice.entry;
+    if (/^https?:\/\//.test(entry)) {
+        return entry;
+    }
+    return joinUrl(manifest.assetsOrigin, entry);
+};
+const ensurePrefix = (value) => value.endsWith("/") ? value : `${value}/`;
+const buildDepsQuery = (peerDeps) => Object.entries(peerDeps)
+    .map(([name, version]) => `${name}@${version}`)
+    .join(",");
+const applyDevFlag = (value, externalDepsOrigin) => {
+    if (!value.startsWith(externalDepsOrigin)) {
+        return value;
+    }
+    return value.includes("?") ? `${value}&dev` : `${value}?dev`;
+};
+const resolveAssetsOrigin = (manifest, environment) => manifest.environments?.[environment]?.assetsOrigin ?? manifest.assetsOrigin;
+const resolveExternalDepsOrigin = (manifest, environment) => manifest.environments?.[environment]?.externalDepsOrigin ??
+    manifest.externalDepsOrigin;
+export const createImportMap = (manifest, options = {}) => {
+    const environment = options.environment ?? "production";
+    const imports = {};
+    const namespacePrefix = ensurePrefix(manifest.namespace);
+    imports[namespacePrefix] = ensurePrefix(resolveAssetsOrigin(manifest, environment));
+    const externalDepsOrigin = resolveExternalDepsOrigin(manifest, environment);
+    const externalDepsPrefix = ensurePrefix(manifest.externalDepsPrefix ?? "@esm.sh/");
+    if (externalDepsOrigin) {
+        imports[externalDepsPrefix] = ensurePrefix(externalDepsOrigin);
+        for (const entry of manifest.externalDeps ?? []) {
+            const name = typeof entry === "string" ? entry : entry.name;
+            const peerDeps = typeof entry === "string" ? manifest.defaultPeerDeps : entry.peerDeps;
+            const specifier = `${externalDepsPrefix}${name}`;
+            const baseUrl = joinUrl(externalDepsOrigin, name);
+            imports[specifier] = peerDeps
+                ? `${baseUrl}?deps=${buildDepsQuery(peerDeps)}`
+                : baseUrl;
+        }
+    }
+    for (const [specifier, config] of Object.entries(manifest.exactImports ?? {})) {
+        imports[specifier] = resolveSharedDependencyUrl(config, environment);
+    }
+    for (const slice of Object.values(manifest.sliceOverrides ?? {})) {
+        imports[slice.specifier] = resolveSliceUrl(manifest, slice, environment);
+    }
+    for (const [sliceName, sliceOrigin] of Object.entries(manifest.environments?.[environment]?.sliceOrigins ?? {})) {
+        imports[`${namespacePrefix}${sliceName}/`] = ensurePrefix(sliceOrigin);
+    }
+    if (options.devDeps && externalDepsOrigin) {
+        for (const [specifier, url] of Object.entries(imports)) {
+            if (!specifier.endsWith("/") && url.startsWith(externalDepsOrigin)) {
+                imports[specifier] = applyDevFlag(url, externalDepsOrigin);
+            }
+        }
+    }
+    return { imports };
+};
+// Note: options.devDeps has no effect here — dev-mode is always resolved at
+// runtime via the generated script's own `?dev` detection, not baked in here.
+export const createImportMapBootstrapScript = (manifest, options = {}) => {
+    const environment = options.environment ?? "production";
+    const { imports } = createImportMap(manifest, { environment });
+    const externalDepsOrigin = resolveExternalDepsOrigin(manifest, environment) ?? "";
+    return `(function () {
+  var importMap = ${JSON.stringify({ imports })};
+  var externalDepsOrigin = ${JSON.stringify(externalDepsOrigin)};
+
+  var currentScript = document.currentScript;
+  var isDev = false;
+  if (currentScript) {
+    var scriptUrl = new URL(currentScript.src, window.location.origin);
+    isDev = scriptUrl.searchParams.has("dev");
+  }
+
+  var addDevFlag = function (specifier, value) {
+    if (
+      !isDev ||
+      specifier.slice(-1) === "/" ||
+      !externalDepsOrigin ||
+      typeof value !== "string" ||
+      value.indexOf(externalDepsOrigin) !== 0
+    ) {
+      return value;
+    }
+    return value.indexOf("?") !== -1 ? value + "&dev" : value + "?dev";
+  };
+
+  var adjustedImports = {};
+  Object.keys(importMap.imports).forEach(function (specifier) {
+    adjustedImports[specifier] = addDevFlag(specifier, importMap.imports[specifier]);
+  });
+
+  var script = document.createElement("script");
+  script.type = "importmap";
+  script.textContent = JSON.stringify({ imports: adjustedImports });
+  document.head.appendChild(script);
+})();
+`;
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./externals.js";
+export * from "./host.js";
+export * from "./import-map.js";
+export * from "./loader.js";
+export * from "./manifest.js";
+export * from "./routes.js";
+export * from "./types.js";
+export * from "./validation.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":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./externals.js";
+export * from "./host.js";
+export * from "./import-map.js";
+export * from "./loader.js";
+export * from "./manifest.js";
+export * from "./routes.js";
+export * from "./types.js";
+export * from "./validation.js";

package/dist/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../src/index.test.ts"],"names":[],"mappings":""}

package/dist/index.test.js

@@ -0,0 +1,240 @@
+// @vitest-environment happy-dom
+import { describe, expect, test, vi } from "vitest";
+import { createExternalMatcher, createImportMap, createImportMapBootstrapScript, createRuntimeHost, defineManifest, notifyInternalNavigation, resolveRoute, validateManifest, } from "./index.js";
+const manifest = defineManifest({
+    namespace: "@acme",
+    assetsOrigin: "https://assets.example.com",
+    externalDepsOrigin: "https://esm.sh",
+});
+describe("runtime composition core", () => {
+    test("creates an import map from namespace and external dependency origins", () => {
+        expect(createImportMap(manifest)).toEqual({
+            imports: {
+                "@acme/": "https://assets.example.com/",
+                "@esm.sh/": "https://esm.sh/",
+            },
+        });
+    });
+    test("uses environment-specific origins and slice origins", () => {
+        expect(createImportMap({
+            ...manifest,
+            environments: {
+                development: {
+                    assetsOrigin: "http://localhost:5173/assets",
+                    externalDepsOrigin: "https://esm.sh",
+                    sliceOrigins: {
+                        search: "http://localhost:5174",
+                    },
+                },
+            },
+        }, { environment: "development" })).toEqual({
+            imports: {
+                "@acme/": "http://localhost:5173/assets/",
+                "@esm.sh/": "https://esm.sh/",
+                "@acme/search/": "http://localhost:5174/",
+            },
+        });
+    });
+    test("includes exactImports entries in the generated import map", () => {
+        expect(createImportMap({
+            ...manifest,
+            exactImports: {
+                react: "https://esm.sh/react@19.2.4",
+            },
+        })).toEqual({
+            imports: {
+                "@acme/": "https://assets.example.com/",
+                "@esm.sh/": "https://esm.sh/",
+                react: "https://esm.sh/react@19.2.4",
+            },
+        });
+    });
+    test("generates externalDeps entries with defaultPeerDeps applied to bare strings", () => {
+        expect(createImportMap({
+            ...manifest,
+            externalDeps: ["zustand"],
+            defaultPeerDeps: { react: "19.2.4" },
+        })).toEqual({
+            imports: {
+                "@acme/": "https://assets.example.com/",
+                "@esm.sh/": "https://esm.sh/",
+                "@esm.sh/zustand": "https://esm.sh/zustand?deps=react@19.2.4",
+            },
+        });
+    });
+    test("supports externalDeps entries that opt out of peerDeps", () => {
+        expect(createImportMap({
+            ...manifest,
+            externalDeps: [{ name: "date-fns", peerDeps: false }],
+            defaultPeerDeps: { react: "19.2.4" },
+        })).toEqual({
+            imports: {
+                "@acme/": "https://assets.example.com/",
+                "@esm.sh/": "https://esm.sh/",
+                "@esm.sh/date-fns": "https://esm.sh/date-fns",
+            },
+        });
+    });
+    test("supports externalDeps entries with a custom peerDeps override", () => {
+        expect(createImportMap({
+            ...manifest,
+            externalDeps: [
+                {
+                    name: "@radix-ui/themes",
+                    peerDeps: { react: "19.2.4", "react-dom": "19.2.4/client" },
+                },
+            ],
+            defaultPeerDeps: { react: "19.2.4" },
+        })).toEqual({
+            imports: {
+                "@acme/": "https://assets.example.com/",
+                "@esm.sh/": "https://esm.sh/",
+                "@esm.sh/@radix-ui/themes": "https://esm.sh/@radix-ui/themes?deps=react@19.2.4,react-dom@19.2.4/client",
+            },
+        });
+    });
+    test("devDeps appends ?dev to exact external entries but not the catch-all prefix", () => {
+        expect(createImportMap({
+            ...manifest,
+            externalDeps: ["zustand"],
+            defaultPeerDeps: { react: "19.2.4" },
+        }, { devDeps: true })).toEqual({
+            imports: {
+                "@acme/": "https://assets.example.com/",
+                "@esm.sh/": "https://esm.sh/",
+                "@esm.sh/zustand": "https://esm.sh/zustand?deps=react@19.2.4&dev",
+            },
+        });
+    });
+    test("bare-string externalDeps entries resolve with no ?deps= query when defaultPeerDeps is unset", () => {
+        expect(createImportMap({
+            ...manifest,
+            externalDeps: ["zustand"],
+        })).toEqual({
+            imports: {
+                "@acme/": "https://assets.example.com/",
+                "@esm.sh/": "https://esm.sh/",
+                "@esm.sh/zustand": "https://esm.sh/zustand",
+            },
+        });
+    });
+    test("resolves routes by convention without explicit slice config", () => {
+        expect(resolveRoute(manifest, "/search/routes")?.specifier).toBe("@acme/search/index.mjs");
+    });
+    test("returns null for the root route unless an override is configured", () => {
+        expect(resolveRoute(manifest, "/")).toBeNull();
+    });
+    test("supports explicit routeOverrides for exceptions", () => {
+        const match = resolveRoute({
+            ...manifest,
+            routeOverrides: {
+                "/": "@acme/home/index.mjs",
+            },
+        }, "/");
+        expect(match?.specifier).toBe("@acme/home/index.mjs");
+    });
+    test("supports sliceOverrides for slices outside the entryFile convention", () => {
+        const match = resolveRoute({
+            ...manifest,
+            sliceOverrides: {
+                legacy: {
+                    route: "/legacy/*",
+                    specifier: "@acme/legacy",
+                    entry: "/legacy/index.mjs",
+                },
+            },
+        }, "/legacy/anything");
+        expect(match?.specifier).toBe("@acme/legacy");
+    });
+    test("creates an external matcher from the manifest", () => {
+        const isExternal = createExternalMatcher(manifest);
+        expect(isExternal("@esm.sh/react")).toBe(true);
+        expect(isExternal("@acme/search/index.mjs")).toBe(true);
+        expect(isExternal("@acme/anything")).toBe(true);
+        expect(isExternal("lodash")).toBe(false);
+    });
+    test("external matcher also matches exactImports and sliceOverrides specifiers", () => {
+        const isExternal = createExternalMatcher({
+            ...manifest,
+            exactImports: {
+                react: "https://esm.sh/react@19.2.4",
+            },
+            sliceOverrides: {
+                legacy: {
+                    route: "/legacy/*",
+                    specifier: "@vendor/legacy",
+                    entry: "/legacy/index.mjs",
+                },
+            },
+        });
+        expect(isExternal("react")).toBe(true);
+        expect(isExternal("@vendor/legacy")).toBe(true);
+        expect(isExternal("lodash")).toBe(false);
+    });
+    test("validates the base manifest without errors", () => {
+        expect(validateManifest(manifest).filter((item) => item.level === "error")).toHaveLength(0);
+    });
+    test("createImportMapBootstrapScript generates valid, parseable JavaScript", () => {
+        const script = createImportMapBootstrapScript(manifest);
+        expect(() => new Function(script)).not.toThrow();
+    });
+    test("createImportMapBootstrapScript embeds the computed import map", () => {
+        const script = createImportMapBootstrapScript(manifest);
+        expect(script).toContain('"@acme/":"https://assets.example.com/"');
+        expect(script).toContain('"@esm.sh/":"https://esm.sh/"');
+    });
+    test("createImportMapBootstrapScript embeds the manifest's own external dependency configuration, not hardcoded esm.sh defaults", () => {
+        const script = createImportMapBootstrapScript({
+            ...manifest,
+            externalDepsOrigin: "https://cdn.example.org",
+            externalDepsPrefix: "@cdn/",
+        });
+        expect(script).toContain("https://cdn.example.org");
+        expect(script).not.toContain("esm.sh");
+    });
+    test("createImportMapBootstrapScript injects an importmap script via document.head.appendChild", () => {
+        const script = createImportMapBootstrapScript(manifest);
+        expect(script).toContain("document.head.appendChild(script)");
+        expect(script).toContain('script.type = "importmap"');
+    });
+    test("createImportMapBootstrapScript's embedded dev-flag logic matches createImportMap's own devDeps behavior", () => {
+        const manifestWithExternalDeps = {
+            ...manifest,
+            externalDeps: ["zustand"],
+            defaultPeerDeps: { react: "19.2.4" },
+        };
+        const expectedWithDevDeps = createImportMap(manifestWithExternalDeps, {
+            devDeps: true,
+        }).imports;
+        const script = createImportMapBootstrapScript(manifestWithExternalDeps);
+        // Simulate the generated script running with a `?dev` script src, using
+        // the same DOM-shape the real browser execution relies on.
+        const documentStub = {
+            currentScript: { src: "http://localhost/importmap.js?dev" },
+            createElement: () => ({}),
+            head: { appendChild: (el) => {
+                    documentStub.result =
+                        el.textContent;
+                } },
+        };
+        const windowStub = { location: { origin: "http://localhost" } };
+        const run = new Function("document", "window", "URL", script);
+        run(documentStub, windowStub, URL);
+        const producedImports = JSON.parse(documentStub.result).imports;
+        expect(producedImports["@esm.sh/zustand"]).toBe(expectedWithDevDeps["@esm.sh/zustand"]);
+        expect(producedImports["@esm.sh/"]).toBe(expectedWithDevDeps["@esm.sh/"]);
+    });
+    test("re-exports createRuntimeHost and notifyInternalNavigation from the public barrel", async () => {
+        const target = document.createElement("div");
+        const mountSpy = vi.fn(async () => { });
+        const importer = vi.fn(async () => ({ default: { mount: mountSpy } }));
+        const host = createRuntimeHost({
+            manifest: { namespace: "@acme", assetsOrigin: "https://assets.example.com" },
+            target,
+            importer,
+        });
+        await host.resolveAndMount("/search");
+        expect(mountSpy).toHaveBeenCalledTimes(1);
+        expect(typeof notifyInternalNavigation).toBe("function");
+    });
+});

package/dist/loader.d.ts

@@ -0,0 +1,4 @@
+import type { DynamicImporter } from "./types.js";
+export declare const importModule: (specifier: string, importer?: DynamicImporter) => Promise<unknown>;
+export declare const unwrapDefault: (moduleNamespace: unknown) => unknown;
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,eAAO,MAAM,YAAY,GACvB,WAAW,MAAM,EACjB,WAAU,eAC4B,KACrC,OAAO,CAAC,OAAO,CAAwB,CAAC;AAE3C,eAAO,MAAM,aAAa,GAAI,iBAAiB,OAAO,KAAG,OAKpC,CAAC"}

package/dist/loader.js

@@ -0,0 +1,6 @@
+export const importModule = (specifier, importer = (specifier) => import(/* @vite-ignore */ specifier)) => importer(specifier);
+export const unwrapDefault = (moduleNamespace) => moduleNamespace &&
+    typeof moduleNamespace === "object" &&
+    "default" in moduleNamespace
+    ? moduleNamespace.default
+    : moduleNamespace;

package/dist/loader.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=loader.test.d.ts.map

package/dist/loader.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.test.d.ts","sourceRoot":"","sources":["../src/loader.test.ts"],"names":[],"mappings":""}

package/dist/loader.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, test, vi } from "vitest";
+import { importModule, unwrapDefault } from "./loader.js";
+describe("importModule", () => {
+    test("uses the default importer to call native dynamic import", async () => {
+        const namespace = (await importModule("./__fixtures__/dummy-module.js"));
+        expect(namespace.default).toBe("default-value");
+        expect(namespace.namedExport).toBe("named-value");
+    });
+    test("uses a custom importer when provided", async () => {
+        const customImporter = vi.fn(async (specifier) => ({
+            default: `loaded:${specifier}`,
+        }));
+        const result = await importModule("some-specifier", customImporter);
+        expect(customImporter).toHaveBeenCalledWith("some-specifier");
+        expect(result).toEqual({ default: "loaded:some-specifier" });
+    });
+});
+describe("unwrapDefault", () => {
+    test("returns the default export when present", () => {
+        expect(unwrapDefault({ default: "the-value" })).toBe("the-value");
+    });
+    test("returns the namespace itself when there is no default export", () => {
+        const namespace = { namedExport: "value" };
+        expect(unwrapDefault(namespace)).toBe(namespace);
+    });
+    test("returns non-object values unchanged", () => {
+        expect(unwrapDefault(null)).toBe(null);
+        expect(unwrapDefault(undefined)).toBe(undefined);
+        expect(unwrapDefault("plain-string")).toBe("plain-string");
+    });
+});

package/dist/manifest.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimeCompositionManifest } from "./types.js";
+export declare const defineManifest: <TManifest extends RuntimeCompositionManifest>(manifest: TManifest) => TManifest;
+export declare const trimTrailingSlash: (value: string) => string;
+export declare const trimLeadingSlash: (value: string) => string;
+export declare const joinUrl: (origin: string, path: string) => string;
+//# 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":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAE7D,eAAO,MAAM,cAAc,GAAI,SAAS,SAAS,0BAA0B,EACzE,UAAU,SAAS,KAClB,SAAqB,CAAC;AAEzB,eAAO,MAAM,iBAAiB,GAAI,OAAO,MAAM,KAAG,MACA,CAAC;AAEnD,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,KAAG,MACD,CAAC;AAEjD,eAAO,MAAM,OAAO,GAAI,QAAQ,MAAM,EAAE,MAAM,MAAM,KAAG,MACG,CAAC"}

package/dist/manifest.js

@@ -0,0 +1,4 @@
+export const defineManifest = (manifest) => manifest;
+export const trimTrailingSlash = (value) => value.endsWith("/") ? value.slice(0, -1) : value;
+export const trimLeadingSlash = (value) => value.startsWith("/") ? value.slice(1) : value;
+export const joinUrl = (origin, path) => `${trimTrailingSlash(origin)}/${trimLeadingSlash(path)}`;

package/dist/routes.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeCompositionManifest, RuntimeRouteMatch } from "./types.js";
+export declare const resolveRoute: (manifest: RuntimeCompositionManifest, path: string) => RuntimeRouteMatch | null;
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,0BAA0B,EAC1B,iBAAiB,EAElB,MAAM,YAAY,CAAC;AA6HpB,eAAO,MAAM,YAAY,GACvB,UAAU,0BAA0B,EACpC,MAAM,MAAM,KACX,iBAAiB,GAAG,IAiBtB,CAAC"}

package/dist/routes.js

@@ -0,0 +1,105 @@
+const normalizePath = (path) => {
+    const withoutHash = path.split("#")[0] ?? "/";
+    const withoutSearch = withoutHash.split("?")[0] ?? "/";
+    const normalized = withoutSearch.startsWith("/")
+        ? withoutSearch
+        : `/${withoutSearch}`;
+    return normalized.length > 1 && normalized.endsWith("/")
+        ? normalized.slice(0, -1)
+        : normalized;
+};
+const routePatternsFor = (slice) => Array.isArray(slice.route) ? slice.route : [slice.route];
+const routePatternsForOverride = (route, override) => {
+    if (typeof override === "string" || !override.route) {
+        return [route];
+    }
+    return Array.isArray(override.route) ? override.route : [override.route];
+};
+const ensureNamespacePrefix = (namespace) => namespace.endsWith("/") ? namespace : `${namespace}/`;
+const resolveConventionalSliceName = (path) => {
+    const [firstSegment] = normalizePath(path).split("/").filter(Boolean);
+    return firstSegment ?? null;
+};
+const buildConventionalSpecifier = (manifest, sliceName) => `${ensureNamespacePrefix(manifest.namespace)}${sliceName}/${manifest.entryFile ?? "index.mjs"}`;
+const matchRoutePattern = (pattern, pathname) => {
+    const normalizedPattern = normalizePath(pattern);
+    const normalizedPathname = normalizePath(pathname);
+    if (normalizedPattern.endsWith("/*")) {
+        const prefix = normalizedPattern.slice(0, -2);
+        return {
+            matched: normalizedPathname === prefix ||
+                normalizedPathname.startsWith(`${prefix}/`),
+            params: {},
+            score: prefix.length,
+        };
+    }
+    if (normalizedPattern === normalizedPathname) {
+        return {
+            matched: true,
+            params: {},
+            score: normalizedPattern.length + 1000,
+        };
+    }
+    return {
+        matched: false,
+        params: {},
+        score: -1,
+    };
+};
+const resolveExplicitRoute = (manifest, path) => {
+    const matches = [];
+    for (const [route, override] of Object.entries(manifest.routeOverrides ?? {})) {
+        for (const pattern of routePatternsForOverride(route, override)) {
+            const match = matchRoutePattern(pattern, path);
+            if (match.matched) {
+                const specifier = typeof override === "string" ? override : override.specifier;
+                matches.push({
+                    sliceName: specifier
+                        .slice(ensureNamespacePrefix(manifest.namespace).length)
+                        .split("/")[0] ?? "",
+                    specifier,
+                    route: pattern,
+                    params: match.params,
+                    score: match.score + 2000,
+                });
+            }
+        }
+    }
+    for (const [sliceName, slice] of Object.entries(manifest.sliceOverrides ?? {})) {
+        for (const route of routePatternsFor(slice)) {
+            const match = matchRoutePattern(route, path);
+            if (match.matched) {
+                matches.push({
+                    sliceName,
+                    slice,
+                    specifier: slice.specifier,
+                    route,
+                    params: match.params,
+                    score: match.score,
+                });
+            }
+        }
+    }
+    const [bestMatch] = matches.sort((a, b) => b.score - a.score);
+    if (!bestMatch) {
+        return null;
+    }
+    const { score: _score, ...routeMatch } = bestMatch;
+    return routeMatch;
+};
+export const resolveRoute = (manifest, path) => {
+    const explicitMatch = resolveExplicitRoute(manifest, path);
+    if (explicitMatch) {
+        return explicitMatch;
+    }
+    const sliceName = resolveConventionalSliceName(path);
+    if (!sliceName) {
+        return null;
+    }
+    return {
+        sliceName,
+        specifier: buildConventionalSpecifier(manifest, sliceName),
+        route: `/${sliceName}/*`,
+        params: {},
+    };
+};

package/dist/types.d.ts

@@ -0,0 +1,67 @@
+export type ImportMap = {
+    imports: Record<string, string>;
+    scopes?: Record<string, Record<string, string>>;
+};
+export type RuntimeEnvironment = "development" | "preview" | "production";
+export type EnvironmentUrlMap = Partial<Record<RuntimeEnvironment, string>>;
+export type SharedDependencyConfig = string | {
+    url: string;
+    environments?: EnvironmentUrlMap;
+    external?: boolean;
+};
+export type SliceConfig = {
+    route: string | string[];
+    specifier: string;
+    entry: string;
+    environments?: EnvironmentUrlMap;
+    external?: boolean;
+};
+export type RouteOverrideConfig = string | {
+    specifier: string;
+    route?: string | string[];
+};
+export type EnvironmentConfig = {
+    assetsOrigin?: string;
+    externalDepsOrigin?: string;
+    sliceOrigins?: Record<string, string>;
+};
+export type ExternalDepEntry = string | {
+    name: string;
+    peerDeps?: Record<string, string> | false;
+};
+export type RuntimeCompositionManifest = {
+    namespace: string;
+    assetsOrigin: string;
+    externalDepsOrigin?: string;
+    externalDepsPrefix?: string;
+    entryFile?: string;
+    environments?: Partial<Record<RuntimeEnvironment, EnvironmentConfig>>;
+    exactImports?: Record<string, SharedDependencyConfig>;
+    sliceOverrides?: Record<string, SliceConfig>;
+    routeOverrides?: Record<string, RouteOverrideConfig>;
+    externalDeps?: ExternalDepEntry[];
+    defaultPeerDeps?: Record<string, string>;
+};
+export type RuntimeRouteMatch = {
+    sliceName: string;
+    slice?: SliceConfig;
+    specifier: string;
+    route: string;
+    params: Record<string, string>;
+};
+export type RuntimeCompositionDiagnostic = {
+    level: "error" | "warning";
+    code: string;
+    message: string;
+};
+export type RuntimeModuleContext = {
+    route?: RuntimeRouteMatch;
+    manifest?: RuntimeCompositionManifest;
+    data?: unknown;
+};
+export type RuntimeModule = {
+    mount(target: Element, context?: RuntimeModuleContext): void | Promise<void>;
+    unmount?(): void | Promise<void>;
+};
+export type DynamicImporter = (specifier: string) => Promise<unknown>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

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

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/validation.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeCompositionDiagnostic, RuntimeCompositionManifest } from "./types.js";
+export declare const validateManifest: (manifest: RuntimeCompositionManifest) => RuntimeCompositionDiagnostic[];
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAC5B,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,gBAAgB,GAC3B,UAAU,0BAA0B,KACnC,4BAA4B,EAgF9B,CAAC"}

package/dist/validation.js

@@ -0,0 +1,67 @@
+export const validateManifest = (manifest) => {
+    const diagnostics = [];
+    if (!manifest.namespace.startsWith("@")) {
+        diagnostics.push({
+            level: "warning",
+            code: "namespace-format",
+            message: "Manifest namespace should be a bare package scope, e.g. @acme.",
+        });
+    }
+    if (!/^https?:\/\//.test(manifest.assetsOrigin)) {
+        diagnostics.push({
+            level: "error",
+            code: "assets-origin-url",
+            message: "assetsOrigin must be an absolute HTTP(S) URL.",
+        });
+    }
+    if (manifest.externalDepsOrigin &&
+        !/^https?:\/\//.test(manifest.externalDepsOrigin)) {
+        diagnostics.push({
+            level: "error",
+            code: "external-deps-origin-url",
+            message: "externalDepsOrigin must be an absolute HTTP(S) URL.",
+        });
+    }
+    if (manifest.externalDepsPrefix &&
+        !manifest.externalDepsPrefix.endsWith("/")) {
+        diagnostics.push({
+            level: "warning",
+            code: "external-deps-prefix-format",
+            message: "externalDepsPrefix should end with / for import-map prefix matching.",
+        });
+    }
+    for (const [sliceName, slice] of Object.entries(manifest.sliceOverrides ?? {})) {
+        if (!slice.specifier.startsWith(`${manifest.namespace}/`)) {
+            diagnostics.push({
+                level: "warning",
+                code: "slice-specifier-namespace",
+                message: `Slice "${sliceName}" specifier should start with ${manifest.namespace}/.`,
+            });
+        }
+        if (!slice.entry.endsWith(".mjs") && !/^https?:\/\//.test(slice.entry)) {
+            diagnostics.push({
+                level: "warning",
+                code: "slice-entry-extension",
+                message: `Slice "${sliceName}" entry should usually point to an ESM .mjs asset.`,
+            });
+        }
+    }
+    for (const [route, override] of Object.entries(manifest.routeOverrides ?? {})) {
+        const specifier = typeof override === "string" ? override : override.specifier;
+        if (!route.startsWith("/")) {
+            diagnostics.push({
+                level: "warning",
+                code: "route-override-format",
+                message: `Route override "${route}" should start with /.`,
+            });
+        }
+        if (!specifier.startsWith(`${manifest.namespace}/`)) {
+            diagnostics.push({
+                level: "warning",
+                code: "route-override-specifier-namespace",
+                message: `Route override "${route}" specifier should start with ${manifest.namespace}/.`,
+            });
+        }
+    }
+    return diagnostics;
+};

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@rmc-toolkit/core",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "test": "vitest run"
+  }
+}
+