@texuli/tools 0.0.0-stage → 0.1.0-next.0

package/dist/a2ui/to-a2ui.js

@@ -0,0 +1,119 @@
+import { COMPONENT_ID, copyProps, isPlainRecord } from "./props.js";
+import { validateA2uiMessages } from "./schema.js";
+import { A2UI_ROOT_ID, A2UI_ROOTS_COMPONENT, A2UI_VERSION, } from "./types.js";
+/**
+ * Convert a catalog tree (one node or a list of roots) into A2UI v0.9
+ * messages: an optional `createSurface`, then one `updateComponents` whose
+ * flat component list references children by id.
+ *
+ * Ids are deterministic: the root is `root` and the rest are `n1`, `n2`… in
+ * the order they are visited. Zero or several roots are wrapped in a
+ * `texuli-roots` component. Props must be literal JSON; reserved names
+ * (`id`, `component`, `children`, `child`), prototype keys, bindings and
+ * function calls fail the conversion. The output is checked against
+ * {@link A2UI_MESSAGE_SCHEMA} before it is returned.
+ */
+export function catalogTreeToA2ui(tree, options) {
+    const maxComponents = options.maxComponents ?? 1000;
+    const maxDepth = options.maxDepth ?? 64;
+    const diagnostics = [];
+    const components = [];
+    let next = 0;
+    let stopped = false;
+    const visit = (value, path, depth, id) => {
+        if (stopped)
+            return;
+        if (depth > maxDepth) {
+            diagnostics.push({ code: 'limit', path, message: `Nesting deeper than ${maxDepth}.` });
+            return;
+        }
+        if (components.length >= maxComponents) {
+            diagnostics.push({ code: 'limit', path, message: `More than ${maxComponents} components.` });
+            stopped = true;
+            return;
+        }
+        if (!isPlainRecord(value) || typeof value.id !== 'string' || !COMPONENT_ID.test(value.id)) {
+            diagnostics.push({
+                code: 'invalid-node',
+                path,
+                message: 'A catalog node is a plain object with a kebab-case "id".',
+            });
+            return;
+        }
+        if (value.id === A2UI_ROOTS_COMPONENT) {
+            diagnostics.push({
+                code: 'invalid-node',
+                path: `${path}.id`,
+                message: `"${A2UI_ROOTS_COMPONENT}" is the adapter's own wrapper, not a catalog id.`,
+            });
+            return;
+        }
+        if (value.props !== undefined && !isPlainRecord(value.props)) {
+            diagnostics.push({
+                code: 'invalid-node',
+                path: `${path}.props`,
+                message: '"props" must be an object.',
+            });
+            return;
+        }
+        if (value.children !== undefined && !Array.isArray(value.children)) {
+            diagnostics.push({
+                code: 'invalid-node',
+                path: `${path}.children`,
+                message: '"children" must be an array.',
+            });
+            return;
+        }
+        const props = copyProps(value.props ?? {}, [], `${path}.props`, 'reserved-prop', diagnostics);
+        const component = { id, component: value.id, ...props };
+        components.push(component);
+        if (Array.isArray(value.children)) {
+            const ids = [];
+            value.children.forEach((child, i) => {
+                if (stopped)
+                    return;
+                next += 1;
+                const childId = `n${next}`;
+                ids.push(childId);
+                visit(child, `${path}.children[${i}]`, depth + 1, childId);
+            });
+            component.children = ids;
+        }
+    };
+    if (Array.isArray(tree)) {
+        if (tree.length === 1)
+            visit(tree[0], '$[0]', 1, A2UI_ROOT_ID);
+        else if (tree.length >= maxComponents) {
+            diagnostics.push({
+                code: 'limit',
+                path: '$',
+                message: `More than ${maxComponents} components.`,
+            });
+        }
+        else {
+            const ids = tree.map(() => `n${++next}`);
+            components.push({ id: A2UI_ROOT_ID, component: A2UI_ROOTS_COMPONENT, children: ids });
+            tree.forEach((node, i) => {
+                visit(node, `$[${i}]`, 2, ids[i]);
+            });
+        }
+    }
+    else {
+        visit(tree, '$', 1, A2UI_ROOT_ID);
+    }
+    if (diagnostics.length > 0)
+        return { ok: false, diagnostics };
+    const messages = [];
+    if (options.createSurface !== false) {
+        messages.push({
+            version: A2UI_VERSION,
+            createSurface: { surfaceId: options.surfaceId, catalogId: options.catalogId },
+        });
+    }
+    messages.push({
+        version: A2UI_VERSION,
+        updateComponents: { surfaceId: options.surfaceId, components },
+    });
+    const invalid = validateA2uiMessages(messages);
+    return invalid.length > 0 ? { ok: false, diagnostics: invalid } : { ok: true, messages };
+}

