@mintlify/package-builder 0.0.0-stage → 0.0.3

package/dist/bundle.js

@@ -0,0 +1,681 @@
+import * as esbuild from 'esbuild';
+import { existsSync, realpathSync, statSync } from 'node:fs';
+import { mkdir, mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { fileURLToPath } from 'node:url';
+import { isSkipped, NAMESPACED, packageOfPath, singleReactPlugin, skipData, } from './react.js';
+export const ISLAND_ID = /^[A-Za-z0-9_-]{1,64}$/;
+export const ISLANDS_HOOKS_SPECIFIER = '@mintlify/islands';
+const RUNTIME_SPECIFIER = /^mint-island-runtime\/(client|server|theme)$/;
+export const URL_LIKE = /^(?:[a-zA-Z][a-zA-Z0-9+.-]+:|\/\/|#)/;
+const ASSET_LOADERS = {
+    ...Object.fromEntries(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.avif', '.woff', '.woff2', '.ttf', '.otf'].map((ext) => [ext, 'file'])),
+    '.svg': 'dataurl',
+    '.eot': 'empty',
+};
+const OUTSIDE = 'outside the docs folder and node_modules';
+const CSS_STUB = 'mint-css-stub';
+const CSS_SPECIFIER = /\.css(?:[?#].*)?$/;
+const CSS_MODULE = /\.module\.css$/;
+const CSS_DUPLICATE = 'mint-css-duplicate';
+const SERVER_BANNER = "import { createRequire as __mintCreateRequire } from 'node:module';\nconst require = __mintCreateRequire(import.meta.url);";
+function runtimeFile(name) {
+    const here = dirname(fileURLToPath(import.meta.url));
+    for (const ext of ['.js', '.tsx', '.ts']) {
+        const candidate = join(here, 'runtime', `${name}${ext}`);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    throw new Error(`Island runtime file ${name} not found next to ${here}`);
+}
+const NATIVE_PATH = { relative, isAbsolute, resolve };
+export function inside(parent, child, ops = NATIVE_PATH) {
+    const rel = ops.relative(parent, child);
+    return rel === '' || (!rel.startsWith('..') && !ops.isAbsolute(rel));
+}
+export function canonical(path) {
+    try {
+        return realpathSync.native(path);
+    }
+    catch {
+        try {
+            return realpathSync(path);
+        }
+        catch {
+            return resolve(path);
+        }
+    }
+}
+export function within(roots, real = canonical, ops = NATIVE_PATH) {
+    const realRoots = roots.map(real);
+    return (path) => {
+        const target = real(path);
+        return realRoots.some((root) => inside(root, target, ops));
+    };
+}
+function nodeModulesRoots(installRoot, hoisted) {
+    const roots = [];
+    for (let dir = installRoot;; dir = dirname(dir)) {
+        const nodeModules = join(dir, 'node_modules');
+        if (existsSync(nodeModules))
+            roots.push(nodeModules);
+        if (!hoisted || dirname(dir) === dir)
+            return roots;
+    }
+}
+function hardLinked(path) {
+    try {
+        return statSync(path).nlink > 1;
+    }
+    catch {
+        return false;
+    }
+}
+function climbsOut(specifier) {
+    return specifier.split(/[\\/]/).includes('..');
+}
+function globLeaves(root, dir, pattern) {
+    const segments = pattern.split(/[\\/]/);
+    const wild = segments.findIndex((s) => s.includes('*'));
+    if (wild === -1)
+        return false;
+    return (!inside(root, resolve(dir, segments.slice(0, wild).join('/'))) ||
+        segments.slice(wild).includes('..'));
+}
+function isPackageSpecifier(specifier) {
+    return (specifier.length > 0 &&
+        !/^[./\\]/.test(specifier) &&
+        !/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(specifier) &&
+        !climbsOut(specifier));
+}
+function badSegment(seg) {
+    return seg === '' || seg === '..' || /[:\0]/.test(seg) || (seg !== '.' && /[. ]$/.test(seg));
+}
+export function docsPathToRelative(path) {
+    const rel = path.replace(/\\/g, '/').replace(/^\/+/, '');
+    if (!rel || rel.split('/').some(badSegment))
+        return undefined;
+    return rel;
+}
+export function docsTarget(docsDir, path, ops = NATIVE_PATH) {
+    const rel = docsPathToRelative(path);
+    if (rel === undefined)
+        return undefined;
+    const target = ops.resolve(docsDir, rel);
+    return ops.relative(docsDir, target) !== '' && inside(docsDir, target, ops) ? target : undefined;
+}
+function packagePath(path) {
+    const normalized = path.replace(/\\/g, '/');
+    const pkg = packageOfPath(normalized);
+    return pkg && `${pkg.name}${normalized.slice(pkg.dir.length)}`;
+}
+export function shownPath(path, docsDir, ops = NATIVE_PATH) {
+    if (inside(docsDir, path, ops))
+        return `/${ops.relative(docsDir, path).replace(/\\/g, '/')}`;
+    return packagePath(path) ?? path.replace(/\\/g, '/');
+}
+function entryFile(id, side) {
+    return `entries/${id}.${side}.jsx`;
+}
+function wildcard(pattern, name) {
+    let p = 0;
+    let star = -1;
+    let mark = 0;
+    for (let n = 0; n < name.length;) {
+        if (pattern[p] === '*') {
+            star = p++;
+            mark = n;
+        }
+        else if (pattern[p] === name[n]) {
+            p++;
+            n++;
+        }
+        else if (star >= 0) {
+            p = star + 1;
+            n = ++mark;
+        }
+        else
+            return false;
+    }
+    while (pattern[p] === '*')
+        p++;
+    return p === pattern.length;
+}
+function globTest(pattern, path) {
+    const segments = path.split('/');
+    let next = segments.map(() => false).concat(true);
+    for (const part of pattern.split('/').reverse()) {
+        const row = next.map(() => false);
+        for (let s = segments.length; s >= 0; s--) {
+            row[s] =
+                part === '**'
+                    ? next[s] === true || row[s + 1] === true
+                    : next[s + 1] === true && wildcard(part, segments[s]);
+        }
+        next = row;
+    }
+    return next[0] === true;
+}
+function globMatches(metafile, srcDir, importer, pattern) {
+    const cut = pattern.lastIndexOf('/', pattern.indexOf('*')) + 1;
+    const base = canonical(resolve(srcDir, dirname(importer), pattern.slice(0, cut)));
+    return Object.keys(metafile.inputs)
+        .filter((key) => !NAMESPACED.test(key))
+        .flatMap((key) => {
+        const path = resolve(srcDir, key);
+        const rel = relative(base, path).split(sep).join('/');
+        return inside(base, path) && globTest(pattern.slice(cut), rel) ? [{ key, rel }] : [];
+    })
+        .sort((a, b) => (a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0))
+        .map((m) => m.key);
+}
+function importedCss(metafile, entries, srcDir, loaded) {
+    const prefix = `${CSS_STUB}:`;
+    const cssOf = (input) => {
+        if (input.startsWith(prefix))
+            return input.slice(prefix.length);
+        const path = resolve(srcDir, input);
+        return !NAMESPACED.test(input) && loaded.has(path) ? path : undefined;
+    };
+    const seen = new Set();
+    const order = new Set();
+    const stack = [...entries].reverse();
+    for (let input = stack.pop(); input !== undefined; input = stack.pop()) {
+        if (seen.has(input))
+            continue;
+        seen.add(input);
+        const css = cssOf(input);
+        if (css !== undefined)
+            order.add(css);
+        const next = (metafile.inputs[input]?.imports ?? []).flatMap((i) => !i.external
+            ? [i.path]
+            : i.path.includes('*')
+                ? globMatches(metafile, srcDir, input, i.path)
+                : []);
+        for (const path of next.reverse())
+            stack.push(path);
+    }
+    const stubs = Object.keys(metafile.inputs).filter((input) => input.startsWith(prefix));
+    const all = new Set([...stubs.map((input) => input.slice(prefix.length)), ...loaded]);
+    return { order: [...order], missed: [...all].filter((path) => !order.has(path)).sort() };
+}
+function entrySource(island, side, provider) {
+    const lines = provider ? [`import * as ProviderModule from ${JSON.stringify(provider)};`] : [];
+    lines.push(`import Island from ${JSON.stringify(`../islands/${island.id}.jsx`)};`);
+    if (side === 'client') {
+        lines.push(`import { createHydrate } from 'mint-island-runtime/client';`);
+        lines.push(`export const hydrate = createHydrate(Island${provider ? ', ProviderModule' : ''});`);
+    }
+    else {
+        lines.push(`import { createRender } from 'mint-island-runtime/server';`);
+        lines.push(`export const render = createRender(Island${provider ? ', ProviderModule' : ''});`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function formatMessages(messages, srcDir, islands, ops = NATIVE_PATH) {
+    const byFile = new Map(islands.map((i) => [`islands/${i.id}.jsx`, i]));
+    return messages.map((m) => {
+        if (!m.location)
+            return m.text;
+        const file = m.location.file.replace(/\\/g, '/');
+        const rel = ops.relative(srcDir, ops.resolve(srcDir, file)).replace(/\\/g, '/');
+        const island = byFile.get(rel);
+        const where = island
+            ? `island ${island.id} (${island.pagePath})`
+            : rel.startsWith('docs/')
+                ? `/${rel.slice('docs/'.length)}`
+                : (packagePath(file) ?? file);
+        return `${where}${m.location.line ? `:${m.location.line}` : ''}: ${m.text}`;
+    });
+}
+function packageFromMessage(message) {
+    const detail = message?.detail?.pkg;
+    if (typeof detail === 'string')
+        return detail;
+    const text = message?.text ?? '';
+    const m = /node_modules\/((?:@[^/]+\/)?[^/"]+)/.exec(text) ??
+        /Could not resolve "((?:@[^/]+\/)?[^/"]+)/.exec(text);
+    return m?.[1] ?? packageOfPath(message?.location?.file ?? '')?.name;
+}
+function packageName(specifier) {
+    return specifier
+        .split('/')
+        .slice(0, specifier.startsWith('@') ? 2 : 1)
+        .join('/');
+}
+export async function bundle(opts) {
+    const start = performance.now();
+    const diagnostics = [];
+    const replacedReact = [];
+    const srcDir = canonical(await mkdtemp(join(opts.workParent ?? tmpdir(), '.mint-pkg-src-')));
+    const srcDocs = join(srcDir, 'docs');
+    const srcIslands = join(srcDir, 'islands');
+    const installRoot = canonical(opts.installRoot);
+    const runtimeDir = dirname(runtimeFile('client'));
+    const allowed = within([
+        srcDir,
+        runtimeDir,
+        ...nodeModulesRoots(installRoot, opts.hoistedNodeModules === true),
+    ]);
+    const loadedCss = new Set();
+    const outsideText = (from) => `${from === undefined ? 'An import' : `The import of "${from}"`} reads a file ${OUTSIDE}`;
+    const outside = (pkg, from) => ({
+        errors: [{ text: outsideText(from), ...(pkg ? { detail: { pkg } } : {}) }],
+    });
+    const cssModule = (path) => {
+        const pkg = packageOfPath(path)?.name;
+        return {
+            text: `${shownPath(path, srcDocs)} is a CSS module. styles.css loads every stylesheet globally, so its class names would not match; import a plain .css file.`,
+            ...(pkg ? { detail: { pkg } } : {}),
+        };
+    };
+    const done = (extra = {}) => ({
+        ok: !diagnostics.some((d) => d.level === 'error'),
+        diagnostics,
+        durationMs: performance.now() - start,
+        srcDir,
+        replacedReact,
+        ...extra,
+    });
+    for (const [path, source] of Object.entries(opts.snippetFiles)) {
+        const target = docsTarget(srcDocs, path);
+        if (!target) {
+            diagnostics.push({
+                level: 'error',
+                code: 'snippet-invalid-path',
+                message: `Snippet path ${path} is not a file path inside the docs folder.`,
+            });
+            continue;
+        }
+        await mkdir(dirname(target), { recursive: true });
+        await writeFile(target, source);
+    }
+    for (const specifier of opts.packages.css ?? []) {
+        if (!isPackageSpecifier(specifier)) {
+            diagnostics.push({
+                level: 'error',
+                code: 'css-invalid-specifier',
+                message: `packages.css entry ${specifier} must be a package path such as @acme/ui/dist/styles.css.`,
+            });
+        }
+    }
+    const provider = opts.packages.provider;
+    if (provider !== undefined && (!provider.startsWith('/') || !docsPathToRelative(provider))) {
+        diagnostics.push({
+            level: 'error',
+            code: 'provider-invalid-path',
+            message: `packages.provider ${provider} must be a path such as /snippets/provider.jsx.`,
+        });
+    }
+    await mkdir(srcIslands, { recursive: true });
+    await mkdir(join(srcDir, 'entries'), { recursive: true });
+    const clientEntries = {};
+    const serverEntries = {};
+    for (const island of opts.islands) {
+        if (!ISLAND_ID.test(island.id)) {
+            diagnostics.push({
+                level: 'error',
+                code: 'island-invalid-id',
+                message: `Island id ${island.id} is not valid.`,
+            });
+            continue;
+        }
+        await writeFile(join(srcIslands, `${island.id}.jsx`), island.module);
+        for (const side of ['client', 'server']) {
+            const file = join(srcDir, entryFile(island.id, side));
+            await writeFile(file, entrySource(island, side, provider));
+            (side === 'client' ? clientEntries : serverEntries)[`islands/${island.id}`] = file;
+        }
+    }
+    if (diagnostics.some((d) => d.level === 'error'))
+        return done();
+    const sandboxPlugin = {
+        name: 'mint-sandbox',
+        setup(build) {
+            build.onLoad({ filter: /.*/, namespace: 'file' }, (args) => {
+                if (!allowed(args.path))
+                    return outside();
+                if (opts.rejectHardLinks && hardLinked(args.path)) {
+                    const pkg = packageOfPath(args.path)?.name;
+                    return {
+                        errors: [
+                            {
+                                text: `${pkg ?? 'A docs file'} contains a hard-linked file, which could point outside the package`,
+                                ...(pkg ? { detail: { pkg } } : {}),
+                            },
+                        ],
+                    };
+                }
+                return undefined;
+            });
+        },
+    };
+    const cssModulePlugin = {
+        name: 'mint-css-modules',
+        setup(build) {
+            build.onLoad({ filter: CSS_MODULE, namespace: 'file' }, (args) => ({
+                errors: [cssModule(args.path)],
+            }));
+        },
+    };
+    const ours = (importer) => inside(srcDir, importer) || inside(runtimeDir, importer);
+    const resolveInDocs = async (build, args) => {
+        const absolute = args.path.startsWith('/');
+        const rel = absolute ? docsPathToRelative(args.path) : args.path;
+        const resolveDir = absolute ? srcDocs : args.resolveDir;
+        if (rel === undefined || !inside(srcDocs, resolve(resolveDir, rel))) {
+            return { errors: [{ text: `${args.path} is outside the docs folder` }] };
+        }
+        const r = await build.resolve(absolute ? `./${rel}` : rel, {
+            kind: args.kind,
+            resolveDir,
+            pluginData: skipData,
+        });
+        return r.errors.length === 0 && inside(srcDocs, r.path)
+            ? { path: r.path, suffix: r.suffix, sideEffects: r.sideEffects }
+            : { errors: [{ text: `Could not find ${args.path} in the docs folder` }] };
+    };
+    const sourcePlugin = {
+        name: 'mint-sources',
+        setup(build) {
+            build.onResolve({ filter: RUNTIME_SPECIFIER }, (args) => ({
+                path: runtimeFile(RUNTIME_SPECIFIER.exec(args.path)[1]),
+            }));
+            build.onResolve({ filter: /^@mintlify\/islands$/ }, () => ({ path: runtimeFile('theme') }));
+            build.onResolve({ filter: /^\// }, async (args) => {
+                if (isSkipped(args.pluginData) || !args.importer || !ours(args.importer))
+                    return undefined;
+                return resolveInDocs(build, args);
+            });
+            build.onResolve({ filter: /^\.\.?(\/|$)/ }, async (args) => {
+                if (isSkipped(args.pluginData))
+                    return undefined;
+                if (!inside(srcDocs, args.importer) && !inside(srcIslands, args.importer))
+                    return undefined;
+                return resolveInDocs(build, args);
+            });
+            build.onResolve({ filter: /^[^./]/ }, async (args) => {
+                if (isSkipped(args.pluginData) || !args.importer || !ours(args.importer))
+                    return undefined;
+                if (climbsOut(args.path)) {
+                    return { errors: [{ text: `"${args.path}" must not contain ".." segments` }] };
+                }
+                const r = await build.resolve(args.path, {
+                    kind: args.kind,
+                    resolveDir: installRoot,
+                    pluginData: skipData,
+                });
+                if (r.errors.length > 0) {
+                    return {
+                        errors: [
+                            {
+                                text: `Could not resolve "${args.path}". Is it listed in package.json dependencies?`,
+                            },
+                        ],
+                    };
+                }
+                if (!r.external && !allowed(r.path)) {
+                    return outside(packageName(args.path), args.path);
+                }
+                return { path: r.path, sideEffects: r.sideEffects, external: r.external };
+            });
+            build.onLoad({ filter: /\.(js|mjs)$/ }, async (args) => inside(srcDocs, args.path)
+                ? { loader: 'jsx', contents: await readFile(args.path, 'utf8') }
+                : undefined);
+        },
+    };
+    const cssCollector = {
+        name: 'mint-css-collector',
+        setup(build) {
+            const stub = (path) => CSS_MODULE.test(path) ? { errors: [cssModule(path)] } : { path, namespace: CSS_STUB };
+            build.onResolve({ filter: CSS_SPECIFIER }, async (args) => {
+                if (isSkipped(args.pluginData))
+                    return undefined;
+                const bare = !args.path.startsWith('.') && !args.path.startsWith('/');
+                const mine = ours(args.importer);
+                if (mine && !bare) {
+                    const local = await resolveInDocs(build, args);
+                    return local.path?.endsWith('.css') ? stub(local.path) : local;
+                }
+                if (bare && mine && climbsOut(args.path)) {
+                    return { errors: [{ text: `"${args.path}" must not contain ".." segments` }] };
+                }
+                const resolveDir = bare && mine ? installRoot : args.resolveDir;
+                const r = await build.resolve(args.path, {
+                    kind: args.kind,
+                    resolveDir,
+                    pluginData: skipData,
+                });
+                if (r.errors.length > 0)
+                    return { errors: r.errors };
+                if (!allowed(r.path))
+                    return outside(undefined, args.path);
+                return r.path.endsWith('.css')
+                    ? stub(r.path)
+                    : { path: r.path, sideEffects: r.sideEffects };
+            });
+            build.onLoad({ filter: /.*/, namespace: CSS_STUB }, () => ({
+                contents: '',
+                loader: 'js',
+            }));
+            build.onLoad({ filter: /\.css$/, namespace: 'file' }, (args) => {
+                loadedCss.add(args.path);
+                return { contents: '', loader: 'js' };
+            });
+        },
+    };
+    const common = {
+        absWorkingDir: srcDir,
+        bundle: true,
+        splitting: true,
+        format: 'esm',
+        metafile: true,
+        jsx: 'automatic',
+        logLevel: 'silent',
+        assetNames: 'assets/[name]-[hash]',
+        chunkNames: '[name]-[hash]',
+        loader: ASSET_LOADERS,
+    };
+    const reactPlugin = singleReactPlugin({ installRoot, onReplaced: (r) => replacedReact.push(r) });
+    const escapes = (metafile) => Object.keys(metafile.inputs)
+        .filter((input) => !NAMESPACED.test(input))
+        .map((input) => resolve(srcDir, input))
+        .filter((path) => !allowed(path))
+        .map(() => ({ text: outsideText() }));
+    const docsGlobs = (metafile) => Object.entries(metafile.inputs).flatMap(([input, { imports }]) => {
+        const importer = resolve(srcDir, input);
+        if (!inside(srcDocs, importer) && !inside(srcIslands, importer))
+            return [];
+        return imports
+            .filter((i) => i.path.includes('*'))
+            .map((i) => ({
+            text: globLeaves(srcDocs, dirname(importer), i.path)
+                ? `${i.path} is outside the docs folder`
+                : `the import of ${i.path} builds its path at runtime; import each file statically`,
+            location: { file: input },
+        }));
+    });
+    const run = async (label, options) => {
+        let errors;
+        try {
+            const result = await esbuild.build({ ...options, write: false, metafile: true });
+            errors = [...docsGlobs(result.metafile), ...escapes(result.metafile)];
+            if (errors.length === 0) {
+                for (const file of result.outputFiles) {
+                    await mkdir(dirname(file.path), { recursive: true });
+                    await writeFile(file.path, file.contents);
+                }
+                return result.metafile;
+            }
+        }
+        catch (err) {
+            errors = err.errors ?? [
+                { text: String(err) },
+            ];
+        }
+        const messages = formatMessages(errors, srcDir, opts.islands);
+        for (const [i, message] of messages.slice(0, 20).entries()) {
+            diagnostics.push({
+                level: 'error',
+                code: 'bundle-error',
+                message: `${label} build: ${message}`,
+                ...withPkg(packageFromMessage(errors[i])),
+            });
+        }
+        return undefined;
+    };
+    const hasEntries = Object.keys(clientEntries).length > 0;
+    const client = hasEntries
+        ? await run('client', {
+            ...common,
+            entryPoints: clientEntries,
+            outdir: join(opts.outDir, 'client'),
+            platform: 'browser',
+            target: ['es2020'],
+            minify: true,
+            define: {
+                'process.env.NODE_ENV': '"production"',
+                'process.env': '{}',
+                global: 'globalThis',
+            },
+            plugins: [sandboxPlugin, reactPlugin, cssModulePlugin, cssCollector, sourcePlugin],
+        })
+        : undefined;
+    const server = client
+        ? await run('server', {
+            ...common,
+            entryPoints: serverEntries,
+            outdir: join(opts.outDir, 'server'),
+            platform: 'node',
+            target: ['node18'],
+            minifyWhitespace: true,
+            minifySyntax: true,
+            outExtension: { '.js': '.mjs' },
+            banner: { js: SERVER_BANNER },
+            define: { 'process.env.NODE_ENV': '"production"' },
+            loader: { ...ASSET_LOADERS, '.css': 'empty' },
+            plugins: [
+                sandboxPlugin,
+                singleReactPlugin({ installRoot, onReplaced: () => { } }),
+                cssModulePlugin,
+                sourcePlugin,
+            ],
+        })
+        : undefined;
+    let css;
+    const cssSpecifiers = [...new Set(opts.packages.css ?? [])];
+    const collected = client
+        ? importedCss(client, opts.islands
+            .map((i) => i.id)
+            .sort()
+            .map((id) => entryFile(id, 'client')), srcDir, loadedCss)
+        : { order: [], missed: [] };
+    for (const path of collected.missed.slice(0, 20)) {
+        diagnostics.push({
+            level: 'error',
+            code: 'css-not-collected',
+            message: `${shownPath(path, srcDocs)} is loaded from JS in a way the builder cannot trace to an island, so styles.css would leave it out. Import it with a static path from a snippet or island.`,
+            ...withPkg(packageOfPath(path)?.name),
+        });
+    }
+    const jsCss = collected.order;
+    const jsOk = !hasEntries || (client !== undefined && server !== undefined);
+    if (jsOk && (cssSpecifiers.length > 0 || jsCss.length > 0)) {
+        const packageCss = new Map();
+        const packageFiles = new Set();
+        const cssOptions = (imports, record) => ({
+            absWorkingDir: srcDir,
+            stdin: {
+                contents: imports.map((p) => `@import ${JSON.stringify(p)};`).join('\n'),
+                loader: 'css',
+                resolveDir: srcDir,
+                sourcefile: 'styles.css',
+            },
+            bundle: true,
+            minify: true,
+            metafile: true,
+            logLevel: 'silent',
+            outfile: join(opts.outDir, 'client', 'styles.css'),
+            assetNames: 'assets/[name]-[hash]',
+            loader: ASSET_LOADERS,
+            plugins: [
+                sandboxPlugin,
+                cssModulePlugin,
+                {
+                    name: 'mint-css-entries',
+                    setup(build) {
+                        build.onStart(async () => {
+                            for (const specifier of cssSpecifiers) {
+                                packageCss.set(specifier, await build.resolve(specifier, {
+                                    kind: 'import-rule',
+                                    resolveDir: installRoot,
+                                    pluginData: skipData,
+                                }));
+                            }
+                        });
+                        if (record) {
+                            build.onLoad({ filter: /.*/, namespace: 'file' }, (args) => {
+                                packageFiles.add(args.path);
+                                return undefined;
+                            });
+                        }
+                        const firstAt = (path) => cssSpecifiers.findIndex((s) => packageCss.get(s)?.path === path);
+                        build.onLoad({ filter: /.*/, namespace: CSS_DUPLICATE }, () => ({
+                            contents: '',
+                            loader: 'css',
+                        }));
+                        build.onResolve({ filter: /.*/ }, async (args) => {
+                            if (isSkipped(args.pluginData))
+                                return undefined;
+                            if (inside(srcDocs, args.importer)) {
+                                if (URL_LIKE.test(args.path))
+                                    return undefined;
+                                const local = await resolveInDocs(build, args);
+                                if (!local.errors || !isPackageSpecifier(args.path))
+                                    return local;
+                                const pkg = await build.resolve(args.path, {
+                                    kind: args.kind,
+                                    resolveDir: installRoot,
+                                    pluginData: skipData,
+                                });
+                                if (pkg.errors.length > 0)
+                                    return local;
+                                return allowed(pkg.path) ? { path: pkg.path } : outside(undefined, args.path);
+                            }
+                            if (relative(join(srcDir, 'styles.css'), args.importer) !== '')
+                                return undefined;
+                            const duplicate = { path: args.path, namespace: CSS_DUPLICATE };
+                            if (isAbsolute(args.path))
+                                return packageFiles.has(args.path) ? duplicate : undefined;
+                            const r = packageCss.get(args.path);
+                            if (!r || r.errors.length > 0) {
+                                return {
+                                    errors: [
+                                        { text: `packages.css entry "${args.path}" was not found in node_modules` },
+                                    ],
+                                };
+                            }
+                            if (firstAt(r.path) < cssSpecifiers.indexOf(args.path))
+                                return duplicate;
+                            return allowed(r.path)
+                                ? { path: r.path }
+                                : outside(packageName(args.path), args.path);
+                        });
+                    },
+                },
+            ],
+        });
+        if (cssSpecifiers.length > 0 && jsCss.length > 0) {
+            await esbuild
+                .build({ ...cssOptions(cssSpecifiers, true), write: false })
+                .catch(() => undefined);
+        }
+        css = await run('css', cssOptions([...cssSpecifiers, ...jsCss], false));
+    }
+    return done({ client, server, css });
+}
+function withPkg(pkg) {
+    return pkg ? { pkg } : {};
+}

package/dist/cli.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import type { BuildResult } from './types.js';
+type Args = {
+    command?: string;
+    input?: string;
+    out?: string;
+    installer?: string;
+    json: boolean;
+};
+export declare function parseArgs(argv: string[]): Args;
+export declare function formatResult(result: BuildResult): string;
+export declare function main(argv: string[]): Promise<number>;
+export {};