@astryxdesign/cli 0.7.12-canary.ccb4a6d → 0.7.12-canary.da3dbdc

package/api/swizzle/_moduleGraph.mjs

@@ -14,6 +14,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import {isBuiltin} from 'node:module';
 import {packageOf} from '../../foundation/render/served-packages.mjs';
+import {resolveInstalledPackageDir} from '../../foundation/integrations/installed-package.mjs';
 import {parse} from '@babel/parser';
 import {
   inspectPackageExport,
@@ -390,6 +391,8 @@ function publicSurfaceOf(packageDir, srcRoot, originsOf) {
  *   file the copy holds (absolute source path), with the edits its imports need
  * @property {Map<string, Set<string>>} dependsOn file -> carried files its
  *   computed specifiers point at
+ * @property {Map<string, string>} otherPackages the source root of each other
+ *   Astryx package the copy carries modules from, with its package name
  * @property {Record<string, string>} dependencies each npm package the copied
  *   files import, other than the owner package and Node's built-in modules,
  *   with the range the owner package declares
@@ -429,19 +432,6 @@ export function planCopy({
     });
   /** @param {string} file @param {string} name */
   const originOf = (file, name) => originsOf(file, 'type').get(name) ?? null;
-  /**
-   * The subpaths that export a module's export: as a value when the import
-   * takes a value, since a type-only export is erased at runtime.
-   * @param {string} file
-   * @param {string} name
-   * @param {boolean} typeOnly
-   */
-  const exportersOf = (file, name, typeOnly) => {
-    const origin = originOf(file, name);
-    if (!origin) return [];
-    const kind = typeOnly ? 'type' : 'value';
-    return surface.byOrigin[kind].get(`${origin.file}#${origin.name}`) ?? [];
-  };
   /**
    * The name a module exports one of its own bindings under, or null.
    * @param {{file: string, name: string}} origin
@@ -454,7 +444,6 @@ export function planCopy({
   };
   /** @type {Map<string, string|null>} */
   const resolutions = new Map();
-  const surface = publicSurfaceOf(packageDir, srcRoot, originsOf);
   /** @type {CopyPlan['files']} */
   const files = new Map();
   /** @type {CopyPlan['dependsOn']} */
@@ -472,73 +461,162 @@ export function planCopy({
   };
   /** @param {string} file */
   const inComponent = file => file.startsWith(componentDir + path.sep);
-  /** @param {string} file */
-  const inSource = file => file.startsWith(srcRoot + path.sep);
 
   /**
-   * The subpath that exports every name a module exports, with the same
-   * definition. An exactly exported file is its own subpath.
-   * @param {string} file
-   * @returns {string|null}
+   * @typedef {ReturnType<typeof makeContext>} PackageContext
    */
-  const subpathCoveringModule = file => {
-    const exact = surface.byFile.get(file);
-    if (exact) return exact;
-    const names = [...originsOf(file, 'type').keys()];
-    if (names.length === 0) return null;
-    const values = originsOf(file, 'value');
-    const options = names.map(name =>
-      exportersOf(file, name, !values.has(name))
-        .filter(o => o.name === name)
-        .map(o => o.subpath),
-    );
-    const common = options.reduce((acc, list) =>
-      acc.filter(s => list.includes(s)),
-    );
-    return STYLEX_FILE.test(file) ? null : pickSubpath(common, file);
-  };
 
   /**
-   * The public subpath to take a name from. A StyleX module is imported by
-   * its own exported path, because the StyleX compiler resolves styles and
-   * variables from the real module; when that path is not exported, there is
-   * no public import.
-   * @param {string[]} subpaths subpaths that export the name
-   * @param {string} target the module the import names
-   * @param {string} [originFile] the module that defines the name
-   * @returns {string|null}
+   * How references inside one package's source are planned: its public
+   * surface and the subpaths a name or module is imported from.
+   * @param {{packageDir: string, srcRoot: string, ownerPackage: string}} pkg
    */
-  const choosePublic = (subpaths, target, originFile) => {
-    const exact = originFile ? surface.byFile.get(originFile) : undefined;
-    if (exact && subpaths.includes(exact)) return exact;
-    if (
-      STYLEX_FILE.test(target) ||
-      (originFile && STYLEX_FILE.test(originFile))
-    )
-      return null;
-    return pickSubpath(subpaths, target);
+  function makeContext({packageDir, srcRoot, ownerPackage}) {
+    const surface = publicSurfaceOf(packageDir, srcRoot, originsOf);
+    /** @param {string} file */
+    const inSource = file => file.startsWith(srcRoot + path.sep);
+    /**
+     * The subpaths that export a module's export: as a value when the import
+     * takes a value, since a type-only export is erased at runtime.
+     * @param {string} file
+     * @param {string} name
+     * @param {boolean} typeOnly
+     */
+    const exportersOf = (file, name, typeOnly) => {
+      const origin = originOf(file, name);
+      if (!origin) return [];
+      const kind = typeOnly ? 'type' : 'value';
+      return surface.byOrigin[kind].get(`${origin.file}#${origin.name}`) ?? [];
+    };
+    /**
+     * The subpath that exports every name a module exports, with the same
+     * definition. An exactly exported file is its own subpath.
+     * @param {string} file
+     * @returns {string|null}
+     */
+    const subpathCoveringModule = file => {
+      const exact = surface.byFile.get(file);
+      if (exact) return exact;
+      const names = [...originsOf(file, 'type').keys()];
+      if (names.length === 0) return null;
+      const values = originsOf(file, 'value');
+      const options = names.map(name =>
+        exportersOf(file, name, !values.has(name))
+          .filter(o => o.name === name)
+          .map(o => o.subpath),
+      );
+      const common = options.reduce((acc, list) =>
+        acc.filter(s => list.includes(s)),
+      );
+      return STYLEX_FILE.test(file) ? null : pickSubpath(common, file);
+    };
+
+    /**
+     * The public subpath to take a name from. A StyleX module is imported by
+     * its own exported path, because the StyleX compiler resolves styles and
+     * variables from the real module; when that path is not exported, there is
+     * no public import.
+     * @param {string[]} subpaths subpaths that export the name
+     * @param {string} target the module the import names
+     * @param {string} [originFile] the module that defines the name
+     * @returns {string|null}
+     */
+    const choosePublic = (subpaths, target, originFile) => {
+      const exact = originFile ? surface.byFile.get(originFile) : undefined;
+      if (exact && subpaths.includes(exact)) return exact;
+      if (
+        STYLEX_FILE.test(target) ||
+        (originFile && STYLEX_FILE.test(originFile))
+      )
+        return null;
+      return pickSubpath(subpaths, target);
+    };
+
+    /**
+     * Prefer the subpath of the module's top folder, then the package root.
+     * @param {string[]} subpaths
+     * @param {string} file
+     * @returns {string|null}
+     */
+    const pickSubpath = (subpaths, file) => {
+      if (subpaths.length === 0) return null;
+      const top = `./${toPosix(path.relative(srcRoot, file)).split('/')[0]}`;
+      return (
+        subpaths.find(s => s === top) ??
+        subpaths.find(s => s === '.') ??
+        [...subpaths].sort((a, b) => a.length - b.length)[0]
+      );
+    };
+
+    /** @param {string} subpath */
+    const publicSpecifier = subpath =>
+      subpath === '.' ? ownerPackage : `${ownerPackage}/${subpath.slice(2)}`;
+
+    return {
+      packageDir,
+      srcRoot,
+      ownerPackage,
+      surface,
+      inSource,
+      exportersOf,
+      subpathCoveringModule,
+      choosePublic,
+      publicSpecifier,
+    };
+  }
+  const owner = makeContext({packageDir, srcRoot, ownerPackage});
+  /** @type {Map<string, PackageContext>} other packages' contexts, by source root */
+  const others = new Map();
+  /** @param {string} file */
+  const contextOf = file => {
+    if (file.startsWith(srcRoot + path.sep)) return owner;
+    for (const [root, context] of others) {
+      if (file.startsWith(root + path.sep)) return context;
+    }
+    return owner;
   };
 
   /**
-   * Prefer the subpath of the module's top folder, then the package root.
-   * @param {string[]} subpaths
+   * The source module a bare import of another Astryx package's
+   * `./internal/*` path names, or null. That module is carried, and its
+   * package gets a context of its own.
    * @param {string} file
+   * @param {string} specifier
    * @returns {string|null}
    */
-  const pickSubpath = (subpaths, file) => {
-    if (subpaths.length === 0) return null;
-    const top = `./${toPosix(path.relative(srcRoot, file)).split('/')[0]}`;
-    return (
-      subpaths.find(s => s === top) ??
-      subpaths.find(s => s === '.') ??
-      [...subpaths].sort((a, b) => a.length - b.length)[0]
-    );
+  const internalModuleOf = (file, specifier) => {
+    const name = packageOf(specifier);
+    const sub = specifier.slice(name.length + 1);
+    if (!name.startsWith('@astryxdesign/') || name === ownerPackage)
+      return null;
+    if (!/^internal(\/|$)/.test(sub)) return null;
+    const installed = resolveInstalledPackageDir(name, path.dirname(file));
+    if (!installed) return null;
+    const dir = fs.realpathSync(installed.packageDir);
+    /** @type {{exports?: unknown}} */
+    let pkg;
+    try {
+      pkg = JSON.parse(
+        fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'),
+      );
+    } catch {
+      return null;
+    }
+    const target = sourceExportTarget(pkg, dir, `./${sub}`);
+    // A StyleX module's identity is its path, so the copy keeps importing it
+    // by its exported path and agrees with the package on it.
+    if (!target || STYLEX_FILE.test(target)) return null;
+    const src = path.join(dir, 'src');
+    const root = target.startsWith(src + path.sep) ? src : dir;
+    if (!others.has(root)) {
+      others.set(
+        root,
+        makeContext({packageDir: dir, srcRoot: root, ownerPackage: name}),
+      );
+    }
+    return target;
   };
 
-  /** @param {string} subpath */
-  const publicSpecifier = subpath =>
-    subpath === '.' ? ownerPackage : `${ownerPackage}/${subpath.slice(2)}`;
-
   /**
    * Carry a module in the copy.
    * @param {string} from
@@ -560,8 +638,14 @@ export function planCopy({
     const edits = [];
     files.set(file, {code: parsed.code, edits});
     if (!CODE_FILE.test(file)) continue;
+    const context = contextOf(file);
     for (const ref of parsed.references) {
       if (!ref.source.startsWith('.')) {
+        const internal = internalModuleOf(file, ref.source);
+        if (internal) {
+          edits.push(sourceEdit(parsed.code, ref, carry(file, internal)));
+          continue;
+        }
         const builtin = ref.source.startsWith('node:') || isBuiltin(ref.source);
         const name = packageOf(ref.source);
         if (!builtin && name !== ownerPackage) packages.add(name);
@@ -576,44 +660,61 @@ export function planCopy({
         else edits.push(sourceEdit(parsed.code, ref, carry(file, target)));
         continue;
       }
-      if (!CODE_FILE.test(target) || !inSource(target)) {
+      if (!CODE_FILE.test(target) || !context.inSource(target)) {
         // An asset, such as `../../locales/en.json` or a stylesheet, that the
         // package exports by its own path is imported from the package.
-        const subpath = `./${toPosix(path.relative(packageDir, target))}`;
+        const subpath = `./${toPosix(path.relative(context.packageDir, target))}`;
         if (
-          subpathDeclaration(surface.exportsField, subpath).state === 'declared'
+          subpathDeclaration(context.surface.exportsField, subpath).state ===
+          'declared'
         ) {
+          if (context !== owner) packages.add(context.ownerPackage);
           edits.push(
-            sourceEdit(parsed.code, ref, `${ownerPackage}/${subpath.slice(2)}`),
+            sourceEdit(
+              parsed.code,
+              ref,
+              `${context.ownerPackage}/${subpath.slice(2)}`,
+            ),
           );
           continue;
         }
         // An unexported asset in the source is carried; one outside it is
         // left for the build to report.
-        if (!inSource(target)) continue;
+        if (!context.inSource(target)) continue;
         edits.push(sourceEdit(parsed.code, ref, carry(file, target)));
         continue;
       }
-      edits.push(planReference(file, parsed.code, ref, target));
+      edits.push(planReference(context, file, parsed.code, ref, target));
     }
   }
-  return {files, dependsOn, dependencies: declaredRanges(packageDir, packages)};
+  return {
+    files,
+    dependsOn,
+    dependencies: declaredRanges(packageDir, packages),
+    otherPackages: new Map(
+      [...others].map(([root, c]) => [root, c.ownerPackage]),
+    ),
+  };
 
   /**
    * Decide one reference that leaves the component folder.
+   * @param {PackageContext} context the package the importing file is in
    * @param {string} file
    * @param {string} code
    * @param {ModuleReference} ref
    * @param {string} target
    * @returns {PlannedEdit}
    */
-  function planReference(file, code, ref, target) {
+  function planReference(context, file, code, ref, target) {
+    // A carried module of another package imports that package's public names
+    // from it, so the copy depends on it.
+    if (context !== owner) packages.add(context.ownerPackage);
     if (ref.kind !== 'named' && ref.kind !== 'reexportNamed') {
-      const covering = subpathCoveringModule(target);
+      const covering = context.subpathCoveringModule(target);
       return sourceEdit(
         code,
         ref,
-        covering ? publicSpecifier(covering) : carry(file, target),
+        covering ? context.publicSpecifier(covering) : carry(file, target),
       );
     }
     /** @type {Array<{choice: SpecifierChoice, specs: ImportSpecifier[]}>} */
@@ -630,13 +731,20 @@ export function planCopy({
     };
     for (const spec of ref.specifiers) {
       if (spec.imported === '*') {
-        const covering = subpathCoveringModule(target);
-        add(covering ? publicSpecifier(covering) : carry(file, target), spec);
+        const covering = context.subpathCoveringModule(target);
+        add(
+          covering ? context.publicSpecifier(covering) : carry(file, target),
+          spec,
+        );
         continue;
       }
       const origin = originOf(target, spec.imported);
-      const publicOptions = exportersOf(target, spec.imported, spec.typeOnly);
-      const chosen = choosePublic(
+      const publicOptions = context.exportersOf(
+        target,
+        spec.imported,
+        spec.typeOnly,
+      );
+      const chosen = context.choosePublic(
         publicOptions.map(o => o.subpath),
         target,
         origin?.file,
@@ -645,7 +753,7 @@ export function planCopy({
         const exported = /** @type {{name: string}} */ (
           publicOptions.find(o => o.subpath === chosen)
         ).name;
-        add(publicSpecifier(chosen), {...spec, imported: exported});
+        add(context.publicSpecifier(chosen), {...spec, imported: exported});
       } else {
         // Take the name from the module that defines it, so the copy carries
         // that module and not a whole barrel. An origin names a binding, so
@@ -654,7 +762,7 @@ export function planCopy({
         const definingExport =
           origin &&
           origin.file !== target &&
-          inSource(origin.file) &&
+          context.inSource(origin.file) &&
           !parseModule(target).declares.has(spec.imported)
             ? exportNameOf(origin)
             : null;

package/api/swizzle/copy/copy.mjs

@@ -361,12 +361,32 @@ export async function swizzleCopy(component, options = {}) {
   );
   /** @type {Map<string, string>} */
   const rootDests = new Map();
+  // A module from another Astryx package goes under a folder named after that
+  // package, at its path in that package's source.
+  /** @param {string} file */
+  const otherPackageOf = file => {
+    for (const [root, name] of plan.otherPackages) {
+      if (file.startsWith(root + path.sep)) return {root, folder: name.split('/').pop() ?? name};
+    }
+    return null;
+  };
+  /** @param {string} file the version of the package a helper comes from */
+  const versionOf = file => {
+    const other = otherPackageOf(file);
+    return other
+      ? packageVersionOf(findPackageRoot(other.root) ?? other.root)
+      : ownerVersion;
+  };
   for (const file of [...allFiles].sort()) {
     if (layoutDestOf(file) != null) continue;
-    const packagePath = path.relative(graphRoot, file);
-    let dest = path.join(outputBase, packagePath);
+    const other = otherPackageOf(file);
+    const base = other ? other.folder : path.basename(packageDir);
+    const packagePath = path.relative(other ? other.root : graphRoot, file);
+    let dest = other
+      ? path.join(outputBase, base, packagePath)
+      : path.join(outputBase, packagePath);
     for (let n = 1; takenDests.has(dest); n++) {
-      const folder = n === 1 ? path.basename(packageDir) : `${path.basename(packageDir)}-${n}`;
+      const folder = n === 1 && !other ? base : `${base}-${n}`;
       dest = path.join(outputBase, folder, packagePath);
     }
     takenDests.add(dest);
@@ -381,15 +401,17 @@ export async function swizzleCopy(component, options = {}) {
   // A private attribute owner module and the unexported style modules it
   // imports travel whole and are replaced only with --overwrite.
   const ownerGroup = new Set();
+  /** @param {string} file the source root a carried module sits under */
+  const rootOf = file => otherPackageOf(file)?.root ?? srcRoot;
   const ownerQueue = helpers.filter(f =>
-    OWNER_MODULE.test(toModulePath(srcRoot, f)),
+    OWNER_MODULE.test(toModulePath(rootOf(f), f)),
   );
   while (ownerQueue.length > 0) {
     const file = /** @type {string} */ (ownerQueue.shift());
     if (ownerGroup.has(file)) continue;
     ownerGroup.add(file);
     for (const dep of plan.dependsOn.get(file) ?? []) {
-      if (!isComponentFile(dep) && STYLEX_MODULE.test(toModulePath(srcRoot, dep))) {
+      if (!isComponentFile(dep) && STYLEX_MODULE.test(toModulePath(rootOf(dep), dep))) {
         ownerQueue.push(dep);
       }
     }
@@ -431,7 +453,7 @@ export async function swizzleCopy(component, options = {}) {
       attempts.set(file, attempt);
       redirected.set(
         file,
-        versionedPath(baseDestOf(file), ownerVersion, attempt),
+        versionedPath(baseDestOf(file), versionOf(file), attempt),
       );
       moved = true;
     }
@@ -473,16 +495,51 @@ export async function swizzleCopy(component, options = {}) {
     );
   }
 
+  // The marker tells @astryxdesign/build that the output folder holds Astryx
+  // source, so the copy compiles below the theme as the package does.
+  const markerDest = confineWrite(path.join(outputBase, SWIZZLE_MARKER), cwd, {
+    allowAbsolute: true,
+    label: 'output file',
+  });
+  const markerExisting = readExisting(markerDest);
+  const markerContent = swizzleMarkerContent(
+    markerExisting,
+    owner.ownerPackage,
+    ownerVersion,
+  );
+  // Every module under the marker compiles as Astryx source, so swizzle marks
+  // only a folder it owns: one the copy creates, an empty one, or one it
+  // marked before. Any other folder is reported with what it holds.
+  const foundInOutputBase =
+    markerExisting == null &&
+    fs.existsSync(outputBase) &&
+    fs.statSync(outputBase).isDirectory()
+      ? fs.readdirSync(outputBase).sort()
+      : [];
+  const marksOutputBase = foundInOutputBase.length === 0;
+  const writes = marksOutputBase
+    ? [
+        ...outputs,
+        {
+          dest: markerDest,
+          content: markerContent,
+          marker: true,
+          unchanged: markerExisting === markerContent,
+        },
+      ]
+    : outputs;
+
   const outputDirExisted = fs.existsSync(outputDir);
   /** @type {string[]} folders this run created, outermost first */
   const createdDirs = [];
   /** @type {Array<{dest: string, original: Buffer|null}>} */
   const written = [];
   let copied = 0;
-  for (const output of outputs) {
+  for (const output of writes) {
+    const counts = !('marker' in output);
     // An identical file is already in place: it is part of this copy, unwritten.
     if (output.unchanged) {
-      copied++;
+      if (counts) copied++;
       continue;
     }
     try {
@@ -491,7 +548,7 @@ export async function swizzleCopy(component, options = {}) {
       if (firstCreated != null) createdDirs.push(firstCreated);
       written.push({dest: output.dest, original});
       fs.writeFileSync(output.dest, output.content);
-      copied++;
+      if (counts) copied++;
     } catch (err) {
       const unrestored = undoCopy(written);
       for (const dir of [...createdDirs].reverse()) {
@@ -516,10 +573,44 @@ export async function swizzleCopy(component, options = {}) {
     usesStyleX: outputs.some(o => o.content.includes('@stylexjs/stylex')),
     dependencies: plan.dependencies,
   };
+  data.marker = marksOutputBase
+    ? {path: toPosix(path.relative(cwd, markerDest)), written: true}
+    : {
+        path: toPosix(path.relative(cwd, markerDest)),
+        written: false,
+        found: foundInOutputBase.slice(0, 5),
+      };
   if (feedback) data.feedback = feedback;
   return {type: 'swizzle.copy', package: data.package, data};
 }
 
+/** The file that marks a swizzle output folder as Astryx source. */
+const SWIZZLE_MARKER = 'astryx-swizzle.json';
+
+/**
+ * The marker's content after a copy from `ownerPackage`: the packages the
+ * folder's copies came from, each with its version. Unreadable content is
+ * replaced.
+ * @param {string|null} existing
+ * @param {string} ownerPackage
+ * @param {string} version
+ * @returns {string}
+ */
+function swizzleMarkerContent(existing, ownerPackage, version) {
+  /** @type {Record<string, string>} */
+  let packages = {};
+  try {
+    const parsed = existing == null ? null : JSON.parse(existing);
+    if (parsed?.packages && typeof parsed.packages === 'object') {
+      packages = {...parsed.packages};
+    }
+  } catch {
+    // Unreadable content is rewritten below.
+  }
+  packages[ownerPackage] = version;
+  return `${JSON.stringify({packages}, null, 2)}\n`;
+}
+
 /**
  * Undo the writes of a copy that failed part-way, newest first: delete the
  * files the copy created and put back the bytes of the files it replaced. A

package/api/swizzle/swizzle.doc.mjs

@@ -21,8 +21,12 @@ export const doc = {
     'the owner package exports: names the package exports are imported from its ' +
     'public paths, and every internal module the component needs is ' +
     "copied beside it in the package's folder layout. Tests, stories and docs are not " +
-    'copied. The receipt flags whether any copied file uses StyleX and lists each npm ' +
-    'package the copy imports with the range the owner package declares. With no name ' +
+    'copied. An output folder swizzle owns (one the copy creates, an empty one, or one it ' +
+    'marked before) gets an astryx-swizzle.json marker naming each package its copies came from, ' +
+    "with its version, so @astryxdesign/build's Babel, PostCSS and Vite integrations, and " +
+    'withAstryx() under webpack, compile the copy below the theme. The receipt flags whether ' +
+    'any copied file uses StyleX and lists each npm package the copy imports with the range ' +
+    'the owner package declares. With no name ' +
     '(or list) it returns the swizzlable component names instead. An integration ' +
     'component that replaces a Core component is what that Core name copies; ' +
     "options.package '@astryxdesign/core' copies the original. The list names Core " +
@@ -81,7 +85,7 @@ export const doc = {
     {
       type: 'swizzle.copy',
       description:
-        'A receipt after copying the component into the project: the component name, owning package, output directory, files-copied count, the copied file names (relative to the component folder; the internal modules copied beside it start with `../`, e.g. `../InputGroup/groupStyles.ts`), whether any file uses StyleX, and, when the owner has an issues URL, feedback ({issuesUrl, ghCommand?}): where to report the gap that led to swizzling.',
+        'A receipt after copying the component into the project: the component name, owning package, output directory, files-copied count, the copied file names (relative to the component folder; the internal modules copied beside it start with `../`, e.g. `../InputGroup/groupStyles.ts`), whether any file uses StyleX, the npm packages the copy imports with the ranges the owner declares (dependencies), the output folder\'s astryx-swizzle.json (marker: {path, written, found?}; written is false for a folder swizzle does not own, and found names up to five entries it already holds), and, when the owner has an issues URL, feedback ({issuesUrl, ghCommand?}): where to report the gap that led to swizzling.',
     },
   ],
   throws: [

package/api/swizzle/swizzle.type.d.mts

@@ -42,6 +42,11 @@ export type SwizzleCopyResponse = {
         files: string[];
         usesStyleX: boolean;
         dependencies: Record<string, string>;
+        marker?: {
+            path: string;
+            written: boolean;
+            found?: string[];
+        } | undefined;
         feedback?: SwizzleFeedback | undefined;
     };
 };

package/api/swizzle/swizzle.type.mjs

@@ -37,6 +37,7 @@
  * @property {string[]} data.files Copied file names, relative to the component folder; the internal modules copied beside it start with `../` (spec:AST-110 FR2).
  * @property {boolean} data.usesStyleX Whether any copied file uses StyleX (requires build-time setup).
  * @property {Record<string, string>} data.dependencies Each npm package the copied files import, other than the owner package, with the version range the owner package declares (`*` when it declares none). The copy builds once the product installs them (spec:AST-110 FR1).
+ * @property {{path: string, written: boolean, found?: string[]}} [data.marker] The output folder's astryx-swizzle.json, relative to the project (spec:AST-110 FR5). Swizzle writes it only into a folder it owns: one the copy creates, an empty one, or one it marked before. When it does not, `written` is false and `found` names up to five entries already in the folder.
  * @property {SwizzleFeedback} [data.feedback]
  */
 

package/api/template/template.mjs

@@ -193,6 +193,7 @@ export async function template(name, options = {}) {
       `Unknown template "${name}"`,
       orderByAffinity(name, templates, t => [t.dirName, t.name], {
         closest: true,
+        typos: true,
       }).map(t => ({
         name: t.dirName,
         reason: `${t.type} template`,

package/assets/discover/official-packages.json

@@ -100,6 +100,10 @@
           "kind": "component",
           "name": "ChatUnreadDivider"
         },
+        {
+          "kind": "component",
+          "name": "ChatVirtualizer"
+        },
         {
           "kind": "component",
           "name": "CircleCheckIndicator"
@@ -128,6 +132,10 @@
           "kind": "component",
           "name": "CommentThread"
         },
+        {
+          "kind": "component",
+          "name": "DialogHeroHeader"
+        },
         {
           "kind": "component",
           "name": "DiffViewer"
@@ -136,6 +144,10 @@
           "kind": "component",
           "name": "EmojiPicker"
         },
+        {
+          "kind": "component",
+          "name": "LineClamp"
+        },
         {
           "kind": "component",
           "name": "ListInput"
@@ -252,6 +264,10 @@
           "kind": "template",
           "name": "CommentThreadShowcase"
         },
+        {
+          "kind": "template",
+          "name": "DialogHeroHeaderShowcase"
+        },
         {
           "kind": "template",
           "name": "DiffViewerShowcase"