@hyperfrontend/builder 0.1.0

package/_shared/bundle/dependencies/prune/namespace-usage/index.esm.js

@@ -0,0 +1,208 @@
+import { resolveRelativeTarget, classifyRequireBinding, getRequireSpecifier, parseChunk } from '../ast-utils/index.esm.js';
+import ts from 'typescript';
+import { createMap } from '../../../../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/map/index.esm.js';
+import { createSet } from '../../../../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.esm.js';
+
+const mergeDemand = (demand, name, contribution) => {
+    const current = demand.get(name);
+    if (current === 'all')
+        return;
+    if (contribution === 'all') {
+        demand.set(name, 'all');
+        return;
+    }
+    if (current)
+        for (const prop of contribution)
+            current.add(prop);
+    else
+        demand.set(name, createSet([...contribution]));
+};
+const classifyNamespaceUse = (node) => {
+    const parent = node.parent;
+    if (ts.isPropertyAccessExpression(parent)) {
+        // why: `obj.NS` — the value sits as the member name, not a use of the binding's value.
+        if (parent.name === node)
+            return { kind: 'ignore' };
+        return { kind: 'read', prop: parent.name.text };
+    }
+    if (ts.isElementAccessExpression(parent) && parent.expression === node) {
+        // why: a literal `NS["freeze"]` is a known slot; a computed `NS[k]` could read any slot, so keep them all.
+        return ts.isStringLiteralLike(parent.argumentExpression) ? { kind: 'read', prop: parent.argumentExpression.text } : { kind: 'bail' };
+    }
+    // why: `{ NS: … }` key and `{ NS: x } = …` binding key never reference the binding's value.
+    if (ts.isPropertyAssignment(parent) && parent.name === node)
+        return { kind: 'ignore' };
+    if (ts.isBindingElement(parent) && parent.propertyName === node)
+        return { kind: 'ignore' };
+    return { kind: 'bail' };
+};
+const recordMemberUse = (memberNode, exportName, usage) => {
+    const classification = classifyNamespaceUse(memberNode);
+    if (classification.kind === 'read')
+        mergeDemand(usage.perName, exportName, createSet([classification.prop]));
+    else
+        mergeDemand(usage.perName, exportName, 'all');
+};
+const ensureUsage = (edges, target) => {
+    const current = edges.get(target);
+    if (current)
+        return current;
+    const created = { bailAll: false, perName: createMap() };
+    edges.set(target, created);
+    return created;
+};
+const collectImports = (sourceFile, importerDir, edges, locals, bindingNodes) => {
+    for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement)) {
+            const target = resolveRelativeTarget(importerDir, statement.moduleSpecifier.text);
+            // why: a side-effect-only import has no clause and binds nothing to track.
+            if (target === null || !statement.importClause)
+                continue;
+            const clause = statement.importClause;
+            // why: a default import binds the whole module object — we cannot tell which export it aliases, so keep every namespace of the target.
+            if (clause.name)
+                ensureUsage(edges, target).bailAll = true;
+            const bindings = clause.namedBindings;
+            if (!bindings)
+                continue;
+            if (ts.isNamespaceImport(bindings)) {
+                ensureUsage(edges, target).bailAll = true;
+                continue;
+            }
+            for (const element of bindings.elements) {
+                locals.set(element.name.text, { target, exportName: (element.propertyName ?? element.name).text });
+                bindingNodes.add(element.name);
+                ensureUsage(edges, target);
+            }
+            continue;
+        }
+        if (ts.isExportDeclaration(statement) && statement.moduleSpecifier) {
+            const target = resolveRelativeTarget(importerDir, statement.moduleSpecifier.text);
+            if (target === null)
+                continue;
+            const usage = ensureUsage(edges, target);
+            // why: `export * from 'F'` re-exports every name wholesale — keep the whole surface.
+            if (!statement.exportClause || !ts.isNamedExports(statement.exportClause)) {
+                usage.bailAll = true;
+                continue;
+            }
+            // why: a re-export hands the namespace to another chunk's importers we cannot see — keep it whole (one-hop safety).
+            for (const element of statement.exportClause.elements)
+                mergeDemand(usage.perName, (element.propertyName ?? element.name).text, 'all');
+        }
+    }
+};
+const scanUse = (id, locals, edges, bindingNodes) => {
+    const tracked = locals.get(id.text);
+    if (!tracked || bindingNodes.has(id))
+        return;
+    const usage = edges.get(tracked.target);
+    // why: a target already marked wholesale needs no finer demand.
+    if (!usage || usage.bailAll)
+        return;
+    const classification = classifyNamespaceUse(id);
+    if (classification.kind === 'read')
+        mergeDemand(usage.perName, tracked.exportName, createSet([classification.prop]));
+    else if (classification.kind === 'bail')
+        mergeDemand(usage.perName, tracked.exportName, 'all');
+};
+const bindRequire = (call, target, edges, locals, namespaceBindings, bindingNodes) => {
+    const usage = ensureUsage(edges, target);
+    const shape = classifyRequireBinding(call);
+    switch (shape.kind) {
+        // why: `require('F').Export` / `require('F')['Export']` — inline member access selecting one export; classify the member's own use.
+        case 'prop':
+        case 'elem-static':
+            recordMemberUse(shape.member, shape.name, usage);
+            return;
+        // why: `require('F')[k]` could select any export — keep the whole target.
+        case 'elem-dynamic':
+            usage.bailAll = true;
+            return;
+        // why: a bare `require('./x')` statement binds nothing and reads no property — a side-effect-only import (mirrored from ESM, which skips clause-less imports) that forbids no slot.
+        case 'side-effect':
+            return;
+        case 'ns-binding':
+            namespaceBindings.set(shape.name.text, target);
+            bindingNodes.add(shape.name);
+            return;
+        case 'destructure':
+            for (const element of shape.pattern.elements) {
+                const key = element.propertyName ?? element.name;
+                // why: a rest element or a nested/computed binding captures more than one named export — keep the whole target.
+                if (element.dotDotDotToken || !ts.isIdentifier(element.name) || !(ts.isIdentifier(key) || ts.isStringLiteralLike(key))) {
+                    usage.bailAll = true;
+                    continue;
+                }
+                locals.set(element.name.text, { target, exportName: key.text });
+                bindingNodes.add(element.name);
+            }
+            return;
+        // why: a `require` not bound to a variable (call argument, spread, …) escapes member tracking — keep the whole target.
+        case 'escape':
+            usage.bailAll = true;
+            return;
+    }
+};
+const collectRequires = (sourceFile, importerDir, edges, locals, namespaceBindings, bindingNodes) => {
+    const visit = (node) => {
+        const specifier = getRequireSpecifier(node);
+        if (specifier !== null) {
+            const target = resolveRelativeTarget(importerDir, specifier);
+            if (target !== null)
+                bindRequire(node, target, edges, locals, namespaceBindings, bindingNodes);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+};
+const scanNamespaceBindingUse = (id, namespaceBindings, edges, bindingNodes) => {
+    const target = namespaceBindings.get(id.text);
+    if (target === undefined || bindingNodes.has(id))
+        return;
+    const usage = edges.get(target);
+    if (!usage || usage.bailAll)
+        return;
+    const parent = id.parent;
+    // why: `dep.Export …` — the member selects one export; classify how that member is used for the property read.
+    if (ts.isPropertyAccessExpression(parent) && parent.expression === id) {
+        recordMemberUse(parent, parent.name.text, usage);
+        return;
+    }
+    if (ts.isElementAccessExpression(parent) && parent.expression === id) {
+        // why: `dep["Export"]` selects a known export; `dep[k]` could select any, so keep every export of the target.
+        if (ts.isStringLiteralLike(parent.argumentExpression))
+            recordMemberUse(parent, parent.argumentExpression.text, usage);
+        else
+            usage.bailAll = true;
+        return;
+    }
+    // why: `obj.dep` — the binding sits as a member name, unrelated. Every other position consumes the module wholesale.
+    if (!(ts.isPropertyAccessExpression(parent) && parent.name === id))
+        usage.bailAll = true;
+};
+const collectNamespaceUsage = (source, importerDir, format) => {
+    const edges = createMap();
+    const sourceFile = parseChunk(source);
+    const locals = createMap();
+    const namespaceBindings = createMap();
+    const bindingNodes = createSet([]);
+    if (format === 'esm')
+        collectImports(sourceFile, importerDir, edges, locals, bindingNodes);
+    else
+        collectRequires(sourceFile, importerDir, edges, locals, namespaceBindings, bindingNodes);
+    if (locals.size === 0 && namespaceBindings.size === 0)
+        return edges;
+    const visit = (node) => {
+        if (ts.isIdentifier(node)) {
+            scanUse(node, locals, edges, bindingNodes);
+            if (namespaceBindings.size > 0)
+                scanNamespaceBindingUse(node, namespaceBindings, edges, bindingNodes);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return edges;
+};
+
+export { mergeDemand, classifyNamespaceUse, recordMemberUse, ensureUsage, collectImports, scanUse, bindRequire, collectRequires, scanNamespaceBindingUse, collectNamespaceUsage };

package/_shared/bundle/dependencies/prune/specifiers/index.cjs.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const index_cjs_js$9 = require('../../../../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.cjs.js');
+const index_cjs_js$2 = require('../../../../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.cjs.js');
+
+const STATIC_FROM_RE = /from\s*['"]([^'"]+)['"]/g;
+const REQUIRE_LITERAL_RE = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+const IMPORT_LITERAL_RE = /import\s*\(\s*['"]([^'"]+)['"]/g;
+const collectInto = (source, re, specifiers) => {
+    for (const match of source.matchAll(re)) {
+        const spec = match[1];
+        if (spec.startsWith('.'))
+            specifiers.add(spec);
+    }
+};
+const collectChunkSpecifiers = (source) => {
+    const specifiers = index_cjs_js$9.createSet([]);
+    collectInto(source, STATIC_FROM_RE, specifiers);
+    collectInto(source, REQUIRE_LITERAL_RE, specifiers);
+    collectInto(source, IMPORT_LITERAL_RE, specifiers);
+    return index_cjs_js$2.from(specifiers);
+};
+const WHITESPACE_RE = /\s/;
+const isDynamicArg = (source, start) => {
+    const quote = source.charAt(start);
+    if (quote !== '"' && quote !== "'")
+        return true;
+    let i = start + 1;
+    while (i < source.length) {
+        const ch = source.charAt(i);
+        if (ch === '\\') {
+            i += 2;
+            continue;
+        }
+        if (ch === quote)
+            break;
+        i += 1;
+    }
+    if (i >= source.length)
+        return true;
+    let j = i + 1;
+    while (j < source.length && WHITESPACE_RE.test(source.charAt(j)))
+        j += 1;
+    return source.charAt(j) !== ')';
+};
+const hasDynamicSpecifier = (source) => {
+    const re = /\b(?:import|require)\s*\(\s*/g;
+    while (re.exec(source) !== null) {
+        if (isDynamicArg(source, re.lastIndex))
+            return true;
+    }
+    return false;
+};
+
+exports.STATIC_FROM_RE = STATIC_FROM_RE;
+exports.REQUIRE_LITERAL_RE = REQUIRE_LITERAL_RE;
+exports.IMPORT_LITERAL_RE = IMPORT_LITERAL_RE;
+exports.collectInto = collectInto;
+exports.collectChunkSpecifiers = collectChunkSpecifiers;
+exports.WHITESPACE_RE = WHITESPACE_RE;
+exports.isDynamicArg = isDynamicArg;
+exports.hasDynamicSpecifier = hasDynamicSpecifier;

package/_shared/bundle/dependencies/prune/specifiers/index.esm.js

@@ -0,0 +1,53 @@
+import { from } from '../../../../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.esm.js';
+import { createSet } from '../../../../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.esm.js';
+
+const STATIC_FROM_RE = /from\s*['"]([^'"]+)['"]/g;
+const REQUIRE_LITERAL_RE = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+const IMPORT_LITERAL_RE = /import\s*\(\s*['"]([^'"]+)['"]/g;
+const collectInto = (source, re, specifiers) => {
+    for (const match of source.matchAll(re)) {
+        const spec = match[1];
+        if (spec.startsWith('.'))
+            specifiers.add(spec);
+    }
+};
+const collectChunkSpecifiers = (source) => {
+    const specifiers = createSet([]);
+    collectInto(source, STATIC_FROM_RE, specifiers);
+    collectInto(source, REQUIRE_LITERAL_RE, specifiers);
+    collectInto(source, IMPORT_LITERAL_RE, specifiers);
+    return from(specifiers);
+};
+const WHITESPACE_RE = /\s/;
+const isDynamicArg = (source, start) => {
+    const quote = source.charAt(start);
+    if (quote !== '"' && quote !== "'")
+        return true;
+    let i = start + 1;
+    while (i < source.length) {
+        const ch = source.charAt(i);
+        if (ch === '\\') {
+            i += 2;
+            continue;
+        }
+        if (ch === quote)
+            break;
+        i += 1;
+    }
+    if (i >= source.length)
+        return true;
+    let j = i + 1;
+    while (j < source.length && WHITESPACE_RE.test(source.charAt(j)))
+        j += 1;
+    return source.charAt(j) !== ')';
+};
+const hasDynamicSpecifier = (source) => {
+    const re = /\b(?:import|require)\s*\(\s*/g;
+    while (re.exec(source) !== null) {
+        if (isDynamicArg(source, re.lastIndex))
+            return true;
+    }
+    return false;
+};
+
+export { STATIC_FROM_RE, REQUIRE_LITERAL_RE, IMPORT_LITERAL_RE, collectInto, collectChunkSpecifiers, WHITESPACE_RE, isDynamicArg, hasDynamicSpecifier };

package/_shared/bundle/entries/discover-entries/index.cjs.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const index_cjs_js$8 = require('../../../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.cjs.js');
+const index_cjs_js$4 = require('../../../../_dependencies/@hyperfrontend/project-scope/core/index.cjs.js');
+
+const PLATFORM_DIRS = index_cjs_js$8.freeze(['browser', 'node']);
+const isPlatformDir = (name) => PLATFORM_DIRS.includes(name);
+const hasIndexFile = (dirPath) => index_cjs_js$4.exists(index_cjs_js$4.join(dirPath, 'index.ts'));
+const getSubdirectories = (dirPath) => {
+    if (!index_cjs_js$4.exists(dirPath) || !index_cjs_js$4.isDirectory(dirPath))
+        return [];
+    return index_cjs_js$4.readDirectory(dirPath)
+        .filter((entry) => entry.isDirectory && !entry.name.startsWith('.'))
+        .map((entry) => entry.name);
+};
+const recurseEntries = (basePath, relativePath, maxDepth) => {
+    if (maxDepth <= 0)
+        return [];
+    const currentPath = relativePath ? index_cjs_js$4.join(basePath, relativePath) : basePath;
+    if (!index_cjs_js$4.exists(currentPath))
+        return [];
+    const entries = [];
+    for (const subdir of getSubdirectories(currentPath)) {
+        const subdirPath = index_cjs_js$4.join(currentPath, subdir);
+        const subdirRelative = relativePath ? `${relativePath}/${subdir}` : subdir;
+        if (hasIndexFile(subdirPath)) {
+            const firstSegment = subdirRelative.split('/')[0];
+            const platform = isPlatformDir(subdir) ? subdir : isPlatformDir(firstSegment) ? firstSegment : undefined;
+            entries.push({
+                exportPath: `./${subdirRelative}`,
+                srcPath: subdirRelative,
+                inputFile: index_cjs_js$4.join(subdirPath, 'index.ts'),
+                isRoot: false,
+                platform,
+            });
+        }
+        entries.push(...recurseEntries(basePath, subdirRelative, maxDepth - 1));
+    }
+    return entries;
+};
+const categorize = (hasRootEntry, platformEntries, featureEntries) => {
+    const hasPlatform = platformEntries.length > 0;
+    const hasFeature = featureEntries.length > 0;
+    const hasNestedPlatform = platformEntries.some((e) => e.srcPath.includes('/'));
+    if (hasRootEntry && !hasPlatform && !hasFeature)
+        return 'root';
+    if (!hasRootEntry && hasPlatform && !hasFeature && !hasNestedPlatform)
+        return 'platform';
+    if (!hasRootEntry && !hasPlatform && hasFeature)
+        return 'feature';
+    if (hasNestedPlatform)
+        return 'complex';
+    return 'hybrid';
+};
+const discoverEntries = (projectRoot) => {
+    const srcPath = index_cjs_js$4.join(projectRoot, 'src');
+    const entryPoints = [];
+    const rootIndexPath = index_cjs_js$4.join(srcPath, 'index.ts');
+    const hasRootEntry = index_cjs_js$4.exists(rootIndexPath);
+    if (hasRootEntry) {
+        entryPoints.push({
+            exportPath: '.',
+            srcPath: '',
+            inputFile: rootIndexPath,
+            isRoot: true,
+        });
+    }
+    entryPoints.push(...recurseEntries(srcPath, '', 3));
+    const firstSegmentOf = (entry) => entry.srcPath.split('/')[0];
+    const platformEntries = entryPoints.filter((e) => !e.isRoot && isPlatformDir(firstSegmentOf(e)));
+    const featureEntries = entryPoints.filter((e) => !e.isRoot && !isPlatformDir(firstSegmentOf(e)));
+    return {
+        category: categorize(hasRootEntry, platformEntries, featureEntries),
+        entryPoints,
+        hasRootEntry,
+        platformEntries,
+        featureEntries,
+    };
+};
+
+exports.PLATFORM_DIRS = PLATFORM_DIRS;
+exports.isPlatformDir = isPlatformDir;
+exports.hasIndexFile = hasIndexFile;
+exports.getSubdirectories = getSubdirectories;
+exports.recurseEntries = recurseEntries;
+exports.categorize = categorize;
+exports.discoverEntries = discoverEntries;

package/_shared/bundle/entries/discover-entries/index.esm.js

@@ -0,0 +1,80 @@
+import { join as join$1 } from '../../fs/posix-path/index.esm.js';
+import { freeze, entries } from '../../../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.esm.js';
+import { exists, isDirectory, readDirectory, relativePath } from '../../../../_dependencies/@hyperfrontend/project-scope/core/index.esm.js';
+
+const PLATFORM_DIRS = freeze(['browser', 'node']);
+const isPlatformDir = (name) => PLATFORM_DIRS.includes(name);
+const hasIndexFile = (dirPath) => exists(join$1(dirPath, 'index.ts'));
+const getSubdirectories = (dirPath) => {
+    if (!exists(dirPath) || !isDirectory(dirPath))
+        return [];
+    return readDirectory(dirPath)
+        .filter((entry) => entry.isDirectory && !entry.name.startsWith('.'))
+        .map((entry) => entry.name);
+};
+const recurseEntries = (basePath, relativePath, maxDepth) => {
+    if (maxDepth <= 0)
+        return [];
+    const currentPath = relativePath ? join$1(basePath, relativePath) : basePath;
+    if (!exists(currentPath))
+        return [];
+    const entries = [];
+    for (const subdir of getSubdirectories(currentPath)) {
+        const subdirPath = join$1(currentPath, subdir);
+        const subdirRelative = relativePath ? `${relativePath}/${subdir}` : subdir;
+        if (hasIndexFile(subdirPath)) {
+            const firstSegment = subdirRelative.split('/')[0];
+            const platform = isPlatformDir(subdir) ? subdir : isPlatformDir(firstSegment) ? firstSegment : undefined;
+            entries.push({
+                exportPath: `./${subdirRelative}`,
+                srcPath: subdirRelative,
+                inputFile: join$1(subdirPath, 'index.ts'),
+                isRoot: false,
+                platform,
+            });
+        }
+        entries.push(...recurseEntries(basePath, subdirRelative, maxDepth - 1));
+    }
+    return entries;
+};
+const categorize = (hasRootEntry, platformEntries, featureEntries) => {
+    const hasPlatform = platformEntries.length > 0;
+    const hasFeature = featureEntries.length > 0;
+    const hasNestedPlatform = platformEntries.some((e) => e.srcPath.includes('/'));
+    if (hasRootEntry && !hasPlatform && !hasFeature)
+        return 'root';
+    if (!hasRootEntry && hasPlatform && !hasFeature && !hasNestedPlatform)
+        return 'platform';
+    if (!hasRootEntry && !hasPlatform && hasFeature)
+        return 'feature';
+    if (hasNestedPlatform)
+        return 'complex';
+    return 'hybrid';
+};
+const discoverEntries = (projectRoot) => {
+    const srcPath = join$1(projectRoot, 'src');
+    const entryPoints = [];
+    const rootIndexPath = join$1(srcPath, 'index.ts');
+    const hasRootEntry = exists(rootIndexPath);
+    if (hasRootEntry) {
+        entryPoints.push({
+            exportPath: '.',
+            srcPath: '',
+            inputFile: rootIndexPath,
+            isRoot: true,
+        });
+    }
+    entryPoints.push(...recurseEntries(srcPath, '', 3));
+    const firstSegmentOf = (entry) => entry.srcPath.split('/')[0];
+    const platformEntries = entryPoints.filter((e) => !e.isRoot && isPlatformDir(firstSegmentOf(e)));
+    const featureEntries = entryPoints.filter((e) => !e.isRoot && !isPlatformDir(firstSegmentOf(e)));
+    return {
+        category: categorize(hasRootEntry, platformEntries, featureEntries),
+        entryPoints,
+        hasRootEntry,
+        platformEntries,
+        featureEntries,
+    };
+};
+
+export { PLATFORM_DIRS, isPlatformDir, hasIndexFile, getSubdirectories, recurseEntries, categorize, discoverEntries };

package/_shared/bundle/entries/resolve-entries/index.cjs.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const index_cjs_js$4 = require('../../../../_dependencies/@hyperfrontend/project-scope/core/index.cjs.js');
+const index_cjs_js$2 = require('../../../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.cjs.js');
+
+const normalizePattern = (pattern) => {
+    if (pattern === '.')
+        return pattern;
+    if (pattern.startsWith('./'))
+        return pattern;
+    return `./${pattern}`;
+};
+const matchesPattern = (entry, pattern) => {
+    const normalized = normalizePattern(pattern);
+    if (normalized === entry.exportPath)
+        return true;
+    if (normalized.includes('*'))
+        return index_cjs_js$4.matchGlobPattern(entry.exportPath, normalized);
+    return false;
+};
+const toPatternList = (patterns) => (index_cjs_js$2.isArray(patterns) ? patterns : [patterns]);
+const resolveEntries = (config, discoveredEntries) => {
+    let entries = discoveredEntries;
+    if (config.entry !== undefined) {
+        const patterns = toPatternList(config.entry);
+        entries = entries.filter((entry) => patterns.some((pattern) => matchesPattern(entry, pattern)));
+    }
+    if (config.exclude !== undefined) {
+        const patterns = toPatternList(config.exclude);
+        entries = entries.filter((entry) => !patterns.some((pattern) => matchesPattern(entry, pattern)));
+    }
+    return entries;
+};
+
+exports.normalizePattern = normalizePattern;
+exports.matchesPattern = matchesPattern;
+exports.toPatternList = toPatternList;
+exports.resolveEntries = resolveEntries;

package/_shared/bundle/entries/resolve-entries/index.esm.js

@@ -0,0 +1,34 @@
+import { isArray } from '../../../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.esm.js';
+import { entries } from '../../../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.esm.js';
+import { matchGlobPattern } from '../../../../_dependencies/@hyperfrontend/project-scope/core/index.esm.js';
+
+const normalizePattern = (pattern) => {
+    if (pattern === '.')
+        return pattern;
+    if (pattern.startsWith('./'))
+        return pattern;
+    return `./${pattern}`;
+};
+const matchesPattern = (entry, pattern) => {
+    const normalized = normalizePattern(pattern);
+    if (normalized === entry.exportPath)
+        return true;
+    if (normalized.includes('*'))
+        return matchGlobPattern(entry.exportPath, normalized);
+    return false;
+};
+const toPatternList = (patterns) => (isArray(patterns) ? patterns : [patterns]);
+const resolveEntries = (config, discoveredEntries) => {
+    let entries = discoveredEntries;
+    if (config.entry !== undefined) {
+        const patterns = toPatternList(config.entry);
+        entries = entries.filter((entry) => patterns.some((pattern) => matchesPattern(entry, pattern)));
+    }
+    if (config.exclude !== undefined) {
+        const patterns = toPatternList(config.exclude);
+        entries = entries.filter((entry) => !patterns.some((pattern) => matchesPattern(entry, pattern)));
+    }
+    return entries;
+};
+
+export { normalizePattern, matchesPattern, toPatternList, resolveEntries };

package/_shared/bundle/externals/validate-globals/index.cjs.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const index_cjs_js$6 = require('../../../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.cjs.js');
+
+const validateExternalsConfig = (external, globals) => {
+    if (!external || external.length === 0)
+        return;
+    const missing = external.filter((dep) => !globals?.[dep]);
+    if (missing.length === 0)
+        return;
+    throw index_cjs_js$6.createError(`Missing globals mapping for external dependencies:\n${missing.map((d) => `  - ${d}`).join('\n')}\nAdd a globals entry or remove the package from the external list to inline it.`);
+};
+
+exports.validateExternalsConfig = validateExternalsConfig;

package/_shared/bundle/externals/validate-globals/index.esm.js

@@ -0,0 +1,12 @@
+import { createError } from '../../../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.esm.js';
+
+const validateExternalsConfig = (external, globals) => {
+    if (!external || external.length === 0)
+        return;
+    const missing = external.filter((dep) => !globals?.[dep]);
+    if (missing.length === 0)
+        return;
+    throw createError(`Missing globals mapping for external dependencies:\n${missing.map((d) => `  - ${d}`).join('\n')}\nAdd a globals entry or remove the package from the external list to inline it.`);
+};
+
+export { validateExternalsConfig };

package/_shared/bundle/fs/deps-root/index.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const index_cjs_js$4 = require('../../../../_dependencies/@hyperfrontend/project-scope/core/index.cjs.js');
+
+const depsRootOf = (context) => index_cjs_js$4.join(context.outputPath, '_dependencies');
+
+exports.depsRootOf = depsRootOf;

package/_shared/bundle/fs/deps-root/index.esm.js

@@ -0,0 +1,5 @@
+import { join as join$1 } from '../posix-path/index.esm.js';
+
+const depsRootOf = (context) => join$1(context.outputPath, '_dependencies');
+
+export { depsRootOf };

package/_shared/bundle/fs/empty-dirs/index.cjs.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const index_cjs_js$4 = require('../../../../_dependencies/@hyperfrontend/project-scope/core/index.cjs.js');
+const node_fs = require('node:fs');
+
+const removeEmptyDirs = (root) => {
+    let removed = 0;
+    const visit = (dir) => {
+        for (const entry of index_cjs_js$4.readDirectory(dir))
+            if (entry.isDirectory)
+                visit(entry.path);
+        if (index_cjs_js$4.readDirectory(dir).length === 0) {
+            node_fs.rmdirSync(dir);
+            removed += 1;
+        }
+    };
+    for (const entry of index_cjs_js$4.readDirectory(root))
+        if (entry.isDirectory)
+            visit(entry.path);
+    return removed;
+};
+
+exports.removeEmptyDirs = removeEmptyDirs;

package/_shared/bundle/fs/empty-dirs/index.esm.js

@@ -0,0 +1,21 @@
+import { readDirectory } from '../../../../_dependencies/@hyperfrontend/project-scope/core/index.esm.js';
+import { rmdirSync } from 'node:fs';
+
+const removeEmptyDirs = (root) => {
+    let removed = 0;
+    const visit = (dir) => {
+        for (const entry of readDirectory(dir))
+            if (entry.isDirectory)
+                visit(entry.path);
+        if (readDirectory(dir).length === 0) {
+            rmdirSync(dir);
+            removed += 1;
+        }
+    };
+    for (const entry of readDirectory(root))
+        if (entry.isDirectory)
+            visit(entry.path);
+    return removed;
+};
+
+export { removeEmptyDirs };

package/_shared/bundle/fs/entry-dir/index.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const index_cjs_js$4 = require('../../../../_dependencies/@hyperfrontend/project-scope/core/index.cjs.js');
+
+const entryDirOf = (entry, context) => entry.isRoot ? context.outputPath : index_cjs_js$4.join(context.outputPath, entry.srcPath);
+
+exports.entryDirOf = entryDirOf;