package/dist/a2ui/types.d.ts

@@ -0,0 +1,71 @@
+/** The A2UI protocol version this adapter reads and writes. */
+export declare const A2UI_VERSION = "v0.9";
+/** The component id A2UI requires as the root of a surface's tree. */
+export declare const A2UI_ROOT_ID = "root";
+/**
+ * Component a payload uses as its root when the catalog tree has zero or
+ * several top-level nodes. `a2uiToCatalogTree` unwraps it.
+ */
+export declare const A2UI_ROOTS_COMPONENT = "texuli-roots";
+/** Keys of an A2UI component that are structure, not props. */
+export declare const A2UI_RESERVED_KEYS: readonly string[];
+/** A static list of child ids, or a data-bound template (not supported here). */
+export type A2uiChildList = readonly string[] | {
+    componentId: string;
+    path: string;
+};
+/** One flat A2UI component: id, type and its props side by side. */
+export interface A2uiComponent {
+    id: string;
+    component: string;
+    children?: A2uiChildList;
+    child?: string;
+    [prop: string]: unknown;
+}
+export interface A2uiCreateSurfaceMessage {
+    version: typeof A2UI_VERSION;
+    createSurface: {
+        surfaceId: string;
+        catalogId: string;
+        theme?: Record<string, unknown>;
+        sendDataModel?: boolean;
+    };
+}
+export interface A2uiUpdateComponentsMessage {
+    version: typeof A2UI_VERSION;
+    updateComponents: {
+        surfaceId: string;
+        components: A2uiComponent[];
+    };
+}
+export interface A2uiUpdateDataModelMessage {
+    version: typeof A2UI_VERSION;
+    updateDataModel: {
+        surfaceId: string;
+        path?: string;
+        value?: unknown;
+    };
+}
+export interface A2uiDeleteSurfaceMessage {
+    version: typeof A2UI_VERSION;
+    deleteSurface: {
+        surfaceId: string;
+    };
+}
+/** One server-to-client message. */
+export type A2uiMessage = A2uiCreateSurfaceMessage | A2uiUpdateComponentsMessage | A2uiUpdateDataModelMessage | A2uiDeleteSurfaceMessage;
+/** Why a conversion failed. */
+export type A2uiIssueCode = 'schema' | 'surface' | 'missing-root' | 'missing-child' | 'cycle' | 'shared-child' | 'template-children' | 'binding' | 'reserved-prop' | 'unsafe-key' | 'not-json' | 'invalid-node' | 'limit';
+export interface A2uiDiagnostic {
+    code: A2uiIssueCode;
+    /** JSONPath-style location, e.g. `$[1].updateComponents.components[2].text`. */
+    path: string;
+    message: string;
+}
+/** Size guards for untrusted payloads. */
+export interface A2uiLimits {
+    /** Most components in one surface (default 1000). */
+    maxComponents?: number;
+    /** Deepest nesting, the root at depth 1 (default 64). */
+    maxDepth?: number;
+}

package/dist/a2ui/types.js

