@loomcli/core 0.6.0 → 0.7.0

package/dist/plugin.d.ts

@@ -114,8 +114,8 @@ interface PluginDefinition<Options extends PluginOptions = PluginOptions, Theme
  * One plugin: an identity and the contributions it carries. Creating and installing the value runs
  * none of its code: `onCommandAttach` runs at graph build, `onFailure` runs when `run()` renders a
  * failure, and the middleware runs inside an invocation, so an installed plugin an invocation never
- * reaches costs that invocation its hooks alone. Every rule
- * that one definition carries on its own throws here, before the value exists.
+ * reaches costs that invocation its hooks alone. The definition is read once, after the identity,
+ * and every rule that one definition carries on its own throws here, before the value exists.
  */
 declare function plugin<Options extends PluginOptions = {}, const Theme extends ThemeMapping = {}>(identity: string, definition: PluginDefinition<Options, Theme>): Plugin<NoInfer<Options>, NoInfer<Theme>>;
 /** How every plugin diagnostic names one plugin at the start of a sentence. */
@@ -130,9 +130,9 @@ interface InstalledPlugins {
 /**
  * The installed list in composition order, with every rule that reads two plugins together: an
  * identity installed twice, a second claim on the theme slot, the signals slot, or the
- * configuration source, and two distinct descriptors under one identity. The slot is read
- * defensively, because a JavaScript author reaches it with any value. Each plugin's own rules
- * already ran at its `plugin()` call.
+ * configuration source, and two distinct descriptors under one identity. The slot is the copy the
+ * Application's constructor took, which a JavaScript author fills with any value. Each plugin's own
+ * rules already ran at its `plugin()` call.
  */
 declare function installPlugins(application: string, plugins: unknown): InstalledPlugins;
 /**
@@ -164,7 +164,7 @@ interface BuiltPlugin {
     onCommandAttach: CommandAttachHook | undefined;
     /** The hook core calls for each failure `run()` renders after graph build, or nothing. */
     onFailure: FailureHook | undefined;
-    /** The plugin's own `views` slot, read once the validated theme is in place. */
+    /** The copy of the plugin's own `views` list, which the Application reads again. */
     views: unknown;
     /** The translations the plugin registers, which resolve after the application's. */
     translators: TranslationContributor;

package/dist/plugin.js

@@ -1,4 +1,5 @@
 import { checkEnvBinding, claimVariables } from './bindings.js';
+import { captureDeclaration, elidedRead, unreadableArgument, unreadableFault } from './capture.js';
 import { notACommand } from './command-rules.js';
 import { attach, commandCode, commandNode } from './command.js';
 import { elided, quoteString, spelled } from './diagnostic-text.js';
@@ -9,14 +10,16 @@ import { boundOptions, pluginSites } from './globals.js';
 import { checkIdentity } from './identity.js';
 import { coreViews } from './lanes.js';
 import { booleanValue, compileOptions } from './options.js';
-import { isPlainObject } from './plain.js';
+import { copyOwnKeys, decidePlain, declaring, isPlainObject, shallowList, shallowRecord, } from './plain.js';
 import { foreignValue, middlewareActivation, notAFunction, notAList, notAnObject, pluginInstalledTwice, pluginOptionRule, signalClaimedTwice, slotTaken, sourceBinding, sourceBoundOwnOption, unknownSignal, } from './plugin-rules.js';
 import { pluginLoaderFailed } from './rules.js';
 import { isProcessSignal } from './signals.js';
 import { buildTheme } from './theme.js';
 import { readTranslations } from './translators.js';
-import { captureConfig, checkDeclarations } from './validation.js';
+import { captureConfig, checkDeclarations, defaultDepthFault } from './validation.js';
 import { buildViews, viewIdentities } from './view.js';
+/** The slots of a definition that hold a list, each copied with its entries as they were built. */
+const definitionLists = ['extensions', 'signals', 'commands', 'views', 'translators'];
 /** Authored values register here, so the public type publishes no state to reach or replace. */
 const nodes = new WeakMap();
 /**
@@ -34,17 +37,47 @@ class PluginDeclaration {
  * One plugin: an identity and the contributions it carries. Creating and installing the value runs
  * none of its code: `onCommandAttach` runs at graph build, `onFailure` runs when `run()` renders a
  * failure, and the middleware runs inside an invocation, so an installed plugin an invocation never
- * reaches costs that invocation its hooks alone. Every rule
- * that one definition carries on its own throws here, before the value exists.
+ * reaches costs that invocation its hooks alone. The definition is read once, after the identity,
+ * and every rule that one definition carries on its own throws here, before the value exists.
  */
 function plugin(identity, definition) {
-    const captured = {
-        ...definition,
-        ...(definition?.theme === undefined
-            ? {}
-            : { theme: isPlainObject(definition.theme) ? { ...definition.theme } : definition.theme }),
-    };
-    return new PluginDeclaration(readPlugin(identity, isPlainObject(definition) ? captured : definition));
+    return new PluginDeclaration(declaring(() => readPlugin(identity, definition)));
+}
+/**
+ * The one copy of a definition that `plugin()` reads: the definition, its theme mapping, options
+ * record, middleware with its activation list, and source, and each list it holds. An entry of a
+ * list is what its factory built and is not copied, and each option's config is captured where its
+ * own rules read it, so a fault about it names the option. A read that throws is the unreadable
+ * fault of the definition, and a definition that is not a plain object is the not-an-object fault.
+ */
+function captureDefinition(identity, definition) {
+    return captureDeclaration(definition, (copy, read) => {
+        read.nested(copy, 'theme', shallowRecord);
+        read.nested(copy, 'options', shallowRecord);
+        read.nested(copy, 'middleware', copyMiddleware);
+        read.nested(copy, 'source', shallowRecord);
+        for (const list of definitionLists) {
+            read.nested(copy, list, shallowList);
+        }
+    }, {
+        notAnObject: () => new DeclarationError(notAnObject, {
+            correction: 'Supply { options, middleware, extensions, views }.',
+            findings: [{ arguments: [identity, definition], call: 'plugin', mark: '1' }],
+            sentence: `${pluginSentence(identity)} declares a definition that is not an object.`,
+        }),
+        unreadable: unreadableArgument({ call: 'plugin', named: identity, subject: pluginSentence(identity) }, 'definition'),
+    });
+}
+/** A middleware object's copy, its activation list copied too, or any other value as declared. */
+function copyMiddleware(middleware) {
+    if (!decidePlain(middleware)) {
+        return middleware;
+    }
+    const copy = copyOwnKeys(middleware);
+    if (Object.hasOwn(copy, 'activate')) {
+        copy.activate = shallowList(copy.activate);
+    }
+    return copy;
 }
 /** How every plugin diagnostic names one plugin at the start of a sentence. */
 function pluginSentence(identity) {
@@ -71,17 +104,6 @@ function entryCode(value) {
     const node = nodeOf(value);
     return node ? spelled(`plugin(${quoteString(node.identity)}, ${elided})`) : value;
 }
-/** The declarations one plugin value carries, which a JavaScript author reaches as any value. */
-function definitionOf(identity, definition) {
-    if (!isPlainObject(definition)) {
-        throw new DeclarationError(notAnObject, {
-            correction: 'Supply { options, middleware, extensions, views }.',
-            findings: [{ arguments: [identity, definition], call: 'plugin', mark: '1' }],
-            sentence: `${pluginSentence(identity)} declares a definition that is not an object.`,
-        });
-    }
-    return definition;
-}
 /** How a second claim on one slot reads: its clause, the note on the owner's entry, and the fix. */
 const slotWords = {
     signals: {
@@ -116,9 +138,9 @@ function slotFault(site, slot, claim) {
 /**
  * The installed list in composition order, with every rule that reads two plugins together: an
  * identity installed twice, a second claim on the theme slot, the signals slot, or the
- * configuration source, and two distinct descriptors under one identity. The slot is read
- * defensively, because a JavaScript author reaches it with any value. Each plugin's own rules
- * already ran at its `plugin()` call.
+ * configuration source, and two distinct descriptors under one identity. The slot is the copy the
+ * Application's constructor took, which a JavaScript author fills with any value. Each plugin's own
+ * rules already ran at its `plugin()` call.
  */
 function installPlugins(application, plugins) {
     const printed = Array.isArray(plugins) ? Array.from(plugins, entryCode) : plugins;
@@ -188,16 +210,32 @@ function installPlugins(application, plugins) {
 }
 /** The keys a plugin option may not declare, in the order its diagnostic names them. */
 const forbidden = ['validate', 'validateOmitted', 'required'];
-/** The rules a plugin option answers before every rule an ordinary declaration carries. */
-function checkPluginOption(site, config) {
-    const sentence = site.subject;
-    if (!isPlainObject(config)) {
-        throw new DeclarationError(notAnObject, {
+/**
+ * The rules a plugin option answers before every rule an ordinary declaration carries, read from
+ * the one copy of its config that `captureConfig` takes, which it answers with for every later read.
+ * `siteOf` places the option with the value its entry prints as: the config as declared for a value
+ * that is not one, elided for a config whose read threw, and the copy for every later rule.
+ */
+function checkPluginOption(siteOf, declared) {
+    const sentence = siteOf(declared).subject;
+    const config = captureConfig(declared, {
+        notAnObject: () => new DeclarationError(notAnObject, {
             correction: 'Supply { type, ... }.',
-            findings: [partFinding(site, [])],
+            findings: [partFinding(siteOf(declared), [])],
             sentence: `${sentence} is not an option declaration.`,
-        });
-    }
+        }),
+        // The default's walk stopped at the limit, so the finding prints it elided.
+        tooDeep: () => {
+            const { keys, shown } = elidedRead('default');
+            return defaultDepthFault(sentence, [partFinding(siteOf(shown), keys)]);
+        },
+        // A part whose read threw is never read again, so the finding prints it elided.
+        unreadable: (thrown, slot) => {
+            const { keys, shown } = elidedRead(slot);
+            return unreadableFault({ declared: 'config', findings: [partFinding(siteOf(shown), keys)], subject: sentence }, thrown);
+        },
+    });
+    const site = siteOf(config);
     const rejected = forbidden.find((key) => key in config);
     if (rejected !== undefined) {
         throw factFault(pluginOptionRule, site, {
@@ -209,6 +247,7 @@ function checkPluginOption(site, config) {
     checkDescription(site, config.description);
     checkHidden(site, config.hidden);
     checkDeprecated(site, config.deprecated);
+    return config;
 }
 /**
  * One plugin's option declarations, in declaration order. They join the globals table, so the rules
@@ -223,12 +262,23 @@ function readOptions(identity, declared, build) {
         });
     }
     const inputs = [];
-    for (const [name, config] of Object.entries(declared ?? {})) {
+    // A finding prints each option's captured config once it is taken, and each later one elided.
+    const shown = Object.fromEntries(Object.keys(declared ?? {}).map((name) => [name, spelled(elided)]));
+    for (const [name, entry] of Object.entries(declared ?? {})) {
         const sentence = `${pluginSentence(identity)} option ${quoted(name)}`;
-        const site = pluginOptionSite({ identity, options: declared }, name, sentence);
-        checkPluginOption(site, config);
+        // A computed key defines its own property even for `__proto__`, where assignment would not.
+        const siteOf = (value) => pluginOptionSite({ identity, options: { ...shown, [name]: value } }, name, sentence);
+        const config = checkPluginOption(siteOf, entry);
+        // Defining the key keeps its place, and holds even for a key of `__proto__`.
+        Object.defineProperty(shown, name, {
+            configurable: true,
+            enumerable: true,
+            value: config,
+            writable: true,
+        });
+        const site = siteOf(config);
         checkEnvBinding(site, config);
-        const input = { config: captureConfig(config), kind: 'option', name };
+        const input = { config, kind: 'option', name };
         // The shared rules name the plugin and the option, so a fault reads with its contributor.
         checkDeclarations([{ input, site }], sentence);
         build.records.set(input, buildExtensions({
@@ -247,7 +297,7 @@ function readOptions(identity, declared, build) {
     const siteOf = pluginSites(identity, inputs);
     compileOptions(inputs, { siteOf, subject: `plugin ${quoted(identity)}` });
     claimVariables(boundOptions(inputs, (input) => ({
-        phrase: `plugin ${quoted(identity)} option "${input.name}"`,
+        phrase: `plugin ${quoted(identity)} option ${quoted(input.name)}`,
         site: siteOf(input),
     })));
     return inputs;
@@ -532,7 +582,8 @@ function readSource(identity, declaration, own) {
     }
     const carrier = own.inputs.find((input) => Object.hasOwn(own.build.records.get(input) ?? {}, bindingIdentity));
     if (carrier) {
-        const option = pluginOptionSite({ identity, options: declaration.options }, carrier.name, `${sentence} option ${quoted(carrier.name)}`);
+        // The record prints each option's captured config, which is what its rules read.
+        const option = pluginSites(identity, own.inputs)(carrier);
         throw new DeclarationError(sourceBoundOwnOption, {
             correction: "Remove the value; the source's own options resolve before it loads.",
             findings: [partFinding(option, ['extensions'])],
@@ -552,7 +603,8 @@ function defineExtensions(identity, declaration, build) {
             sentence: `${pluginSentence(identity)} declares extensions that are not an array.`,
         });
     }
-    for (const [index, descriptor] of (extensions ?? []).entries()) {
+    const list = Array.isArray(extensions) ? extensions : [];
+    for (const [index, descriptor] of list.entries()) {
         if (!isDescriptor(descriptor)) {
             throw new DeclarationError(foreignValue, {
                 correction: 'Supply the value returned by extension(identity, config).',
@@ -567,14 +619,15 @@ function defineExtensions(identity, declaration, build) {
     }
 }
 /**
- * Every rule one definition carries on its own, in the order the definition's slots are read. The
- * plugin's own extensions register before any declaration carries a value, so a duplicated package
- * copy is reported from the list that defines it. The views list is read against core's view
- * identities, and the Application reads it again against every other contributor's.
+ * Every rule one definition carries on its own, in the order the definition's slots are read, each
+ * from the one copy `captureDefinition` takes once the identity is judged. The plugin's own
+ * extensions register before any declaration carries a value, so a duplicated package copy is
+ * reported from the list that defines it. The views list is read against core's view identities,
+ * and the Application reads the same copy again against every other contributor's.
  */
 function readPlugin(named, definition) {
     checkIdentity('plugin', named);
-    const declaration = definitionOf(named, definition);
+    const declaration = captureDefinition(named, definition);
     const theme = declaration.theme === undefined ? undefined : buildTheme(declaration.theme, named);
     const build = { descriptors: new Map(), records: new Map() };
     defineExtensions(named, declaration, build);

package/dist/sources.js

@@ -1,4 +1,4 @@
-import { asSentence, foreignFailure, InternalError, LoomError, reasonOf } from './errors.js';
+import { asSentence, foreignFailure, InternalError, LoomError, quoted, reasonOf, } from './errors.js';
 import { isProseLine } from './facts.js';
 import { isSupplied } from './options.js';
 import { isPlainObject } from './plain.js';
@@ -100,12 +100,12 @@ function readAnswer(sentence, input, answer) {
     const shape = isPlainObject(answer) ? answer : undefined;
     const label = shape?.label;
     if (!shape || !isProseLine(label)) {
-        throw ruleFault(`${sentence} answered option "${input.name}" with an answer that is not { value, label }.`);
+        throw ruleFault(`${sentence} answered option ${quoted(input.name)} with an answer that is not { value, label }.`);
     }
     const kind = rawKind(input);
     const value = rawValue(kind, shape.value);
     if (value === undefined) {
-        throw ruleFault(`${sentence} answered option "${input.name}" with a value that is not ${owed[kind]}.`);
+        throw ruleFault(`${sentence} answered option ${quoted(input.name)} with a value that is not ${owed[kind]}.`);
     }
     return { label, value };
 }
@@ -121,7 +121,7 @@ function readAnswers(sentence, answers, requested) {
     return Object.entries(answers).map(([name, answer]) => {
         const target = byName.get(name);
         if (!target) {
-            throw ruleFault(`${sentence} answered option "${name}", which core did not request.`);
+            throw ruleFault(`${sentence} answered option ${quoted(name)}, which core did not request.`);
         }
         const { label, value } = readAnswer(sentence, target.input, answer);
         return { label, target, value };

package/dist/style-layout.js

@@ -1,4 +1,4 @@
-import { graphemeWidths } from '@rockorager/uucode/width';
+import { graphemeWidths } from './style-width.js';
 const offsets = [0, 1, 2, 3, 4, 5, 6, 7];
 const empty = {
     advance: offsets.map(() => 0),
@@ -117,6 +117,7 @@ function padBlock(block, padding, attributes) {
     if (!block.tabs && block.minimum >= padding.width) {
         return block;
     }
+    const space = (count) => leaf({ attributes, kind: 'text', text: ' '.repeat(count) }, count);
     const lines = block.lines.map((line, index) => {
         // A terminal newline has no extra line to align; interior blank lines do.
         if (index > 0 && index === block.lines.length - 1 && !line.content.text) {
@@ -134,7 +135,6 @@ function padBlock(block, padding, attributes) {
         else if (padding.align === 'center') {
             before = Math.floor(missing / 2);
         }
-        const space = (count) => leaf({ attributes, kind: 'text', text: ' '.repeat(count) }, count);
         // Re-segment inserted spaces too: a trailing Unicode Prepend character can absorb one.
         const spaced = join([space(before), content, space(missing - before)]);
         const row = measured([{ content: spaced, ending: [] }]);

package/dist/style-width.d.ts

@@ -0,0 +1,13 @@
+/** One grapheme cluster of a string: where it starts and ends, and the columns it occupies. */
+interface GraphemeWidth {
+    start: number;
+    end: number;
+    width: number;
+}
+/**
+ * Each grapheme cluster of a string with the terminal columns it occupies. Printable ASCII that no
+ * non-ASCII character follows is its own one-column cluster. Any other run of clusters is read by
+ * one cursor, which starts at the run and carries the break state from cluster to cluster.
+ */
+export declare function graphemeWidths(text: string): Generator<GraphemeWidth>;
+export {};

package/dist/style-width.js

@@ -0,0 +1,170 @@
+/*!
+Ported from the grapheme width iterator of @rockorager/uucode 2.2.1, src/width.ts.
+Copyright (c) 2026 Tim Culverhouse. Licensed under the MIT License,
+in licenses/uucode-LICENSE.md of @loomcli/core.
+*/
+import { graphemeTable, widthTable } from './unicode.generated.js';
+/** The break state after a regional indicator, which pairs with the next one into a flag. */
+const regionalIndicatorState = 1;
+/** The break state inside an extended pictographic sequence, which a ZWJ continues. */
+const pictographicState = 2;
+// The table members, read once, so each lookup indexes the arrays directly.
+const { stage1, stage1Shift, stage2, stage2Mask, stage3, widthMask, zeroWidthFlag, emojiVSFlag } = widthTable;
+const { breakTable, graphemeBreakPropertyCount } = graphemeTable;
+/** A code point's packed row: its grapheme break property, width, and emoji flags. */
+function lookup(codePoint) {
+    const offset = stage1[codePoint >> stage1Shift] ?? 0;
+    return stage3[stage2[offset + (codePoint & stage2Mask)] ?? 0] ?? 0;
+}
+/** The row an empty string starts from: the Other break property at width one. */
+const defaultRow = 1 << 5;
+const graphemeBreak = (row) => row & 0x1f;
+const rowWidth = (row) => (row >> 5) & widthMask;
+const zeroInGrapheme = (row) => ((row >> 5) & zeroWidthFlag) !== 0;
+const emojiSelectorBase = (row) => ((row >> 8) & emojiVSFlag) !== 0;
+/** The next break state shifted left once, with whether a cluster boundary falls between. */
+function transition(before, after, state) {
+    const count = graphemeBreakPropertyCount;
+    return breakTable[(state * count + before) * count + after] ?? 0;
+}
+/** A cursor at the start of a run, with the run's first code point read ahead. */
+function cursor(text, start) {
+    const hasNext = start < text.length;
+    const codePoint = hasNext ? (text.codePointAt(start) ?? 0) : 0;
+    return {
+        codePoint: 0,
+        hasNext,
+        index: start,
+        isBreak: false,
+        nextCodePoint: codePoint,
+        nextIndex: hasNext ? start + (codePoint > 0xff_ff ? 2 : 1) : start,
+        nextRow: hasNext ? lookup(codePoint) : defaultRow,
+        row: defaultRow,
+        state: 0,
+        text,
+    };
+}
+/** Moves to the next code point and reads whether a cluster boundary follows it. */
+function advance(at) {
+    if (!at.hasNext) {
+        return false;
+    }
+    at.codePoint = at.nextCodePoint;
+    at.row = at.nextRow;
+    const index = at.nextIndex;
+    at.index = index;
+    if (index >= at.text.length) {
+        at.hasNext = false;
+        at.isBreak = true;
+        return true;
+    }
+    const first = at.text.charCodeAt(index);
+    let codePoint = first;
+    let nextIndex = index + 1;
+    if (first >= 0xd8_00 && first <= 0xdb_ff && nextIndex < at.text.length) {
+        const second = at.text.charCodeAt(nextIndex);
+        if (second >= 0xdc_00 && second <= 0xdf_ff) {
+            codePoint = ((first - 0xd8_00) << 10) + second - 0xdc_00 + 0x1_00_00;
+            nextIndex += 1;
+        }
+    }
+    const row = lookup(codePoint);
+    const packed = transition(graphemeBreak(at.row), graphemeBreak(row), at.state);
+    at.state = packed >> 1;
+    at.nextCodePoint = codePoint;
+    at.nextIndex = nextIndex;
+    at.nextRow = row;
+    at.isBreak = (packed & 1) !== 0;
+    return true;
+}
+/** The width of the next grapheme cluster, leaving the cursor at its end. */
+function clusterWidth(at) {
+    if (!advance(at)) {
+        return 0;
+    }
+    const standalone = rowWidth(at.row);
+    if (at.isBreak) {
+        return standalone;
+    }
+    let width = zeroInGrapheme(at.row) ? 0 : standalone;
+    let previousRow = at.row;
+    let previousState = at.state;
+    for (;;) {
+        if (!advance(at)) {
+            break;
+        }
+        switch (at.codePoint) {
+            case 0xfe_0f: {
+                if (emojiSelectorBase(previousRow)) {
+                    width = 2;
+                }
+                break;
+            }
+            case 0xfe_0e: {
+                if (emojiSelectorBase(previousRow)) {
+                    width = 1;
+                }
+                break;
+            }
+            case 0x20_0d: {
+                if (previousState === pictographicState && !at.isBreak) {
+                    if (!advance(at) || at.isBreak) {
+                        return width;
+                    }
+                    previousRow = at.row;
+                    previousState = at.state;
+                    continue;
+                }
+                break;
+            }
+            case 0x1_f3_fb:
+            case 0x1_f3_fc:
+            case 0x1_f3_fd:
+            case 0x1_f3_fe:
+            case 0x1_f3_ff: {
+                width = 2;
+                break;
+            }
+            default: {
+                if (previousState === regionalIndicatorState) {
+                    width = 2;
+                }
+                else if (!zeroInGrapheme(at.row)) {
+                    width += rowWidth(at.row);
+                }
+            }
+        }
+        if (at.isBreak) {
+            break;
+        }
+        previousRow = at.row;
+        previousState = at.state;
+    }
+    return width;
+}
+/** Whether the character at an index is printable ASCII that no non-ASCII character follows. */
+function asciiAlone(text, index) {
+    const code = text.charCodeAt(index);
+    return (code >= 0x20 && code < 0x7f && (index + 1 >= text.length || text.charCodeAt(index + 1) < 0x80));
+}
+/**
+ * Each grapheme cluster of a string with the terminal columns it occupies. Printable ASCII that no
+ * non-ASCII character follows is its own one-column cluster. Any other run of clusters is read by
+ * one cursor, which starts at the run and carries the break state from cluster to cluster.
+ */
+export function* graphemeWidths(text) {
+    let start = 0;
+    while (start < text.length) {
+        if (asciiAlone(text, start)) {
+            yield { end: start + 1, start, width: 1 };
+            start += 1;
+            continue;
+        }
+        const at = cursor(text, start);
+        do {
+            const width = clusterWidth(at);
+            yield { end: at.index, start, width };
+            start = at.index;
+        } while (start < text.length && !asciiAlone(text, start));
+    }
+}

package/dist/types.d.ts

@@ -185,7 +185,7 @@ export interface ViewContext {
 export interface View<Data> {
     render: (data: Readonly<Data>, context: ViewContext) => string;
     /** A view has one shape; the row view of Results is the other. */
-    row?: never;
+    row?: undefined;
 }
 /**
  * A row view renders a sequence one row at a time.
@@ -197,7 +197,7 @@ export interface RowView<Row> {
     head?: (context: ViewContext) => string;
     tail?: (count: number, context: ViewContext) => string;
     /** A row view has one shape; the whole view of Rendered output is the other. */
-    render?: never;
+    render?: undefined;
 }
 /** The views record of a value result: every entry renders the whole value. */
 export type ResultViews<Value> = Readonly<Record<string, View<Value>>>;

package/dist/unicode.generated.d.ts

@@ -0,0 +1,27 @@
+/*!
+The tables derive from the Unicode Character Database.
+Copyright © 1991-2025 Unicode, Inc. Licensed under the Unicode License v3,
+in licenses/unicode-LICENSE.txt of @loomcli/core.
+
+They are generated from the tables of @rockorager/uucode.
+Copyright (c) 2026 Tim Culverhouse. Licensed under the MIT License,
+in licenses/uucode-LICENSE.md of @loomcli/core.
+*/
+/** The grapheme break state machine, indexed by state and two break properties. */
+export declare const graphemeTable: {
+    breakStateCount: number;
+    breakTable: Uint8Array<ArrayBuffer>;
+    graphemeBreakPropertyCount: number;
+};
+/** Each code point's width and grapheme break property, in a three-stage lookup. */
+export declare const widthTable: {
+    emojiVSFlag: number;
+    maxCodePoint: number;
+    stage1: Uint16Array<ArrayBuffer>;
+    stage1Shift: number;
+    stage2: Uint8Array<ArrayBuffer>;
+    stage2Mask: number;
+    stage3: Uint16Array<ArrayBuffer>;
+    widthMask: number;
+    zeroWidthFlag: number;
+};