@pix3/vite-plugin 0.0.0-stage → 2.0.0-alpha.1

package/dist/build/scan.js

@@ -0,0 +1,375 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { NON_SHIPPABLE_DIRECTORIES } from "../files/scan.js";
+import { RESERVED_ROOT_DIR } from "../files/paths.js";
+import { normalizeResRoot, resToAbsolute, stripRes, wireToRes } from "./project-manifest.js";
+const TEXT_SOURCE_EXTENSIONS = new Set([
+    'pix3scene',
+    'prefab',
+    'pix3anim',
+    'ts',
+    'tsx',
+    'mts',
+    'cts',
+    'js',
+    'jsx',
+    'mjs',
+    'cjs',
+    'json',
+    'yaml',
+    'yml',
+    'html',
+    'css',
+    'atlas',
+    // Single-file components: a game may hang its HUD on a framework.
+    'vue',
+    'svelte',
+    'astro',
+]);
+/** Text sources whose `import`s are imports (not a `package.json`'s dependency list). */
+const CODE_EXTENSIONS = new Set([
+    'ts',
+    'tsx',
+    'mts',
+    'cts',
+    'js',
+    'jsx',
+    'mjs',
+    'cjs',
+    'html',
+    'vue',
+    'svelte',
+    'astro',
+]);
+/** Tests and declarations: their mentions would only keep modules the game never runs. */
+const NOT_A_SOURCE = /\.(?:spec|test)\.[cm]?[jt]sx?$|\.d\.[cm]?ts$|^package-lock\.json$/;
+const SCENE_LIKE = /\.(pix3scene|prefab)$/i;
+const SCANNABLE_RESOURCE = /\.(pix3scene|prefab|pix3anim)$/i;
+const RESOURCE_PATH_PATTERN = /res:\/\/([^\s"'`\])]+)/g;
+const MENTIONED_NAME_PATTERN = /[A-Za-z_][A-Za-z0-9_]*(?::[A-Za-z_][A-Za-z0-9_]*)*/g;
+const IMPORT_SPECIFIER_PATTERN = /\b(?:from|import)\s*\(?\s*['"`]([^'"`\s]+)['"`]|\brequire\s*\(\s*['"`]([^'"`\s]+)['"`]/g;
+/** Every identifier-like token of a text (the strip's mention superset) into `names`. */
+export const collectMentionedNames = (text, names) => {
+    for (const match of text.matchAll(MENTIONED_NAME_PATTERN))
+        names.add(match[0]);
+};
+/** Every module specifier a code text imports, statically or not, into `specifiers`. */
+export const collectImportedSpecifiers = (text, specifiers) => {
+    for (const match of text.matchAll(IMPORT_SPECIFIER_PATTERN)) {
+        specifiers.add(match[1] ?? match[2]);
+    }
+};
+/** Whether a set of specifiers imports `name` itself or a subpath of it. */
+const importsPackage = (specifiers, name) => [...specifiers].some(specifier => specifier === name || specifier.startsWith(`${name}/`));
+/** Names that mean "this project talks to the multiplayer stack". */
+export const NETWORK_MENTION_NAMES = [
+    'network',
+    'netNodes',
+    'Network',
+    'NetworkService',
+    'NetworkedNode',
+    'ReplicatedTransform',
+    'NetworkedNodeBehavior',
+    'ReplicatedTransformBehavior',
+    'core:NetworkedNode',
+    'core:ReplicatedTransform',
+];
+const SPINE_PAGE_IMAGE_PATTERN = /\.(png|jpg|jpeg|webp|ktx2|basis|bmp)$/i;
+/**
+ * A `.pix3scene` that is instantiated rather than navigated to: `prefabs/`, `.prefab`, and
+ * `scenes/ui/` overlays (the conventions of the 1.x exporter and `pix3 smoke`).
+ */
+export const isPrefabPath = (path) => /(^|\/)prefabs\//i.test(path) || /\.prefab$/i.test(path) || /(^|\/)scenes\/ui\//i.test(path);
+/** A scene the player can boot into or `changeScene` to: a `.pix3scene` that is not a prefab. */
+export const isPlayableScenePath = (path) => path.toLowerCase().endsWith('.pix3scene') && !isPrefabPath(path);
+const hasFileExtension = (path) => /\.[a-zA-Z0-9]+$/.test(path);
+const extensionOf = (name) => {
+    const dot = name.lastIndexOf('.');
+    return dot <= 0 ? '' : name.slice(dot + 1).toLowerCase();
+};
+/** Page image names declared inside an `.atlas` file (port of `parseSpineAtlasPageNames`). */
+export const parseSpineAtlasPageNames = (atlasText) => {
+    const pages = [];
+    let expectPage = true;
+    for (const rawLine of atlasText.split(/\r?\n/)) {
+        if (rawLine.trim().length === 0) {
+            expectPage = true;
+            continue;
+        }
+        if (expectPage) {
+            const candidate = rawLine.trim();
+            if (SPINE_PAGE_IMAGE_PATTERN.test(candidate))
+                pages.push(candidate);
+            expectPage = false;
+        }
+    }
+    return pages;
+};
+const resolveSpinePagePath = (atlasPath, pageName) => {
+    const name = pageName.trim().replace(/^\.\//, '');
+    if (/^[a-z]+[a-z0-9+.-]*:\/\//i.test(name) || name.startsWith('/'))
+        return stripRes(name);
+    const separator = atlasPath.lastIndexOf('/');
+    return separator < 0 ? name : `${atlasPath.slice(0, separator + 1)}${name}`;
+};
+/** Every file under `root` as a wire path, excluding tooling, build output and `.pix3/`. */
+export const listProjectFiles = async (root) => {
+    const out = [];
+    const walk = async (wireDir) => {
+        const absolute = wireDir ? join(root, ...wireDir.split('/')) : root;
+        let entries;
+        try {
+            entries = await readdir(absolute, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+        for (const entry of entries) {
+            const wirePath = wireDir ? `${wireDir}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                if (NON_SHIPPABLE_DIRECTORIES.has(entry.name))
+                    continue;
+                if (!wireDir && entry.name === RESERVED_ROOT_DIR)
+                    continue;
+                await walk(wirePath);
+            }
+            else if (entry.isFile()) {
+                out.push(wirePath);
+            }
+            // Symlinks are neither listed nor followed (the file API's rule, `files/scan.ts`).
+        }
+    };
+    await walk('');
+    return out;
+};
+const isTextSource = (wirePath) => {
+    const name = wirePath.slice(wirePath.lastIndexOf('/') + 1);
+    return TEXT_SOURCE_EXTENSIONS.has(extensionOf(name)) && !NOT_A_SOURCE.test(name);
+};
+/** The static directory prefix of an interpolated `res://` path, or null (port of 1.x). */
+const staticDirectoryPrefix = (resourcePath) => {
+    const staticPrefix = resourcePath.split('${')[0] ?? '';
+    const lastSlash = staticPrefix.lastIndexOf('/');
+    if (lastSlash <= 0)
+        return null;
+    const directory = staticPrefix.slice(0, lastSlash);
+    return directory.length > 0 ? directory : null;
+};
+export const scanProject = async (options) => {
+    const { root, manifest } = options;
+    const resRoot = normalizeResRoot(options.resRoot);
+    const warnings = [];
+    const mentionedNames = new Set();
+    const importedSpecifiers = new Set();
+    const resAbsolute = (resPath) => resToAbsolute(root, resRoot, resPath);
+    const wirePaths = await listProjectFiles(root);
+    const resFiles = new Set();
+    for (const wirePath of wirePaths) {
+        const resPath = wireToRes(wirePath, resRoot);
+        if (resPath !== null)
+            resFiles.add(resPath);
+    }
+    // One pass over every text source: mentions and `res://` references.
+    const assets = new Set();
+    const directoryQueue = [];
+    const queuedDirectories = new Set();
+    const scanQueue = [];
+    const scanned = new Set();
+    const addResource = (raw) => {
+        const resourcePath = stripRes(raw.trim());
+        if (!resourcePath)
+            return;
+        if (!hasFileExtension(resourcePath)) {
+            if (!queuedDirectories.has(resourcePath)) {
+                queuedDirectories.add(resourcePath);
+                directoryQueue.push(resourcePath);
+            }
+            return;
+        }
+        if (assets.has(resourcePath))
+            return;
+        assets.add(resourcePath);
+        if (SCANNABLE_RESOURCE.test(resourcePath) && !scanned.has(resourcePath)) {
+            scanQueue.push(resourcePath);
+        }
+    };
+    const collectFromText = (contents) => {
+        collectMentionedNames(contents, mentionedNames);
+        for (const match of contents.matchAll(RESOURCE_PATH_PATTERN)) {
+            const resourcePath = (match[1] ?? '').trim();
+            if (resourcePath.includes('${') || resourcePath.includes('`')) {
+                const prefix = staticDirectoryPrefix(resourcePath);
+                if (prefix)
+                    addResource(prefix);
+            }
+            else {
+                addResource(resourcePath);
+            }
+        }
+    };
+    let textSourceCount = 0;
+    for (const wirePath of wirePaths) {
+        if (!isTextSource(wirePath))
+            continue;
+        let contents;
+        try {
+            contents = await readFile(join(root, ...wirePath.split('/')), 'utf8');
+        }
+        catch {
+            warnings.push(`Could not read ${wirePath}; its references were not scanned.`);
+            continue;
+        }
+        textSourceCount++;
+        collectFromText(contents);
+        if (CODE_EXTENSIONS.has(extensionOf(wirePath))) {
+            collectImportedSpecifiers(contents, importedSpecifiers);
+        }
+        const resPath = wireToRes(wirePath, resRoot);
+        if (resPath !== null && SCANNABLE_RESOURCE.test(resPath))
+            scanned.add(resPath);
+    }
+    // Every scene and prefab ships: a game may load any of them at run time.
+    const allSceneLike = [...resFiles].filter(path => SCENE_LIKE.test(path)).sort();
+    for (const scenePath of allSceneLike)
+        addResource(scenePath);
+    // Transitive: a resource reached only through a reference (a `.pix3anim` outside the text
+    // walk is impossible here — the walk read everything — but a referenced directory can yield
+    // scannable files, and those name more).
+    const drain = async () => {
+        while (scanQueue.length > 0 || directoryQueue.length > 0) {
+            const scannable = scanQueue.shift();
+            if (scannable !== undefined) {
+                if (scanned.has(scannable))
+                    continue;
+                scanned.add(scannable);
+                try {
+                    collectFromText(await readFile(resAbsolute(scannable), 'utf8'));
+                }
+                catch {
+                    // Missing: reported below, when the asset set is verified against the disk.
+                }
+                continue;
+            }
+            const directory = directoryQueue.shift();
+            if (directory === undefined)
+                continue;
+            const prefix = `${directory}/`;
+            for (const resPath of resFiles) {
+                if (resPath.startsWith(prefix))
+                    addResource(resPath);
+            }
+        }
+    };
+    await drain();
+    // Fonts are named only by the manifest, never by a `res://` in a scene.
+    for (const face of manifest.fonts)
+        addResource(face.path);
+    // Locale tables: only declared (or discovered) locales ship, plus their sprites.
+    const localization = manifest.localization ?? discoverLocalization(resFiles);
+    if (localization) {
+        const tables = new Set([localization.defaultLocale, localization.fallbackLocale ?? '', ...localization.locales]
+            .filter(locale => locale.length > 0)
+            .map(locale => `locales/${locale}.json`));
+        for (const table of tables) {
+            if (!resFiles.has(table))
+                continue;
+            addResource(table);
+            try {
+                const parsed = JSON.parse(await readFile(resAbsolute(table), 'utf8'));
+                for (const value of Object.values(parsed.sprites ?? {})) {
+                    if (typeof value === 'string' && value.trim())
+                        addResource(value);
+                }
+            }
+            catch {
+                warnings.push(`Failed to scan locale table for sprite references: ${table}`);
+            }
+        }
+    }
+    // Spine atlas pages live inside the `.atlas` text, invisible to the `res://` scan.
+    for (const atlasPath of [...assets].filter(path => /\.atlas$/i.test(path))) {
+        try {
+            const text = await readFile(resAbsolute(atlasPath), 'utf8');
+            for (const page of parseSpineAtlasPageNames(text)) {
+                addResource(resolveSpinePagePath(atlasPath, page));
+            }
+        }
+        catch {
+            warnings.push(`Failed to scan Spine atlas for page images: ${atlasPath}`);
+        }
+    }
+    await drain();
+    // Only files that exist ship; a reference to nothing is reported, not embedded as a miss.
+    const assetPaths = [];
+    for (const resPath of [...assets].sort()) {
+        if (resFiles.has(resPath)) {
+            assetPaths.push(resPath);
+            continue;
+        }
+        try {
+            if ((await stat(resAbsolute(resPath))).isFile()) {
+                assetPaths.push(resPath);
+                continue;
+            }
+        }
+        catch {
+            // fall through
+        }
+        warnings.push(`Referenced resource not found: res://${resPath}`);
+    }
+    const dependencies = options.dependencies;
+    const mentions = (name) => mentionedNames.has(name) || (dependencies?.mentionedNames.has(name) ?? false);
+    const imports = (name) => importsPackage(importedSpecifiers, name) ||
+        (dependencies ? importsPackage(dependencies.importedSpecifiers, name) : false);
+    const scenePaths = allSceneLike.filter(isPlayableScenePath);
+    const entryScenePath = resolveEntryScene(scenePaths, manifest, options.entryScene, warnings);
+    return {
+        scenePaths,
+        entryScenePath,
+        assetPaths,
+        mentionedNames,
+        importedSpecifiers,
+        usesSpine: mentions('SpineSkeleton2D'),
+        // A PostProcess node, or a script / library that imports the package itself: then the
+        // runtime's own import shares the one real copy instead of a stub beside it.
+        usesPostProcessing: mentions('PostProcess') || imports('postprocessing'),
+        usesNetwork: NETWORK_MENTION_NAMES.some(mentions),
+        localization,
+        netKindPrefabs: assetPaths
+            .filter(path => SCENE_LIKE.test(path) && isPrefabPath(path))
+            .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)),
+        warnings,
+        textSourceCount,
+    };
+};
+/** Zero-config localization: `locales/*.json` → `en` if present, else the first (editor rule). */
+export const discoverLocalization = (resFiles) => {
+    const ids = [...resFiles]
+        .map(path => /^locales\/([^/]+)\.json$/.exec(path)?.[1] ?? null)
+        .filter((id) => id !== null)
+        .sort();
+    if (ids.length === 0)
+        return null;
+    return { defaultLocale: ids.includes('en') ? 'en' : ids[0], locales: ids };
+};
+/**
+ * The scene the player boots into, the same in dev and in a build: `pix3({ entryScene })`, else
+ * `pix3project.yaml` `defaultExportScenePath`, else `scenes/main.pix3scene`, else the first scene.
+ * A named scene that is not one of `scenePaths` is skipped with a warning.
+ */
+export const resolveEntryScene = (scenePaths, manifest, requested, warnings) => {
+    const wanted = requested ? stripRes(requested) : '';
+    if (wanted && scenePaths.includes(wanted))
+        return wanted;
+    if (wanted)
+        warnings.push(`Requested entry scene is not a project scene: ${wanted}`);
+    const configured = manifest.defaultScenePath ?? '';
+    if (configured && scenePaths.includes(configured))
+        return configured;
+    if (configured)
+        warnings.push(`defaultExportScenePath is not a project scene: ${configured}`);
+    if (scenePaths.includes('scenes/main.pix3scene'))
+        return 'scenes/main.pix3scene';
+    return scenePaths[0] ?? '';
+};

package/dist/build/strip-decision.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Whether a build may strip unmentioned runtime modules (plan §B.6 item 2, N11). On by default.
+ * A dependency that declares `@pix3/runtime` is parsed first (`dependency-imports.ts`): its
+ * named imports keep their modules, and an import the build cannot follow (`import * as`, a
+ * dynamic import, a parse error) turns strip **off** with a message naming
+ * `pix3({ strip: { keep } })` — the owner names the runtime classes the library uses and strip
+ * stays on. `strip: false` switches it off for foreign entries; `strip: true` forces it on.
+ */
+export type StripOption = boolean | {
+    readonly keep?: readonly string[];
+};
+export interface StripDecision {
+    readonly enabled: boolean;
+    /** Why it is off (or on against findings), for the build log; null when nothing to say. */
+    readonly reason: string | null;
+    /** Names kept by `pix3({ strip: { keep } })`. */
+    readonly keep: readonly string[];
+}
+/** The fix a message names when a dependency's imports cannot be followed. */
+export declare const KEEP_HINT = "pix3({ strip: { keep: ['<RuntimeClass>', \u2026] } })";
+/** Project dependencies that themselves depend on `@pix3/runtime`. */
+export declare const runtimeDependents: (root: string) => string[];
+export interface StripFindings {
+    /** Imports of `@pix3/runtime` the build could not follow (from `scanDependencyImports`). */
+    readonly opaque: readonly string[];
+}
+export declare const decideStrip: (option: StripOption | undefined, findings?: StripFindings) => StripDecision;

package/dist/build/strip-decision.js

@@ -0,0 +1,82 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { findPackageDir } from "../dev-info.js";
+const OWN_PACKAGES = new Set([
+    '@pix3/runtime',
+    '@pix3/vite-plugin',
+    '@pix3/editor-core',
+    '@pix3/cli',
+]);
+/** The fix a message names when a dependency's imports cannot be followed. */
+export const KEEP_HINT = "pix3({ strip: { keep: ['<RuntimeClass>', …] } })";
+const readPackage = (dir) => {
+    try {
+        const parsed = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+};
+const namesOf = (pkg, ...sections) => {
+    const out = [];
+    for (const section of sections) {
+        const value = pkg[section];
+        if (value && typeof value === 'object')
+            out.push(...Object.keys(value));
+    }
+    return out;
+};
+/** Project dependencies that themselves depend on `@pix3/runtime`. */
+export const runtimeDependents = (root) => {
+    const pkg = readPackage(root);
+    if (!pkg)
+        return [];
+    const dependents = [];
+    const names = new Set(namesOf(pkg, 'dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'));
+    for (const name of names) {
+        if (OWN_PACKAGES.has(name))
+            continue;
+        const dir = findPackageDir(root, name);
+        const dependency = dir ? readPackage(dir) : null;
+        if (!dependency)
+            continue;
+        if (namesOf(dependency, 'dependencies', 'peerDependencies').includes('@pix3/runtime')) {
+            dependents.push(name);
+        }
+    }
+    return dependents.sort();
+};
+export const decideStrip = (option, findings = { opaque: [] }) => {
+    if (option === false)
+        return { enabled: false, reason: 'pix3({ strip: false })', keep: [] };
+    if (option === true) {
+        return { enabled: true, reason: 'forced by pix3({ strip: true })', keep: [] };
+    }
+    const keep = option && typeof option === 'object' ? [...(option.keep ?? [])] : [];
+    const opaque = findings.opaque;
+    if (opaque.length === 0) {
+        return {
+            enabled: true,
+            reason: keep.length > 0 ? `keeping ${keep.join(', ')} by pix3({ strip: { keep } })` : null,
+            keep,
+        };
+    }
+    const first = opaque[0] + (opaque.length > 1 ? ` (+${opaque.length - 1} more)` : '');
+    if (option && typeof option === 'object') {
+        return {
+            enabled: true,
+            reason: `${first} — the build cannot see which runtime modules it reaches; stripping anyway ` +
+                `because pix3({ strip: { keep } }) names what it uses` +
+                (keep.length > 0 ? ` (${keep.join(', ')})` : ' (nothing listed!)'),
+            keep,
+        };
+    }
+    return {
+        enabled: false,
+        reason: `${first} — the build cannot see which runtime modules it reaches, so nothing is ` +
+            `stripped. Name the runtime classes it uses with ${KEEP_HINT} to strip the rest, ` +
+            `or pass strip: true to strip regardless`,
+        keep,
+    };
+};

package/dist/build/strippable-runtime-modules.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Runtime modules a playable build may replace with a throwing stub when nothing in the project
+ * mentions them (plan §B.6 item 2; port of the 1.x `strippable-runtime-modules.ts`).
+ *
+ * Why a stub and not a runtime refactor: the plugin already owns the `load` hook, so "leave this
+ * out" costs one stub and changes no `@pix3/runtime` API — which matters because the package is
+ * consumed by external projects. See `../pix3/.plans/done/playable-export-size.md` §2 Р3/Р4.
+ *
+ * The table is only safe because of two invariants, both enforced by
+ * `strippable-runtime-modules.spec.ts` against the real import graph of `packages/runtime/src`:
+ *
+ * 1. Every **value** importer of a listed module — and every module that reaches it through the
+ *    lazy getter that constructs it (`SceneService.physics2d`, `JuiceApi.trail`) — is either
+ *    itself listed ({@link StrippableRuntimeModule.importers}), neutralised for this purpose
+ *    ({@link NEUTRALISED_IMPORTERS}), or explicitly excused as a lazy construction site
+ *    ({@link StrippableRuntimeModule.lazyValueImporters}); and that getter's name is a keep-name.
+ * 2. Behaviour ids match `behaviors/register-behaviors.ts`.
+ *
+ * Besides its keep-names, a module is kept by any mention of one of its **value exports** (the
+ * build reads them from the real source: {@link valueExportNames}) — the barrel re-exports every
+ * one, so `import { pointInPolygon } from '@pix3/runtime'` must keep `collision-shapes-2d` rather
+ * than hand the game a stub that throws (or a constant that reads `undefined`).
+ *
+ * If the runtime grows a new importer of a listed module, the spec fails and the entry has to be
+ * re-justified instead of quietly shipping a broken build.
+ */
+export interface StrippableRuntimeModule {
+    /** Path under `packages/runtime/src`, without extension. */
+    readonly modulePath: string;
+    /**
+     * Names that keep the module in the bundle when the project mentions any of them — the class
+     * name plus, for script components, the registry id as it appears in scene YAML
+     * (`type: core:Follow`).
+     */
+    readonly keepWhenMentioned: readonly string[];
+    /**
+     * Entries of this table that keep this module alive: value importers, and modules that reach
+     * it through a lazy getter of a module that is always kept (`this.scene?.physics2d` in a
+     * behaviour that imports only the service's types). Such a module can only be stripped once all
+     * of them are — the build runs that fixpoint.
+     */
+    readonly importers?: readonly string[];
+    /**
+     * Value importers that are NOT strippable, excused because they only construct the module
+     * lazily on a path unreachable for a project that never mentions it. Each one needs a comment
+     * saying why.
+     */
+    readonly lazyValueImporters?: readonly string[];
+}
+/**
+ * Importers whose references do not pin anything, because they cannot survive in a player bundle
+ * on their own:
+ *
+ * - `core/SceneLoader` — the `switch` over every node type; a case whose type never appears in a
+ *   shipped scene is dead code that only constructs the stub.
+ * - `index` — the package barrel; the bundler drops re-exports nobody imports.
+ * - `behaviors/register-behaviors` — registers classes by id into a `Map`; a stub registers fine
+ *   and `ScriptRegistry.createComponent` reports the throw.
+ * - `core/SceneSaver` — never constructed by a player (see `SceneManager`'s optional saver), so it
+ *   tree-shakes out with everything it imports.
+ *
+ * @internal The import-graph guard (`strippable-runtime-modules.spec.ts`) reads it.
+ */
+export declare const NEUTRALISED_IMPORTERS: readonly ["core/SceneLoader", "index", "behaviors/register-behaviors", "core/SceneSaver"];
+export declare const STRIPPABLE_RUNTIME_MODULES: readonly StrippableRuntimeModule[];
+/**
+ * The subset of {@link STRIPPABLE_RUNTIME_MODULES} that can leave a build in which
+ * `mentions(name)` is false for every name the entry (and, transitively, every entry that imports
+ * it) is kept by.
+ */
+export declare const resolveStrippableRuntimeModules: (mentions: (name: string) => boolean, 
+/** The module's value exports (from its real source); each one keeps it like a keep-name. */
+exportsOf?: (modulePath: string) => readonly string[]) => readonly StrippableRuntimeModule[];
+/** Every value export name of a module's source (the names that keep it besides the table's). */
+export declare const valueExportNames: (moduleSource: string) => string[];
+/**
+ * A drop-in replacement for a runtime module's source: same value exports, but every class throws
+ * if anything ever constructs it. Derived from the real source rather than hardcoded, so a renamed
+ * export cannot silently drift — and if a name is missed, the bundler fails the build with "no
+ * matching export" instead of shipping something broken.
+ *
+ * Types and interfaces need no stubs: the bundler erases type-only usages, so the importing module
+ * no longer references those names at all.
+ */
+export declare const buildStrippedModuleSource: (moduleSource: string, modulePath: string) => string;