@@ -0,0 +1,11 @@
+/** The A2UI protocol version this adapter reads and writes. */
+export const A2UI_VERSION = 'v0.9';
+/** The component id A2UI requires as the root of a surface's tree. */
+export const A2UI_ROOT_ID = 'root';
+/**
+ * Component a payload uses as its root when the catalog tree has zero or
+ * several top-level nodes. `a2uiToCatalogTree` unwraps it.
+ */
+export const A2UI_ROOTS_COMPONENT = 'texuli-roots';
+/** Keys of an A2UI component that are structure, not props. */
+export const A2UI_RESERVED_KEYS = ['id', 'component', 'children', 'child'];

package/dist/cli-add/add.d.ts

@@ -0,0 +1,21 @@
+import type { AddFilePlan, AddOptions, AddResult } from './types.js';
+/**
+ * Plan which files to copy for a component. Does not write.
+ * Throws never — errors go on the result.
+ */
+export declare function planAdd(options: AddOptions): Promise<{
+    result: AddResult;
+    plans: AddFilePlan[];
+    meta?: {
+        id: string;
+        package: string;
+        version: string;
+        sourceDir: string;
+        cwdReal: string;
+    };
+}>;
+/**
+ * Copy a styled component into the consumer project with provenance headers.
+ * Local filesystem only — no network. Contained writes only.
+ */
+export declare function addComponent(options: AddOptions): Promise<AddResult>;

package/dist/cli-add/add.js

