eidosmd 0.2.0 → 0.3.1

package/dist/src/core/migrate.js

@@ -1,23 +1,40 @@
-// `eidos migrate`: the mechanical hop from a 4.x root to the standard this CLI
-// carries (5.0.0). Five names move on disk and nothing is dropped: `_eidos/`
-// becomes `.eidos/`, `shapes/` becomes `templates/`, the framework document
-// takes the 5.0.0 keys, every blueprint's `flavor` becomes `variant`, and
-// `eidos_version` is set. A root that kept the markdown Framework.md gets
-// Framework.yaml in its place, the index inside it. A template that opens
-// with frontmatter loses the block; one named off its unit is noted, since
-// only the owner can say which name is right.
-import { existsSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
+// `eidos migrate`: the mechanical hop from an older root to the standard this
+// CLI carries. From 4.x, five names move on disk and nothing is dropped:
+// `_eidos/` becomes `.eidos/`, `shapes/` becomes `templates/`, the framework
+// document takes the 5.0.0 keys, every blueprint's `flavor` becomes
+// `variant`, and `eidos_version` is set. A root that kept the markdown
+// Framework.md gets Framework.yaml in its place, the index inside it. A
+// template that opens with frontmatter loses the block; one named off its
+// unit is noted, since only the owner can say which name is right. From
+// 5.0.0 nothing on disk moves: the version is bumped and the standard's core
+// block is rewritten with its required rows, every region carried as found.
+// 5.2.0 named the one personal file a tool keeps, `local.yaml`, and the one
+// line in `.eidos/.gitignore` that covers every tool's: the hop adds that
+// line, and this CLI's own `.gitignore` beside its local file, which did the
+// same job before, goes. 5.3.0 declares every folder at the root with a
+// type: `collections` becomes `folders` and every entry gains
+// `type: collection`; anything at the root the document does not declare is
+// the owner's to declare or move, so it is reported, never touched.
+import { existsSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { isMap, isScalar, isSeq, parseDocument } from 'yaml';
-import { FRAMEWORK_DIR, FRAMEWORK_FILES, STANDARD_CORE, unitOf } from './framework-model.js';
+import { FRAMEWORK_DIR, FRAMEWORK_FILES, isCollection, STANDARD_CORE, unitOf } from './framework-model.js';
 import { convertToYaml } from './convert.js';
-import { annotateYaml } from './framework-structured.js';
+import { annotateYaml, coreEntries, YAML_GUIDANCE } from './framework-structured.js';
+import { undeclaredAtRoot } from './check.js';
 import { parseFramework } from './framework.js';
 import { parseVersions } from './framework-markdown.js';
 import { stripFrontmatter } from './template.js';
+import { LOCAL_IGNORE_PATTERN, rootIgnoresLocal, settingsDir } from './settings.js';
 import { readVersions, writeVersions, versionsFile } from './versions.js';
 import { standardVersion } from '../paths.js';
 export const LEGACY_DIR = '_eidos';
+// The comment the seeds write above the pattern, so a migrated root reads as a fresh one does.
+const LOCAL_IGNORE_NOTE = "# Eidos: a tool's local.yaml is personal and never shared.\n# A tool that keeps a folder under plugins/ may keep its personal settings there, one machine's (a\n# viewer command, an editor, a key path); everything else in its folder is the root's. This one\n# line covers every tool, so no tool writes a .gitignore of its own.\n";
+// The guidance this CLI wrote above `collections` before 5.3.0. A document
+// carrying it word for word gets the `folders` guidance in its place; any
+// other comment there is the owner's or the seed's and stays.
+const COLLECTIONS_GUIDANCE = " The collections. Each declares its variants (one default; each a template file named <unit>.<variant>.md under templates/, the unit being the word for one of its blueprints) and its grouping.\n Add a group under `grouping.groups` with a one-line description; add a variant with a template file in templates/.";
 export class MigrationError extends Error {
     constructor(message) {
         super(message);
@@ -67,23 +84,49 @@ const renameKey = (pair, to) => {
 };
 // The YAML form, key by key, comments kept: `schema` → `properties`,
 // `flavors` → `variants`, each variant's `shape` → `template` (with its path),
-// `unit` gone, the version set, and this CLI's guidance comments refreshed.
+// `unit` gone, `collections` → `folders` with `type: collection` on every
+// entry, the core block rewritten, the version set. A document that still
+// had the 4.x keys gets this CLI's guidance comments in their place; one
+// already on 5.x keeps every comment it had, the seed's included.
 export function migrateYamlDocument(text, version) {
     const document = parseDocument(text);
     const top = document.contents;
     if (!isMap(top))
         return text;
     // the root's versions left the framework document in 5.0.0; migrateRoot moves them
+    const legacy = top.items.some((pair) => keyOf(pair) === 'schema' || keyOf(pair) === 'versions');
     top.items = top.items.filter((pair) => keyOf(pair) !== 'versions');
     for (const pair of top.items) {
         const key = keyOf(pair);
         if (key === 'schema')
             renameKey(pair, 'properties');
-        // the standard's own block is migrate's to rewrite: its rows are the 5.0.0 core
+        if (key === 'collections') {
+            renameKey(pair, 'folders');
+            if (isScalar(pair.key) && pair.key.commentBefore === COLLECTIONS_GUIDANCE)
+                pair.key.commentBefore = YAML_GUIDANCE['folders'] ?? null;
+            if (isSeq(pair.value)) {
+                for (const folder of pair.value.items) {
+                    if (!isMap(folder) || folder.has('type'))
+                        continue;
+                    const map = folder;
+                    // the type sits beside the name, the way the seeds write it
+                    const at = map.items.findIndex((entry) => keyOf(entry) === 'name');
+                    map.items.splice(at === -1 ? 0 : at + 1, 0, document.createPair('type', 'collection'));
+                }
+            }
+        }
+        // the standard's own block is migrate's to rewrite: its rows are this version's core
         if ((key === 'schema' || key === 'properties') && isMap(pair.value)) {
             for (const entry of pair.value.items) {
                 if (keyOf(entry) === 'core' && isSeq(entry.value) && entry.value.items.length > 0) {
-                    entry.value = document.createNode(STANDARD_CORE.map(({ name, type, meaning }) => ({ name, type, meaning })));
+                    // one row per line, the flow style the seeds write the block in
+                    const rows = document.createNode(coreEntries(STANDARD_CORE));
+                    if (isSeq(rows)) {
+                        for (const row of rows.items)
+                            if (isMap(row))
+                                row.flow = true;
+                    }
+                    entry.value = rows;
                 }
             }
         }
@@ -115,7 +158,8 @@ export function migrateYamlDocument(text, version) {
             }
         }
     }
-    annotateYaml(document);
+    if (legacy)
+        annotateYaml(document);
     return document.toString({ lineWidth: 0 });
 }
 // What a 4.x document recorded under `versions`, in either form, for the move
@@ -210,6 +254,19 @@ export function migrateRoot(root, options) {
         if (held.includes(`${LEGACY_DIR}/`))
             act(`point .gitignore at ${FRAMEWORK_DIR}/`, () => writeFileSync(ignore, held.replace(new RegExp(`${LEGACY_DIR}/`, 'g'), `${FRAMEWORK_DIR}/`), 'utf8'));
     }
+    // 5.2.0: one line keeps every tool's personal file out of the repository,
+    // and this CLI's private .gitignore, which covered only its own, is retired.
+    const frameworkIgnore = path.join(live, '.gitignore');
+    if (!rootIgnoresLocal(root)) {
+        act(`add ${LOCAL_IGNORE_PATTERN} to ${FRAMEWORK_DIR}/.gitignore, the one line every tool's personal file needs`, () => {
+            const held = existsSync(frameworkIgnore) ? readFileSync(frameworkIgnore, 'utf8') : '# Eidos: me.md is personal and never shared.\nme.md\n';
+            writeFileSync(frameworkIgnore, `${held.replace(/\s*$/, '')}\n\n${LOCAL_IGNORE_NOTE}${LOCAL_IGNORE_PATTERN}\n`, 'utf8');
+        });
+    }
+    const ownIgnore = path.join(settingsDir(root), '.gitignore');
+    if (existsSync(ownIgnore) && readFileSync(ownIgnore, 'utf8').trim() === 'local.yaml') {
+        act(`remove ${rel(root, ownIgnore)}; the root's .gitignore covers it now`, () => rmSync(ownIgnore, { force: true }));
+    }
     const framework = parseFramework(next, found.format, root, path.join(dir, found.name));
     // The markdown form left the standard in 5.0.0: the same framework is written
     // as data, and the markdown document and each collection's index.md go.
@@ -218,6 +275,25 @@ export function migrateRoot(root, options) {
             convertToYaml(framework, false);
         });
     }
+    // 5.3.0: everything at the root is declared, and only the owner can say
+    // what an undeclared entry is or whether a declared one with nothing behind
+    // it should stay; each is a note, never a move.
+    const undeclared = undeclaredAtRoot(framework);
+    // on a dry run the framework folder may still be the old one
+    for (const entry of undeclared.folders.filter((name) => name !== LEGACY_DIR))
+        notes.push(`${entry}/ is at the root and no folder declares it; declare it (eidos configure:folder add ${entry} --type assets|other, or configure:collection add) or move it`);
+    for (const entry of undeclared.files)
+        notes.push(`${entry} is at the root and top_level does not list it; declare it (eidos configure:doc add) or move it`);
+    for (const folder of framework.folders) {
+        if (!existsSync(path.join(root, folder.name)))
+            notes.push(`${folder.name}/ is declared as ${isCollection(folder) ? 'a collection' : `an ${folder.type} folder`} but is not there; create it or remove the entry`);
+    }
+    for (const doc of framework.topLevel) {
+        if (/^[a-z][a-z0-9+.-]*:/i.test(doc.path))
+            continue;
+        if (!existsSync(path.resolve(dir, doc.path.split('#')[0] ?? '')))
+            notes.push(`top_level lists ${doc.title} at ${doc.path}, which is not there; write it or remove the entry`);
+    }
     for (const collection of framework.collections) {
         for (const file of markdownFiles(path.join(root, collection.name))) {
             const content = readFileSync(file, 'utf8');

package/dist/src/core/regions.js

@@ -0,0 +1,117 @@
+// Regions: the span inside a markdown file that a tool owns, fenced by two
+// HTML comments carrying its name (Eidos 5.1.0). `<!-- <tool>:<region> <args> -->`
+// opens one and `<!-- /<tool>:<region> -->` closes it, each alone on its line;
+// what sits between is the tool's, rewritten wholesale by it and read by
+// nothing else. The standard reads none of the contents: a check faults only
+// an opener with no closer, a heading or a link inside is not the person's,
+// and a renderer that does not know the tool shows the contents as they are.
+// A tool's identifier and a region's name: lowercase letters, digits, and hyphens.
+const NAME = '[a-z0-9][a-z0-9-]*';
+// Both closers HTML allows, `-->` and `--!>`, end a marker.
+const OPENER = new RegExp(`^<!--\\s*(${NAME}):(${NAME})(?:\\s+(.*?))?\\s*--!?>$`);
+const CLOSER = new RegExp(`^<!--\\s*/(${NAME}):(${NAME})\\s*--!?>$`);
+const FENCE = /^ {0,3}(`{3,}|~{3,})/;
+function parseArgs(text) {
+    const args = {};
+    for (const token of (text ?? '').split(/\s+/)) {
+        const eq = token.indexOf('=');
+        if (eq > 0)
+            args[token.slice(0, eq)] = token.slice(eq + 1);
+    }
+    return args;
+}
+// Every region in the text, in order. A marker inside a fenced code block
+// (three or more backticks or tildes, closed by the same) is text; a region
+// closes at the first closer naming its tool and region, and the lines
+// between are not read for markers, so another tool's marker there is content.
+export function parseRegions(text) {
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    const out = [];
+    let fence = null;
+    let index = 0;
+    while (index < lines.length) {
+        const line = (lines[index] ?? '').trim();
+        if (fence) {
+            const closing = FENCE.exec(lines[index] ?? '');
+            if (closing && closing[1] && closing[1][0] === fence.char && closing[1].length >= fence.length && (lines[index] ?? '').trim() === closing[1])
+                fence = null;
+            index += 1;
+            continue;
+        }
+        const opening = FENCE.exec(lines[index] ?? '');
+        if (opening && opening[1]) {
+            fence = { char: opening[1][0] ?? '`', length: opening[1].length };
+            index += 1;
+            continue;
+        }
+        const opener = OPENER.exec(line);
+        if (!opener || !opener[1] || !opener[2]) {
+            index += 1;
+            continue;
+        }
+        const region = { tool: opener[1], region: opener[2], args: parseArgs(opener[3]), open: index, close: null, contents: '' };
+        let end = index + 1;
+        while (end < lines.length) {
+            const closer = CLOSER.exec((lines[end] ?? '').trim());
+            if (closer && closer[1] === region.tool && closer[2] === region.region) {
+                region.close = end;
+                break;
+            }
+            end += 1;
+        }
+        region.contents = lines.slice(index + 1, region.close ?? lines.length).join('\n');
+        out.push(region);
+        index = (region.close ?? lines.length) + 1;
+    }
+    return out;
+}
+// The zero-based lines every region occupies, markers included; an unclosed
+// one runs to the end of the text.
+export function regionLines(text) {
+    const out = new Set();
+    const total = text.replace(/\r\n?/g, '\n').split('\n').length;
+    for (const region of parseRegions(text)) {
+        for (let line = region.open; line <= (region.close ?? total - 1); line += 1)
+            out.add(line);
+    }
+    return out;
+}
+// The text with every region's lines blanked, line count kept, so what the
+// standard does read (headings, links, prose) is only the person's.
+export function stripRegions(text) {
+    const inside = regionLines(text);
+    if (inside.size === 0)
+        return text;
+    return text
+        .replace(/\r\n?/g, '\n')
+        .split('\n')
+        .map((line, index) => (inside.has(index) ? '' : line))
+        .join('\n');
+}
+function escapeHtml(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+// The text with each region replaced by one HTML block that shows its
+// contents as they are: a `<pre>` carrying the tool and region name, which a
+// markdown renderer passes through whole (an HTML block that opens with
+// `<pre` runs to `</pre>`, blank lines included), so nothing inside is
+// rendered as markdown. A renderer that knows the tool draws its own view.
+export function regionsAsHtml(text) {
+    const regions = parseRegions(text);
+    if (regions.length === 0)
+        return text;
+    const lines = text.replace(/\r\n?/g, '\n').split('\n');
+    const out = [];
+    let index = 0;
+    for (const region of regions) {
+        out.push(...lines.slice(index, region.open));
+        const args = Object.entries(region.args)
+            .map(([key, value]) => `${key}=${value}`)
+            .join(' ');
+        const attributes = [`data-tool="${escapeHtml(region.tool)}"`, `data-region="${escapeHtml(region.region)}"`, args !== '' ? `data-args="${escapeHtml(args)}"` : '', region.close === null ? 'data-unclosed=""' : ''].filter((attribute) => attribute !== '');
+        out.push('', `<pre class="region" ${attributes.join(' ')}>${escapeHtml(region.contents)}</pre>`, '');
+        index = (region.close ?? lines.length) + 1;
+    }
+    out.push(...lines.slice(index));
+    return out.join('\n');
+}

package/dist/src/core/scaffold.js

@@ -1,10 +1,12 @@
-// Scaffolding one blueprint: frontmatter generated from the properties that
-// apply to its collection, body rendered from its variant's shape, filename in
-// the framework's convention with a permanent kebab-case id inside. Born
+// Scaffolding one blueprint: frontmatter generated from the required
+// properties that apply to its collection plus any optional one given a
+// value, body rendered from its variant's template, filename in the
+// framework's convention with a permanent kebab-case id inside. Born
 // conforming; the prose is still the owner's.
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { blueprintId } from './blueprint.js';
+import { optionProblem } from './check.js';
 import { defaultVariant, findCollection, findVariant, propertiesFor } from './framework.js';
 import { convert, kebab } from './naming.js';
 import { loadTemplate } from './template.js';
@@ -15,7 +17,8 @@ export class ScaffoldError extends Error {
         this.name = 'ScaffoldError';
     }
 }
-function coerce(type, raw) {
+// A value typed on a command line, as the property's declared type holds it.
+export function coerce(type, raw) {
     switch (type.toLowerCase()) {
         case 'list':
             return raw
@@ -84,20 +87,23 @@ export function scaffoldBlueprint(framework, existing, options) {
         title,
         summary: options.summary ?? '',
         variant: variant.name,
-        status: 'Draft',
         date_created: options.date,
         date_modified: options.date,
     };
     if (group !== null && collection.grouping?.property) {
         values[collection.grouping.property] = group;
     }
-    const types = new Map(propertiesFor(framework, collection.name).map((property) => [property.name, property.type]));
+    const declared = new Map(propertiesFor(framework, collection.name).map((property) => [property.name, property]));
+    const types = new Map([...declared].map(([name, property]) => [name, property.type]));
     for (const [key, raw] of Object.entries(options.set)) {
-        const type = types.get(key);
-        if (type === undefined) {
+        const property = declared.get(key);
+        if (property === undefined) {
             notes.push(`property '${key}' is not in the Properties table for ${collection.name}; written anyway`);
         }
-        values[key] = coerce(type ?? 'Text', raw);
+        values[key] = coerce(property?.type ?? 'Text', raw);
+        const offList = property ? optionProblem(property, values[key]) : null;
+        if (offList)
+            notes.push(`'${key}: ${offList.off.join(', ')}' is not one of its options (${offList.options.join(', ')}); written anyway, and check reports it`);
     }
     let content = blankBlueprint(framework, collection.name, values, shape.text, title);
     const extra = Object.keys(options.set).filter((key) => !types.has(key));

package/dist/src/core/seed.js

@@ -1,7 +1,8 @@
 // Installing a seed: copy a starting framework into a new root's `.eidos/`,
-// set the naming convention, the starting groups, and the collection names in
-// its Framework.yaml (the seed's own comments kept), scaffold a folder per
-// collection, and drop one blank blueprint per framing variant.
+// set the naming convention, the starting groups, and the folder names in
+// its Framework.yaml (the seed's own comments kept), scaffold every declared
+// folder (a collection's with its groups, an assets folder empty), and drop
+// one blank blueprint per framing variant.
 // It writes no prose: the README's one-liner, each group's description, and
 // every scaffolded blueprint's summary and body stay the owner's.
 import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
@@ -12,7 +13,7 @@ import { buildIndexes } from './index-leaf.js';
 import { listBlueprints } from './blueprint.js';
 import { convert, kebab, titleize } from './naming.js';
 import { renderTemplate } from './template.js';
-import { TOOL_KEY } from './framework-model.js';
+import { isCollection, TOOL_KEY } from './framework-model.js';
 import { DEFAULT_CANVAS_HINTS } from './canvas.js';
 import { isMap, isScalar, isSeq, parseDocument } from 'yaml';
 const GITIGNORE_SHIPPED = '_gitignore';
@@ -76,13 +77,16 @@ class Writer {
 }
 const mapsIn = (value) => (isSeq(value) ? value.items.filter((item) => isMap(item)) : []);
 const nameOf = (map) => String(map.get('name') ?? '');
-// The seed's collections and the properties scoped to them, renamed into the
-// root's convention; every other key, and every comment, stays as the seed wrote it.
-function renameCollections(document, renames) {
-    for (const collection of mapsIn(document.get('collections'))) {
-        const to = renames.get(nameOf(collection));
+// The `folders` list as the seed wrote it (`collections` in a seed older than 5.3.0).
+const foldersOf = (document) => document.get('folders') ?? document.get('collections');
+// The seed's folders and the properties scoped to its collections, renamed
+// into the root's convention; every other key, and every comment, stays as
+// the seed wrote it.
+function renameFolders(document, renames) {
+    for (const folder of mapsIn(foldersOf(document))) {
+        const to = renames.get(nameOf(folder));
         if (to !== undefined)
-            collection.set('name', to);
+            folder.set('name', to);
     }
     const properties = document.get('properties');
     if (!isMap(properties))
@@ -123,16 +127,26 @@ function renameInText(text, from, to) {
     const escaped = from.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     return text.replace(new RegExp(`(?<![\\w-])${escaped}(?!\\w)`, 'g'), to);
 }
-// A blank blueprint: every property that applies to the collection, with the
-// values given and `[]` for an empty list, then the variant's template as the body.
+// A value worth writing: anything but nothing, an empty string, or an empty list.
+function hasValue(value) {
+    return value !== undefined && value !== null && value !== '' && !(Array.isArray(value) && value.length === 0);
+}
+// A blank blueprint: every required property that applies to the collection
+// (with the value given, else blank, `[]` for a list), every optional one
+// that was given a value, then the variant's template as the body. An
+// optional property left out is not a gap, so the file carries nothing it
+// doesn't need.
 export function blankBlueprint(framework, collectionName, values, shapeTemplate, title) {
-    const entries = propertiesFor(framework, collectionName).map((property) => {
+    const entries = [];
+    for (const property of propertiesFor(framework, collectionName)) {
         const value = values[property.name];
-        if ((value === undefined || value === null || value === '') && property.type.toLowerCase() === 'list') {
-            return [property.name, []];
+        if (hasValue(value)) {
+            entries.push([property.name, value]);
+        }
+        else if (property.required) {
+            entries.push([property.name, property.type.toLowerCase() === 'list' ? [] : '']);
         }
-        return [property.name, value ?? ''];
-    });
+    }
     return formatFrontmatter(entries) + '\n' + renderTemplate(shapeTemplate, title);
 }
 export function installSeed(options) {
@@ -178,9 +192,9 @@ export function installSeed(options) {
     //    convention, edited in place so the seed's comments travel with it.
     document.set('naming', naming);
     for (const collection of leftOut) {
-        const collections = document.get('collections');
-        if (isSeq(collections))
-            collections.items = collections.items.filter((item) => !(isMap(item) && nameOf(item) === collection.name));
+        const folders = foldersOf(document);
+        if (isSeq(folders))
+            folders.items = folders.items.filter((item) => !(isMap(item) && nameOf(item) === collection.name));
         for (const variant of collection.variants)
             writer.remove(path.join(root, '.eidos', variant.template));
     }
@@ -189,7 +203,7 @@ export function installSeed(options) {
         if (!grouped || !grouped.grouping) {
             throw new InstallError(`no collection in '${options.seed}' declares a grouping`);
         }
-        const groupedNode = mapsIn(document.get('collections')).find((collection) => nameOf(collection) === grouped.name);
+        const groupedNode = mapsIn(foldersOf(document)).find((collection) => nameOf(collection) === grouped.name);
         const grouping = groupedNode?.get('grouping');
         if (!isMap(grouping)) {
             throw new InstallError(`${frameworkSrc}: ${grouped.name} declares a grouping the document does not carry`);
@@ -226,6 +240,8 @@ export function installSeed(options) {
         }
         docs.push({ target, body });
     }
+    // Every declared folder takes the naming convention, a collection and an
+    // assets folder alike; the files inside an assets folder keep their names.
     const folders = new Map();
     const renames = new Map();
     if (readme !== null && leftOut.length > 0) {
@@ -234,21 +250,27 @@ export function installSeed(options) {
             .filter((line) => !leftOut.some((collection) => line.includes(`[${collection.name}]`)))
             .join('\n');
     }
-    for (const collection of installing) {
-        const folder = convert(collection.name, naming);
-        folders.set(collection.name, folder);
-        if (folder !== collection.name) {
-            renames.set(collection.name, folder);
+    const plain = seedFramework.folders.filter((folder) => !isCollection(folder));
+    for (const declared of [...installing, ...plain]) {
+        // a seed writes a collection's name in Title Case and its assets folder in
+        // lowercase; the convention is applied to the title-cased word either way
+        const folder = convert(titleize(declared.name), naming);
+        folders.set(declared.name, folder);
+        if (folder !== declared.name) {
+            renames.set(declared.name, folder);
             if (readme !== null) {
-                readme = renameInText(readme, collection.name, folder);
+                readme = renameInText(readme, declared.name, folder);
             }
         }
     }
-    renameCollections(document, renames);
+    renameFolders(document, renames);
     applyDefaultCanvasHints(document);
     let serialized = document.toString({ lineWidth: 0 });
+    // comments name the collections too, so the word follows; an assets folder's
+    // name is also a type (`type: assets`), so only its entry is renamed
     for (const [from, to] of renames) {
-        serialized = renameInText(serialized, from, to);
+        if (installing.some((collection) => collection.name === from))
+            serialized = renameInText(serialized, from, to);
     }
     const frameworkFile = path.join(root, '.eidos', 'Framework.yaml');
     writer.write(frameworkFile, serialized);
@@ -259,9 +281,12 @@ export function installSeed(options) {
     for (const doc of docs) {
         writer.write(path.join(root, doc.target), doc.body);
     }
-    // 3. a folder per collection; blank blueprints for the framing one.
+    // 3. a folder per declared folder; blank blueprints for the framing collection.
     const scaffolded = [];
     const groupsInConvention = options.groups.map((group) => convert(group, naming));
+    for (const folder of plain) {
+        writer.mkdir(path.join(root, folders.get(folder.name) ?? folder.name));
+    }
     for (const collection of installing) {
         const folderName = folders.get(collection.name) ?? collection.name;
         const folder = path.join(root, folderName);
@@ -285,7 +310,6 @@ export function installSeed(options) {
                 id: kebab(variant.name),
                 title,
                 variant: variant.name,
-                status: 'Draft',
                 date_created: options.date,
                 date_modified: options.date,
             };
@@ -306,6 +330,7 @@ export function installSeed(options) {
         naming,
         frameworkFile,
         collections: installing.map((collection) => folders.get(collection.name) ?? collection.name),
+        folders: plain.map((folder) => folders.get(folder.name) ?? folder.name),
         groupedCollection: grouped ? (folders.get(grouped.name) ?? grouped.name) : null,
         groups: groupsInConvention,
         scaffolded,