@loomcli/core 0.5.0 → 0.7.0

package/dist/options.js

@@ -1,52 +1,129 @@
-import { DeclarationError, MissingValueError, RepeatedOptionError, ShortGroupError, UnexpectedValueError, UnknownOptionError, } from './errors.js';
+import { declaredName } from './command-rules.js';
+import { valueCode } from './diagnostic-text.js';
+import { DeclarationError, MissingValueError, quoted, RepeatedOptionError, ShortGroupError, UnexpectedValueError, UnknownOptionError, } from './errors.js';
+import { factFault, flagFault, siteFinding } from './facts.js';
+import { booleanOptionMultiple, optionDeclaredTwice, optionPolarity, optionType, polarityOnString, shortAlias, shortOnlyBothPolarities, shortOnlyWithoutShort, spellingTaken, } from './input-rules.js';
 /** Every parsed value lands in one of these maps; `lists` holds the repeated string options. */
 export function emptyValues() {
     return { booleans: new Map(), lists: new Map(), spellings: new Map(), strings: new Map() };
 }
-function validateDeclaration({ name, config }) {
+/**
+ * The part of one declaration that yields a spelling of the given role, which a spelling fault
+ * marks: the declared name for the long form, `short` for the short alias, and the `polarity` that
+ * generates a negative form.
+ */
+export function spellingMark(site, role) {
+    if (role === 'long') {
+        return site.named;
+    }
+    return `${site.at}.${role === 'short' ? 'short' : 'polarity'}`;
+}
+/** The declared name answers the declared-name rule an argument's name answers. */
+export function checkOptionName(name, site) {
+    const findings = [siteFinding(site, site.named)];
     if (typeof name !== 'string') {
-        throw new DeclarationError('Option names must be strings. Supply a string name.');
+        throw new DeclarationError(declaredName, {
+            correction: 'Supply a string name.',
+            findings,
+            sentence: `Option name ${valueCode(name)} is not a string.`,
+        });
     }
     if (!name || name.startsWith('-') || /[\s=]/u.test(name)) {
-        throw new DeclarationError(`Option name "${name}" is invalid. Use a nonempty name without a leading hyphen, whitespace, or "=".`);
-    }
-    if (!['string', 'boolean'].includes(config.type)) {
-        throw new DeclarationError(`Option "${name}" has an invalid type. Use "string" or "boolean".`);
+        throw new DeclarationError(declaredName, {
+            correction: 'Use a nonempty name without a leading hyphen, whitespace, or "=".',
+            findings,
+            sentence: `Option name ${quoted(name)} is invalid.`,
+        });
     }
-    if (config.short !== undefined &&
-        (typeof config.short !== 'string' || !/^[A-Za-z]$/u.test(config.short))) {
-        throw new DeclarationError(`Option "${name}" requires a short alias of one ASCII letter.`);
+}
+/** Whether a declared short alias is one ASCII letter, the rule every short spelling answers. */
+export function isShortAlias(short) {
+    return typeof short === 'string' && /^[A-Za-z]$/u.test(short);
+}
+/** The sentence and correction of the short-alias fault for the option `subject` names. */
+export function shortAliasText(subject) {
+    return {
+        correction: 'Supply one ASCII letter.',
+        sentence: `${subject} declares a short alias that is not one ASCII letter.`,
+    };
+}
+/** The short alias, and `shortOnly`, which leaves the option that alias alone. */
+function checkShortForms(config, site, subject) {
+    if (config.short !== undefined && !isShortAlias(config.short)) {
+        throw factFault(shortAlias, site, { ...shortAliasText(subject), fact: 'short' });
     }
     if (config.shortOnly !== undefined && typeof config.shortOnly !== 'boolean') {
-        throw new DeclarationError(`Option "${name}" shortOnly must be Boolean. Use true or false.`);
+        throw flagFault(site, 'shortOnly');
     }
     if (config.shortOnly && config.short === undefined) {
-        throw new DeclarationError(`Option "${name}" with shortOnly requires a short alias.`);
+        throw factFault(shortOnlyWithoutShort, site, {
+            correction: 'Add short or remove shortOnly.',
+            fact: 'shortOnly',
+            sentence: `${subject} declares shortOnly and no short alias.`,
+        });
     }
+}
+/** A Boolean option's polarity, which a string option does not declare. */
+function checkPolarity(config, site, subject) {
+    if (config.polarity === undefined) {
+        return;
+    }
+    if (config.type !== 'boolean') {
+        throw factFault(polarityOnString, site, {
+            correction: 'Remove polarity or use type "boolean".',
+            fact: 'polarity',
+            sentence: `${subject} declares polarity but is not Boolean.`,
+        });
+    }
+    if (!['positive', 'both', 'negative'].includes(config.polarity)) {
+        throw factFault(optionPolarity, site, {
+            correction: 'Use "positive", "both", or "negative".',
+            fact: 'polarity',
+            sentence: `${subject} has an invalid polarity.`,
+        });
+    }
+    if (config.polarity === 'both' && config.shortOnly) {
+        throw factFault(shortOnlyBothPolarities, site, {
+            correction: 'Enable long forms or select one polarity.',
+            fact: 'shortOnly',
+            sentence: `${subject} cannot express both polarities with shortOnly.`,
+        });
+    }
+}
+/** Every rule one option declaration answers alone, before the table meets it. */
+function validateDeclaration({ name, config }, site) {
+    checkOptionName(name, site);
+    const subject = `Option ${quoted(name)}`;
+    if (!['string', 'boolean'].includes(config.type)) {
+        throw factFault(optionType, site, {
+            correction: 'Use "string" or "boolean".',
+            fact: 'type',
+            sentence: `${subject} has an invalid type.`,
+        });
+    }
+    checkShortForms(config, site, subject);
     if (config.type === 'boolean' && config.multiple !== undefined) {
-        throw new DeclarationError(`Option "${name}" is a boolean option and declares multiple. Remove multiple or declare a string option.`);
+        throw factFault(booleanOptionMultiple, site, {
+            correction: 'Remove multiple or declare a string option.',
+            fact: 'multiple',
+            sentence: `${subject} is a boolean option and declares multiple.`,
+        });
     }
     if (config.multiple !== undefined && typeof config.multiple !== 'boolean') {
-        throw new DeclarationError(`Option "${name}" multiple must be Boolean. Use true or false.`);
-    }
-    if (config.polarity !== undefined) {
-        if (config.type !== 'boolean') {
-            throw new DeclarationError(`Option "${name}" declares polarity but is not Boolean. Remove polarity or use type "boolean".`);
-        }
-        if (!['positive', 'both', 'negative'].includes(config.polarity)) {
-            throw new DeclarationError(`Option "${name}" has an invalid polarity. Use "positive", "both", or "negative".`);
-        }
-        if (config.polarity === 'both' && config.shortOnly) {
-            throw new DeclarationError(`Option "${name}" cannot express both polarities with shortOnly. Enable long forms or select one polarity.`);
-        }
+        throw flagFault(site, 'multiple');
     }
+    checkPolarity(config, site, subject);
 }
-function addSpelling(spellings, spelling, option) {
-    const existing = spellings.get(spelling);
+function addSpelling(claims, spelling, claim) {
+    const existing = claims.get(spelling);
     if (existing) {
-        throw new DeclarationError(`Option spelling "${spelling}" is used by both "${existing.name}" and "${option.name}". Change one declaration.`);
+        throw new DeclarationError(spellingTaken, {
+            correction: 'Change one declaration.',
+            findings: [existing, claim].map(({ option, site }) => siteFinding(site, spellingMark(site, option.role))),
+            sentence: `Option spelling ${quoted(spelling)} is used by both ${quoted(existing.option.name)} and ${quoted(claim.option.name)}.`,
+        });
     }
-    spellings.set(spelling, option);
+    claims.set(spelling, claim);
 }
 /**
  * One Boolean option's value for one invocation: the value the parser consumed, or the value its
@@ -57,37 +134,50 @@ function addSpelling(spellings, spelling, option) {
 export function booleanValue(values, name, config) {
     return values.booleans.get(name) ?? config.polarity === 'negative';
 }
-export function compileOptions(declarations, subject) {
-    const spellings = new Map();
-    const names = new Set();
-    for (const { name, config } of declarations) {
-        validateDeclaration({ config, name });
-        if (names.has(name)) {
-            throw new DeclarationError(`Option "${name}" is declared more than once on ${subject}. Remove or rename the duplicate.`);
+/**
+ * One scope's options compiled into the spelling table the parser reads, with every rule one
+ * declaration answers alone and every rule two of them answer together.
+ */
+export function compileOptions(declarations, scope) {
+    const claims = new Map();
+    const names = new Map();
+    for (const declaration of declarations) {
+        const { name, config } = declaration;
+        const site = scope.siteOf(declaration);
+        validateDeclaration({ config, name }, site);
+        const first = names.get(name);
+        if (first) {
+            const earlier = scope.siteOf(first);
+            throw new DeclarationError(optionDeclaredTwice, {
+                correction: 'Remove or rename the duplicate.',
+                findings: [
+                    siteFinding(earlier, earlier.named, 'the first declaration'),
+                    siteFinding(site, site.named, 'the second declaration'),
+                ],
+                sentence: `Option ${quoted(name)} is declared more than once on ${scope.subject}.`,
+            });
         }
-        names.add(name);
+        names.set(name, declaration);
         const positive = config.type === 'string'
             ? { multiple: config.multiple === true, name, type: 'string' }
             : { name, type: 'boolean', value: config.polarity !== 'negative' };
         if (!config.shortOnly) {
             if (config.type === 'string' || config.polarity !== 'negative') {
-                addSpelling(spellings, `--${name}`, { ...positive, role: 'long' });
+                addSpelling(claims, `--${name}`, { option: { ...positive, role: 'long' }, site });
             }
             if (config.type === 'boolean' &&
                 (config.polarity === 'both' || config.polarity === 'negative')) {
-                addSpelling(spellings, `--no-${name}`, {
-                    name,
-                    role: 'negative',
-                    type: 'boolean',
-                    value: false,
+                addSpelling(claims, `--no-${name}`, {
+                    option: { name, role: 'negative', type: 'boolean', value: false },
+                    site,
                 });
             }
         }
         if (config.short !== undefined) {
-            addSpelling(spellings, `-${config.short}`, { ...positive, role: 'short' });
+            addSpelling(claims, `-${config.short}`, { option: { ...positive, role: 'short' }, site });
         }
     }
-    return spellings;
+    return new Map([...claims].map(([spelling, { option }]) => [spelling, option]));
 }
 /**
  * Whether a token reads as an option: it starts with a hyphen. Routing stops at one, and a
@@ -199,6 +289,9 @@ function readOption(spellings, input, state) {
 /**
  * A hyphen token belongs to the globals when its long spelling or every short letter does. The
  * pre-scan reads the globals alone, so a letter it does not own is only "not a global option".
+ * The scan stops at a global value option, because the letters after it may be the value the
+ * operator meant to pass: the token then belongs to the globals, and parsing reports the
+ * value-position fault that names that option alone.
  */
 function isGlobalToken(spellings, token) {
     const long = longToken(token);
@@ -210,8 +303,12 @@ function isGlobalToken(spellings, token) {
     let other = '';
     for (let index = 0; index < group.length; index += 1) {
         const letter = group.charAt(index);
-        if (spellings.has(`-${letter}`)) {
+        const option = spellings.get(`-${letter}`);
+        if (option) {
             global = global === '' ? letter : global;
+            if (option.type === 'string') {
+                break;
+            }
         }
         else {
             other = other === '' ? letter : other;

package/dist/output.d.ts

@@ -4,7 +4,7 @@ import type { RenderingPolicy } from './rendering.js';
 import type { Palette } from './style-state.js';
 import type { ActionChannel, Host, OpenResult, Out, ResultBinding, ViewContext } from './types.js';
 import type { ViewRegistry } from './view.js';
-type WriteState = {
+export type WriteState = {
     kind: 'ok';
 } | {
     kind: 'failed';
@@ -19,6 +19,7 @@ export declare class Output {
     private readonly signal;
     private readonly destinations;
     private renderFault;
+    private readonly viewFaults;
     private readonly stops;
     private route;
     /**
@@ -56,7 +57,7 @@ export declare class Output {
     private resultFault;
     /** The registry one invocation resolves through, republished as each contributor is read. */
     useViews(registry: ViewRegistry): void;
-    /** The routed path, published once routing resolved it, which an incomplete sequence names. */
+    /** The path routing walked, updated as each name routes, which an incomplete sequence names. */
     useRoute(path: readonly string[]): void;
     /** What this invocation's output raised beside its calls, in the order it was raised. */
     get stopped(): readonly unknown[];
@@ -112,6 +113,12 @@ export declare class Output {
      * awaits the call must not end the process with an unhandled rejection.
      */
     private renderFailed;
+    /**
+     * Whether one value is what a view or a message check failed with during this invocation. A
+     * broken view is a defect in the code that broke the view contract, so an action or a source that
+     * lets its rejection propagate reports it as that defect.
+     */
+    raisedByView(value: unknown): boolean;
     /** What a view failed with during this invocation, if one did. */
     get fault(): {
         cause: unknown;

package/dist/output.js

@@ -145,10 +145,13 @@ export class Output {
     signal;
     destinations = new Map();
     renderFault = undefined;
+    // Every value a view failed with.
+    // A caller that lets one propagate never offers it to a translator.
+    viewFaults = new WeakSet();
     // Every fault the output path raised beside its calls, reported after the primary outcome.
     // A source a sequence stopped on and a results-lane fault are both such faults.
     stops = [];
-    // The routed Command an incomplete sequence names, published once routing resolved it.
+    // The path routing walked, which an incomplete sequence names, updated as each name routes.
     route = [];
     /**
      * The channel every caller writes through. It is typed with the result left open, because the
@@ -263,7 +266,7 @@ export class Output {
     useViews(registry) {
         this.registry = registry;
     }
-    /** The routed path, published once routing resolved it, which an incomplete sequence names. */
+    /** The path routing walked, updated as each name routes, which an incomplete sequence names. */
     useRoute(path) {
         this.route = path;
     }
@@ -395,10 +398,23 @@ export class Output {
      */
     renderFailed(cause) {
         this.renderFault ??= { cause };
+        if ((typeof cause === 'object' || typeof cause === 'function') && cause !== null) {
+            this.viewFaults.add(cause);
+        }
         const rejection = Promise.reject(cause);
         void rejection.catch(() => undefined);
         return rejection;
     }
+    /**
+     * Whether one value is what a view or a message check failed with during this invocation. A
+     * broken view is a defect in the code that broke the view contract, so an action or a source that
+     * lets its rejection propagate reports it as that defect.
+     */
+    raisedByView(value) {
+        return ((typeof value === 'object' || typeof value === 'function') &&
+            value !== null &&
+            this.viewFaults.has(value));
+    }
     /** What a view failed with during this invocation, if one did. */
     get fault() {
         return this.renderFault;

package/dist/plain.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Runs one declaring call with verdicts of its own, dropped when it returns or throws. A call made
+ * inside another, such as a `plugin()` a getter makes, is part of the outer read and shares them.
+ */
+declare function declaring<Result>(call: () => Result): Result;
+/**
+ * A structural value core reads as plain data: an object literal, and never a declaration that
+ * carries state of its own. The options slots read it to reject a value that is not an options
+ * object, and `snapshot` reads it to copy a declared value faithfully. A value a declaring call
+ * already judged answers with that verdict.
+ */
+declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Whether a declaring call reads one part of a declaration as plain data, decided once: the first
+ * verdict is recorded, and `isPlainObject` answers with it for the same value from then on.
+ */
+declare function decidePlain(value: unknown): value is Record<string, unknown>;
+/**
+ * A snapshot of one value. Arrays and plain objects are copied and frozen to any depth, so a
+ * consumer cannot reach the source through the copy. A value that holds itself is copied with the
+ * same cycle, because each source object is judged and copied once and every path to it reaches
+ * that copy. Primitives and library objects, such as a class instance or a `Date` a schema
+ * produced, are reported as they are, because core cannot copy them meaningfully. Build reads it
+ * for a converter's schema, and the chain for the request one middleware holds.
+ */
+declare function snapshot(value: unknown): unknown;
+/** The snapshot of one plain object, under the record type the caller already established. */
+declare function snapshotRecord(value: Record<string, unknown>): Readonly<Record<string, unknown>>;
+/**
+ * The snapshot `snapshot` takes, of a value whose paths may hold at most `levels` arrays and plain
+ * objects, the value itself included. Every path through a container the value holds twice counts
+ * it, and a value that holds itself has a path without end. Either kind of path past `levels`
+ * throws `NestedTooDeepError` before the walk goes deeper than `levels`, so neither the walk nor
+ * any later reader of the copy goes deeper either. A declaring call reads it for a declared default.
+ */
+declare function boundedSnapshot(value: unknown, levels: number): unknown;
+/** What `boundedSnapshot` throws for a value with a path longer than its limit. */
+declare class NestedTooDeepError extends Error {
+    name: string;
+}
+/**
+ * A copy of every own string key of one object, enumerable or not, each described once and read
+ * once, in the order the object lists its keys. `entering` hears each key before it is read, so a
+ * read that throws can name it. A symbol key is not copied, because no declaration declares one.
+ */
+declare function copyOwnKeys(declared: object, entering?: (key: string) => void): Record<string, unknown>;
+/**
+ * The copy of one part of a declaration that `decidePlain` judges plain, by `copyOwnKeys`. Any other
+ * value is answered as it is, so the rule for its slot reports it.
+ */
+declare function shallowRecord(value: unknown): unknown;
+/** A copy of one list's entries by `fillList`. Each entry is what its factory built, so it is kept. */
+declare function copyList<Entry>(list: readonly Entry[]): Entry[];
+/** The copy of a value that is a list, by `copyList`. Any other value is answered as it is. */
+declare function shallowList(value: unknown): unknown;
+export { boundedSnapshot, copyList, copyOwnKeys, decidePlain, declaring, isPlainObject, NestedTooDeepError, shallowList, shallowRecord, snapshot, snapshotRecord, };

package/dist/plain.js

@@ -0,0 +1,238 @@
+/**
+ * The verdict the declaring call under way reached on each part of a declaration it captured, so
+ * every later rule of that call reads that one verdict and never asks the part's prototype again.
+ * No call is under way outside `declaring`, so a run and every later call judge afresh.
+ */
+let verdicts = undefined;
+/**
+ * Runs one declaring call with verdicts of its own, dropped when it returns or throws. A call made
+ * inside another, such as a `plugin()` a getter makes, is part of the outer read and shares them.
+ */
+function declaring(call) {
+    if (verdicts !== undefined) {
+        return call();
+    }
+    verdicts = new WeakMap();
+    try {
+        return call();
+    }
+    finally {
+        verdicts = undefined;
+    }
+}
+/**
+ * A structural value core reads as plain data: an object literal, and never a declaration that
+ * carries state of its own. The options slots read it to reject a value that is not an options
+ * object, and `snapshot` reads it to copy a declared value faithfully. A value a declaring call
+ * already judged answers with that verdict.
+ */
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    return verdicts?.get(value) ?? hasPlainPrototype(value);
+}
+/** Whether one object's prototype, read once, is `Object.prototype` or `null`. */
+function hasPlainPrototype(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/**
+ * Whether a declaring call reads one part of a declaration as plain data, decided once: the first
+ * verdict is recorded, and `isPlainObject` answers with it for the same value from then on.
+ */
+function decidePlain(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const known = verdicts?.get(value);
+    if (known !== undefined) {
+        return known;
+    }
+    const verdict = hasPlainPrototype(value);
+    verdicts?.set(value, verdict);
+    return verdict;
+}
+/**
+ * A snapshot of one value. Arrays and plain objects are copied and frozen to any depth, so a
+ * consumer cannot reach the source through the copy. A value that holds itself is copied with the
+ * same cycle, because each source object is judged and copied once and every path to it reaches
+ * that copy. Primitives and library objects, such as a class instance or a `Date` a schema
+ * produced, are reported as they are, because core cannot copy them meaningfully. Build reads it
+ * for a converter's schema, and the chain for the request one middleware holds.
+ */
+function snapshot(value) {
+    return copied(value, copying(Number.POSITIVE_INFINITY), 1);
+}
+/** The snapshot of one plain object, under the record type the caller already established. */
+function snapshotRecord(value) {
+    return copiedRecord(value, copying(Number.POSITIVE_INFINITY), 1);
+}
+/**
+ * The snapshot `snapshot` takes, of a value whose paths may hold at most `levels` arrays and plain
+ * objects, the value itself included. Every path through a container the value holds twice counts
+ * it, and a value that holds itself has a path without end. Either kind of path past `levels`
+ * throws `NestedTooDeepError` before the walk goes deeper than `levels`, so neither the walk nor
+ * any later reader of the copy goes deeper either. A declaring call reads it for a declared default.
+ */
+function boundedSnapshot(value, levels) {
+    return copied(value, copying(levels), 1);
+}
+/** What `boundedSnapshot` throws for a value with a path longer than its limit. */
+class NestedTooDeepError extends Error {
+    name = 'NestedTooDeepError';
+}
+/** A snapshot about to start, whose paths may hold at most `levels` containers. */
+function copying(levels) {
+    return { copies: new Map(), heights: new Map(), levels };
+}
+/**
+ * One value of a snapshot in progress, reached at `level`, where the value itself is level 1. An
+ * object the walk reached already answers as it did then, so its prototype is read once.
+ */
+function copied(value, walk, level) {
+    if (typeof value !== 'object' || value === null) {
+        return value;
+    }
+    if (walk.copies.has(value)) {
+        return walk.copies.get(value);
+    }
+    if (Array.isArray(value)) {
+        return copiedList(value, walk, level);
+    }
+    if (isPlainObject(value)) {
+        return copiedRecord(value, walk, level);
+    }
+    return kept(value, walk);
+}
+/** An object core cannot copy, kept as it is, which every later reach answers with unread. */
+function kept(value, walk) {
+    walk.copies.set(value, value);
+    walk.heights.set(value, 0);
+    return value;
+}
+/**
+ * How many containers the longest path from one entry holds, once the walk has copied the entry of
+ * a container reached at `level`. A container the walk filled counts every container below it,
+ * even one it reached first by a shorter path. A container still being filled is one this entry
+ * leads back into, so the path through it has no end, and any other value holds none.
+ */
+function checkedHeight(entry, walk, level) {
+    const height = typeof entry === 'object' && entry !== null
+        ? (walk.heights.get(entry) ?? Number.POSITIVE_INFINITY)
+        : 0;
+    if (level + height > walk.levels) {
+        throw new NestedTooDeepError();
+    }
+    return height;
+}
+/**
+ * The copier of each entry of one container reached at `level`, which counts how many containers
+ * the longest path from that container holds, itself included.
+ */
+function entryCopier(walk, level) {
+    let height = 1;
+    return {
+        copy: (entry) => {
+            const copy = copied(entry, walk, level + 1);
+            height = Math.max(height, checkedHeight(entry, walk, level) + 1);
+            return copy;
+        },
+        height: () => height,
+    };
+}
+/** Throws `NestedTooDeepError` for a container the walk first reaches past its limit. */
+function checkLevel(walk, level) {
+    if (level > walk.levels) {
+        throw new NestedTooDeepError();
+    }
+}
+/**
+ * One array's copy. It joins `copies` before its entries are read, so an entry that leads back to
+ * it reaches the copy, and it is frozen once it is filled. A hole stays a hole.
+ */
+function copiedList(list, walk, level) {
+    checkLevel(walk, level);
+    const copy = [];
+    walk.copies.set(list, copy);
+    const entries = entryCopier(walk, level);
+    fillList(copy, list, entries.copy);
+    walk.heights.set(list, entries.height());
+    return Object.freeze(copy);
+}
+/**
+ * One plain object's copy on `Object.prototype`, filled and frozen as an array's copy is. Each key
+ * is defined as an own data property, so a key of `__proto__` is stored under that name.
+ */
+function copiedRecord(record, walk, level) {
+    checkLevel(walk, level);
+    const copy = {};
+    walk.copies.set(record, copy);
+    const entries = entryCopier(walk, level);
+    for (const [key, entry] of Object.entries(record)) {
+        defineEntry(copy, key, entries.copy(entry));
+    }
+    walk.heights.set(record, entries.height());
+    return Object.freeze(copy);
+}
+/** Defines one key as an own data property, so a key of `__proto__` is stored under that name. */
+function defineEntry(target, key, value) {
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true,
+    });
+}
+/**
+ * A copy of every own string key of one object, enumerable or not, each described once and read
+ * once, in the order the object lists its keys. `entering` hears each key before it is read, so a
+ * read that throws can name it. A symbol key is not copied, because no declaration declares one.
+ */
+function copyOwnKeys(declared, entering = () => undefined) {
+    const copy = {};
+    for (const key of Reflect.ownKeys(declared)) {
+        if (typeof key === 'string') {
+            entering(key);
+            if (Reflect.getOwnPropertyDescriptor(declared, key) !== undefined) {
+                defineEntry(copy, key, Reflect.get(declared, key));
+            }
+        }
+    }
+    return copy;
+}
+/**
+ * The copy of one part of a declaration that `decidePlain` judges plain, by `copyOwnKeys`. Any other
+ * value is answered as it is, so the rule for its slot reports it.
+ */
+function shallowRecord(value) {
+    return decidePlain(value) ? copyOwnKeys(value) : value;
+}
+/**
+ * Fills `copy` with what `convert` makes of each entry of `list`, read by its length once and then
+ * index by index, so none of the list's own methods runs. A hole stays a hole.
+ */
+function fillList(copy, list, convert) {
+    const { length } = list;
+    for (let index = 0; index < length; index += 1) {
+        if (Object.hasOwn(list, index)) {
+            defineEntry(copy, index, convert(list[index]));
+        }
+    }
+    copy.length = length;
+}
+/** A copy of one list's entries by `fillList`. Each entry is what its factory built, so it is kept. */
+function copyList(list) {
+    const copy = [];
+    fillList(copy, list, (entry) => entry);
+    return copy;
+}
+/** The copy of a value that is a list, by `copyList`. Any other value is answered as it is. */
+function shallowList(value) {
+    if (!Array.isArray(value)) {
+        return value;
+    }
+    const list = value;
+    return copyList(list);
+}
+export { boundedSnapshot, copyList, copyOwnKeys, decidePlain, declaring, isPlainObject, NestedTooDeepError, shallowList, shallowRecord, snapshot, snapshotRecord, };