@@ -0,0 +1,241 @@
+/**
+ * Core `texuli add` logic: resolve a styled component, refuse primitives,
+ * stamp provenance, write into the consumer tree. No network.
+ * Destination and source paths are contained (see paths.ts).
+ */
+import { existsSync } from 'node:fs';
+import { mkdir, readdir, readFile, realpath, stat, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { assertNoSymlinkOnPath, assertSourceFileInside, resolveContainedOutDir, resolveContainedSourceDir, validateRegistryEntry, } from "./paths.js";
+import { hasProvenance, provenanceHeader, provenanceSource } from "./provenance.js";
+import { getAddable, isPrimitivesPath, listAddableIds } from "./registry.js";
+const DEFAULT_VERSION = '0.0.0';
+async function listFilesRecursive(dir) {
+    const out = [];
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === 'node_modules' || entry.name === 'dist' || entry.name === '.git')
+                continue;
+            out.push(...(await listFilesRecursive(full)));
+        }
+        else if (entry.isFile()) {
+            out.push(full);
+        }
+    }
+    return out;
+}
+function defaultOutRelative(id) {
+    return join('src', 'components', 'texuli', id);
+}
+/**
+ * Plan which files to copy for a component. Does not write.
+ * Throws never — errors go on the result.
+ */
+export async function planAdd(options) {
+    const id = options.id.trim().toLowerCase();
+    const version = options.version ?? DEFAULT_VERSION;
+    const dryRun = Boolean(options.dryRun);
+    const force = options.force === true;
+    const cwdResolved = resolve(options.cwd);
+    const empty = (errors, outDir = cwdResolved) => ({
+        result: {
+            ok: false,
+            id,
+            package: '',
+            outDir,
+            files: [],
+            errors,
+            dryRun,
+        },
+        plans: [],
+    });
+    if (!id)
+        return empty(['Component id is required.']);
+    if (!options.sourceRoot || !existsSync(options.sourceRoot)) {
+        return empty([`Source root does not exist: ${options.sourceRoot || '(empty)'}`]);
+    }
+    if (isPrimitivesPath(options.sourceRoot)) {
+        return empty(['Source root must not be the primitives package.']);
+    }
+    // (1) Contain outDir under cwd.
+    const outRelative = options.outDir ?? defaultOutRelative(id);
+    const outResolved = resolveContainedOutDir(options.cwd, outRelative);
+    if (!outResolved.ok)
+        return empty([outResolved.error]);
+    const outDir = outResolved.outDir;
+    let cwdReal = cwdResolved;
+    try {
+        cwdReal = await realpath(cwdResolved);
+    }
+    catch {
+        cwdReal = cwdResolved;
+    }
+    const entry = getAddable(id, options.registry);
+    if (!entry) {
+        const known = listAddableIds(options.registry).join(', ');
+        return empty([
+            `Unknown or non-addable component "${id}". Styled components only (never primitives). Known: ${known || '(none)'}.`,
+        ], outDir);
+    }
+    // (3) Validate registry entry (built-in or options.registry).
+    const entryCheck = validateRegistryEntry(entry);
+    if (!entryCheck.ok)
+        return empty([entryCheck.error], outDir);
+    if (entry.package === '@texuli/primitives' ||
+        entry.package === 'primitives' ||
+        isPrimitivesPath(join('packages', entry.package, entry.directory))) {
+        return empty([`Refusing to copy primitives package component "${id}".`], outDir);
+    }
+    const sourceResolved = resolveContainedSourceDir(options.sourceRoot, entry);
+    if (!sourceResolved.ok)
+        return empty([sourceResolved.error], outDir);
+    const { sourceDir } = sourceResolved;
+    if (isPrimitivesPath(sourceDir)) {
+        return empty([`Refusing to copy primitives package component "${id}".`], outDir);
+    }
+    if (!existsSync(sourceDir)) {
+        return empty([`Source directory missing: ${sourceDir}`], outDir);
+    }
+    const sourceStat = await stat(sourceDir);
+    if (!sourceStat.isDirectory()) {
+        return empty([`Source is not a directory: ${sourceDir}`], outDir);
+    }
+    const files = await listFilesRecursive(sourceDir);
+    if (files.length === 0) {
+        return empty([`No files found under ${sourceDir}`], outDir);
+    }
+    // Headers record the source relative to the real root, so a symlinked root
+    // (macOS /var -> /private/var) never stamps a parent or machine path.
+    const sourceDirRel = relative(await realpath(options.sourceRoot), await realpath(sourceDir))
+        .split(sep)
+        .join('/');
+    const plans = [];
+    const fileResults = [];
+    const errors = [];
+    for (const from of files) {
+        if (isPrimitivesPath(from)) {
+            return empty([`Refusing path under primitives: ${from}`], outDir);
+        }
+        // (4) Source file must realpath inside sourceDir.
+        const inside = assertSourceFileInside(sourceDir, from);
+        if (!inside.ok) {
+            return empty([inside.error], outDir);
+        }
+        const relativePath = relative(sourceDir, from).split(sep).join('/');
+        // Relative path must not escape (belt and braces).
+        if (relativePath.startsWith('..') ||
+            relativePath.includes(`../`) ||
+            relativePath.includes('..\\')) {
+            return empty([`Source relative path escapes component directory: ${relativePath}`], outDir);
+        }
+        if (provenanceSource(sourceDirRel, relativePath) === null) {
+            return empty([`Provenance source would not be a plain relative path: ${sourceDirRel}/${relativePath}`], outDir);
+        }
+        const to = resolve(outDir, relativePath);
+        // Destination file must stay under outDir / cwd.
+        const relToOut = relative(outDir, to);
+        if (relToOut.startsWith(`..${sep}`) || relToOut === '..' || isAbsoluteRel(relToOut)) {
+            return empty([`Destination file escapes outDir: ${to}`], outDir);
+        }
+        // (2) No symlink on destination path (even with --force).
+        const linkCheck = assertNoSymlinkOnPath(to, cwdReal);
+        if (!linkCheck.ok) {
+            return empty([linkCheck.error], outDir);
+        }
+        const buf = await readFile(from);
+        plans.push({
+            relativePath,
+            from: inside.realFile,
+            to,
+            sourceBytes: buf.byteLength,
+        });
+        const exists = existsSync(to);
+        if (exists && !force) {
+            fileResults.push({ path: to, action: 'skip', bytes: buf.byteLength });
+            errors.push(`Refusing to overwrite existing file (use --force): ${to}`);
+            continue;
+        }
+        fileResults.push({
+            path: to,
+            action: dryRun ? 'would-write' : 'write',
+            bytes: buf.byteLength,
+        });
+    }
+    const ok = errors.length === 0;
+    return {
+        result: {
+            ok,
+            id: entry.id,
+            package: entry.package,
+            outDir,
+            files: fileResults,
+            errors,
+            dryRun,
+        },
+        plans: ok ? plans : [],
+        meta: ok
+            ? {
+                id: entry.id,
+                package: entry.package,
+                version,
+                sourceDir: sourceDirRel,
+                cwdReal,
+            }
+            : undefined,
+    };
+}
+function isAbsoluteRel(rel) {
+    return rel.startsWith('/') || /^[A-Za-z]:[\\/]/.test(rel);
+}
+/**
+ * Copy a styled component into the consumer project with provenance headers.
+ * Local filesystem only — no network. Contained writes only.
+ */
+export async function addComponent(options) {
+    const { result, plans, meta } = await planAdd(options);
+    if (!result.ok || !meta || result.dryRun)
+        return result;
+    for (const plan of plans) {
+        // Re-check symlink containment immediately before write (TOCTOU).
+        const linkCheck = assertNoSymlinkOnPath(plan.to, meta.cwdReal);
+        if (!linkCheck.ok) {
+            return {
+                ...result,
+                ok: false,
+                errors: [...result.errors, linkCheck.error],
+                files: result.files.map((file) => file.path === plan.to ? { ...file, action: 'skip' } : file),
+            };
+        }
+        const raw = await readFile(plan.from, 'utf8');
+        // planAdd checked every path; null here would be a bug, so stamp nothing unsafe.
+        const source = provenanceSource(meta.sourceDir, plan.relativePath);
+        if (source === null) {
+            return {
+                ...result,
+                ok: false,
+                errors: [...result.errors, `Unsafe provenance source: ${plan.relativePath}`],
+            };
+        }
+        const header = hasProvenance(raw)
+            ? ''
+            : provenanceHeader({ id: meta.id, package: meta.package, version: meta.version, source }, plan.relativePath);
+        const body = header + raw;
+        await mkdir(dirname(plan.to), { recursive: true });
+        // After mkdir, parents must still be free of symlinks.
+        const afterMkdir = assertNoSymlinkOnPath(plan.to, meta.cwdReal);
+        if (!afterMkdir.ok) {
+            return {
+                ...result,
+                ok: false,
+                errors: [...result.errors, afterMkdir.error],
+            };
+        }
+        await writeFile(plan.to, body, 'utf8');
+    }
+    return {
+        ...result,
+        files: result.files.map((file) => file.action === 'would-write' ? { ...file, action: 'write' } : file),
+    };
+}

package/dist/cli-add/cli.d.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+export type AddCliArgs = {
+    id: string | null;
+    cwd: string;
+    sourceRoot: string;
+    outDir: string | null;
+    version: string | null;
+    json: boolean;
+    dryRun: boolean;
+    force: boolean;
+    list: boolean;
+    help: boolean;
+};
+/** Parse argv after the process name (and optional `add` verb). */
+export declare function parseAddArgs(argv: readonly string[], defaults?: {
+    cwd?: string;
+    sourceRoot?: string;
+}): AddCliArgs;
+/** Run the add CLI. Returns a process exit code. */
+export declare function runAddCli(argv: readonly string[], defaults?: {
+    cwd?: string;
+    sourceRoot?: string;
+}): Promise<number>;
+/** True when this module is the process entry (tsx / node cli.ts). */
+export declare function isMainModule(metaUrl: string): boolean;

package/dist/cli-add/cli.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+/// <reference types="node" />
+/**
+ * `texuli add <component> [options]`
+ *
+ * Copies styled component source into the consumer project with a provenance
+ * header. Never copies primitives. No network.
+ *
+ *   pnpm exec tsx packages/tools/src/cli-add/cli.ts button --cwd <app> --source-root <repo>
+ *   … --json --dry-run --force --out src/ui/button
+ */
+import { fileURLToPath } from 'node:url';
+import { addComponent } from "./add.js";
+import { listAddableIds } from "./registry.js";
+const USAGE = `Usage: texuli add <component> [options]
+
+Copy styled Texuli component source into the current project (never primitives).
+
+Options:
+  --cwd <dir>           Consumer project root (default: process.cwd())
+  --source-root <dir>   Monorepo / fixture root that holds packages/ (required in tests; default: cwd)
+  --out <dir>           Destination relative to cwd (default: src/components/texuli/<id>)
+  --version <semver>    Version stamped in the provenance header (default: 0.0.0)
+  --force               Overwrite existing files
+  --dry-run             Plan only; write nothing
+  --json                Machine-readable result on stdout
+  --list                Print addable component ids and exit
+  --help                Show this help
+`;
+/** Parse argv after the process name (and optional `add` verb). */
+export function parseAddArgs(argv, defaults) {
+    const cwdDefault = defaults?.cwd ?? process.cwd();
+    const sourceDefault = defaults?.sourceRoot ?? cwdDefault;
+    const args = {
+        id: null,
+        cwd: cwdDefault,
+        sourceRoot: sourceDefault,
+        outDir: null,
+        version: null,
+        json: false,
+        dryRun: false,
+        force: false,
+        list: false,
+        help: false,
+    };
+    const rest = [...argv];
+    // Drop a leading `add` verb when the bin routes all subcommands here.
+    if (rest[0] === 'add')
+        rest.shift();
+    for (let i = 0; i < rest.length; i += 1) {
+        const arg = rest[i];
+        if (arg === undefined)
+            break;
+        const next = () => {
+            const value = rest[i + 1];
+            if (value === undefined || value.startsWith('-')) {
+                throw new Error(`${arg} needs a value`);
+            }
+            i += 1;
+            return value;
+        };
+        if (arg === '--help' || arg === '-h')
+            args.help = true;
+        else if (arg === '--json')
+            args.json = true;
+        else if (arg === '--dry-run')
+            args.dryRun = true;
+        else if (arg === '--force')
+            args.force = true;
+        else if (arg === '--list')
+            args.list = true;
+        else if (arg === '--cwd')
+            args.cwd = next();
+        else if (arg === '--source-root')
+            args.sourceRoot = next();
+        else if (arg === '--out')
+            args.outDir = next();
+        else if (arg === '--version')
+            args.version = next();
+        else if (arg.startsWith('-'))
+            throw new Error(`Unknown option: ${arg}`);
+        else if (args.id === null)
+            args.id = arg;
+        else
+            throw new Error(`Unexpected argument: ${arg}`);
+    }
+    return args;
+}
+function printHuman(result) {
+    if (!result.ok) {
+        for (const error of result.errors)
+            console.error(error);
+        return;
+    }
+    const verb = result.dryRun ? 'would add' : 'added';
+    console.log(`${verb} ${result.id} (${result.package}) → ${result.outDir}`);
+    for (const file of result.files) {
+        console.log(`  ${file.action.padEnd(12)} ${file.path} (${file.bytes} B)`);
+    }
+}
+/** Run the add CLI. Returns a process exit code. */
+export async function runAddCli(argv, defaults) {
+    let args;
+    try {
+        args = parseAddArgs(argv, defaults);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        console.error(USAGE);
+        return 1;
+    }
+    if (args.help) {
+        console.log(USAGE);
+        return 0;
+    }
+    if (args.list) {
+        const ids = listAddableIds();
+        console.log(args.json ? JSON.stringify({ ids }) : ids.join('\n'));
+        return 0;
+    }
+    if (!args.id) {
+        console.error('Component id is required.');
+        console.error(USAGE);
+        return 1;
+    }
+    const result = await addComponent({
+        id: args.id,
+        cwd: args.cwd,
+        sourceRoot: args.sourceRoot,
+        ...(args.outDir ? { outDir: args.outDir } : {}),
+        ...(args.version ? { version: args.version } : {}),
+        dryRun: args.dryRun,
+        force: args.force,
+    });
+    if (args.json)
+        console.log(JSON.stringify(result));
+    else
+        printHuman(result);
+    return result.ok ? 0 : 1;
+}
+/** True when this module is the process entry (tsx / node cli.ts). */
+export function isMainModule(metaUrl) {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    try {
+        return fileURLToPath(metaUrl) === entry || fileURLToPath(metaUrl) === fileURLToPath(entry);
+    }
+    catch {
+        return metaUrl.endsWith(entry.replace(/\\/g, '/'));
+    }
+}
+if (isMainModule(import.meta.url)) {
+    runAddCli(process.argv.slice(2)).then((code) => {
+        process.exitCode = code;
+    });
+}

package/dist/cli-add/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `@texuli/tools/cli-add` — `texuli add <component>`
+ *
+ * Copies styled component source into a consumer project with a provenance
+ * header. Never copies primitives. Local filesystem only (no network).
+ */
+export { addComponent, planAdd } from './add.js';
+export { type AddCliArgs, isMainModule, parseAddArgs, runAddCli } from './cli.js';
+export { assertNoSymlinkOnPath, assertSourceFileInside, escapesRoot, resolveContainedOutDir, resolveContainedSourceDir, validateRegistryEntry, } from './paths.js';
+export { hasProvenance, isPlainSourcePath, type ProvenanceMeta, provenanceBlockComment, provenanceBody, provenanceHeader, provenanceHtmlComment, provenanceSource, } from './provenance.js';
+export { DEFAULT_ADD_REGISTRY, getAddable, isPrimitivesPath, listAddableIds, } from './registry.js';
+export type { AddableComponent, AddFilePlan, AddOptions, AddResult, } from './types.js';

package/dist/cli-add/index.js

@@ -0,0 +1,11 @@
+/**
+ * `@texuli/tools/cli-add` — `texuli add <component>`
+ *
+ * Copies styled component source into a consumer project with a provenance
+ * header. Never copies primitives. Local filesystem only (no network).
+ */
+export { addComponent, planAdd } from "./add.js";
+export { isMainModule, parseAddArgs, runAddCli } from "./cli.js";
+export { assertNoSymlinkOnPath, assertSourceFileInside, escapesRoot, resolveContainedOutDir, resolveContainedSourceDir, validateRegistryEntry, } from "./paths.js";
+export { hasProvenance, isPlainSourcePath, provenanceBlockComment, provenanceBody, provenanceHeader, provenanceHtmlComment, provenanceSource, } from "./provenance.js";
+export { DEFAULT_ADD_REGISTRY, getAddable, isPrimitivesPath, listAddableIds, } from "./registry.js";

package/dist/cli-add/paths.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Re-export shared path containment (implementation lives in `../internal/paths.ts`).
+ */
+export { assertNoSymlinkOnPath, assertSourceFileInside, escapesRoot, resolveContainedOutDir, resolveContainedSourceDir, validateRegistryEntry, } from '../internal/paths.js';

package/dist/cli-add/paths.js

@@ -0,0 +1,4 @@
+/**
+ * Re-export shared path containment (implementation lives in `../internal/paths.ts`).
+ */
+export { assertNoSymlinkOnPath, assertSourceFileInside, escapesRoot, resolveContainedOutDir, resolveContainedSourceDir, validateRegistryEntry, } from "../internal/paths.js";