@loomcli/core 0.2.0 → 0.3.0

package/dist/environment.d.ts

@@ -0,0 +1,22 @@
+import type { Plugin } from './plugin.js';
+/** The shallow type information an Application supplies before its Command graph is composed. */
+interface ApplicationEnvironment<Globals = {}, Plugins extends readonly Plugin[] = readonly []> {
+    readonly globals: Globals;
+    readonly plugins: Plugins;
+}
+interface RegistrationShape {
+    environment?: ApplicationEnvironment<unknown, readonly Plugin[]>;
+}
+/** The Application augments this interface once in its own TypeScript compilation context. */
+interface Register extends RegistrationShape {
+}
+type RegisteredEnvironment = Register extends {
+    environment: infer Environment;
+} ? Environment extends ApplicationEnvironment<unknown, readonly Plugin[]> ? Environment : never : ApplicationEnvironment;
+type RegisteredGlobals = RegisteredEnvironment['globals'];
+/** A private type marker avoids pretending parsed global values exist before an invocation. */
+declare const applicationEnvironment: unique symbol;
+type EnvironmentOf<Value extends {
+    readonly [applicationEnvironment]: ApplicationEnvironment<unknown, readonly Plugin[]>;
+}> = Value[typeof applicationEnvironment];
+export type { ApplicationEnvironment, EnvironmentOf, Register, RegisteredEnvironment, RegisteredGlobals, applicationEnvironment, };

package/dist/environment.js

@@ -0,0 +1 @@
+export {};

package/dist/errors.d.ts

@@ -1,5 +1,5 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { InputIdentity, Renderer } from './types.js';
+import type { InputIdentity } from './types.js';
 /**
  * The two short-group faults. A value option that is not last in its group names that option's
  * spelling; a group that mixes scopes names the whole group and the two letters that disagree.
@@ -14,28 +14,25 @@ type ShortGroupFault = {
     global: string;
     other: string;
 };
-/** One registration: the class it names, read as the prototype and the name that class holds. */
-interface Registration {
-    name: string;
-    prototype: unknown;
-    render: (failure: LoomError) => unknown;
-}
-/** Phantom key. It marks a failure registration and holds no runtime value. */
-declare const failureRegistration: unique symbol;
-/** The runtime value `renderFailure` returns. Its pair lives in the registry above. */
-declare class RegisteredFailure {
-    readonly [failureRegistration]: true;
-    constructor(registration: Registration);
-}
+/**
+ * Core's own text for one failure: its message under the category prefix its class carries, with
+ * the trailing newline every view's text carries. The four categories are disjoint branches of the
+ * hierarchy, so one ordered test reads every class, and a class without a prefix of its own writes
+ * the sentence alone. It is the default view of every failure class and the text the plain
+ * fallback path writes, so it runs no application code and nothing downstream composes its newline.
+ */
+export declare function defaultText(failure: LoomError): string;
 /** How a diagnostic names one Command inside a sentence: by name, or as the unnamed root. */
 export declare function commandSubject(name: string | null): string;
+/** The routed path names the Command a sentence speaks of; an empty path is the root. */
+export declare function routedSubject(command: readonly string[]): string;
 /** The same subject at the start of a sentence. */
 export declare function commandSentence(name: string | null): string;
 /**
  * Every failure `run()` reports is an instance of a public class. Each class carries the facts its
- * sentence interpolates, so a renderer reads them instead of parsing prose, and the exit status is
+ * sentence interpolates, so a view reads them instead of parsing prose, and the exit status is
  * a field of the base, so a subclass inherits it. `message` never carries a category prefix; the
- * default renderers add it.
+ * default views add it.
  */
 export declare abstract class LoomError extends Error {
     readonly exitCode: 1 | 2;
@@ -109,58 +106,33 @@ export declare class DeclarationError extends LoomError {
 export declare class FatalError extends LoomError {
     constructor(message: string);
 }
-/** Exit 1: an unexpected exception, a non-error throw, or a renderer that could not answer. */
+/** Exit 1: an unexpected exception, a non-error throw, or a view that could not answer. */
 export declare class InternalError extends LoomError {
     readonly cause: unknown;
     constructor(message: string, cause: unknown);
 }
+/** The four ways the results lane is broken, each named where core meets it. */
+export type ResultFault = 'missing' | 'repeated' | 'undeclared' | 'middleware';
+/**
+ * Exit 1: the promise a declared result makes was not kept. It wraps no thrown value, so its
+ * `cause` is `undefined`, and it extends `InternalError`, so an override of that class brands it
+ * and its default text carries the same prefix, while an override keyed by this class reaches it
+ * alone.
+ */
+export declare class ResultError extends InternalError {
+    readonly path: readonly string[];
+    readonly kind: ResultFault;
+    readonly cause: undefined;
+    constructor(kind: ResultFault, path: readonly string[]);
+}
 /** What a diagnostic says about an unexpected value, whether or not it was an Error. */
 export declare function reasonOf(thrown: unknown): string;
 /**
- * Why a returned value is not the text a renderer owes. A renderer is synchronous, so a returned
- * promise is a non-string return like any other, and its rejection is adopted and swallowed here:
- * an unobserved rejection would end the process before the invocation could report anything.
+ * Why a returned value is not the text a view owes. A view is synchronous, so a returned promise is
+ * a non-string return like any other, and its rejection is adopted and swallowed here: an
+ * unobserved rejection would end the process before the invocation could report anything.
  */
 export declare function notTextReason(value: unknown): string;
 /** Every thrown value reaches reporting as a failure class; anything else is internal. */
 export declare function toFailure(thrown: unknown): LoomError;
-/** An opaque registration pairing one failure class with a renderer for its instances. */
-export type FailureRenderer = Pick<RegisteredFailure, typeof failureRegistration>;
-/**
- * A registration pairing one failure class with a renderer for its instances. The helper is the
- * typed path for a class-keyed list, because an array literal cannot carry a different type
- * parameter per element.
- */
-export declare function renderFailure<Failure extends LoomError>(type: abstract new (...args: never[]) => Failure, renderer: Renderer<Failure>): FailureRenderer;
-/** The renderers one application registered, keyed by the class each one names. */
-export type FailureRegistry = ReadonlyMap<unknown, Registration>;
-/**
- * One class answers to one renderer inside one contributor, so a second registration for it is a
- * declaration fault. The subject names the contributor: the Application, or an installed plugin.
- */
-export declare function buildFailures(failures: readonly FailureRenderer[], subject?: string): FailureRegistry;
-/**
- * One registry from every contributor's own, resolving first-in-wins: the application's
- * registrations, then each installed plugin's in installation order, then core's text.
- */
-export declare function mergeFailures(registries: readonly FailureRegistry[]): FailureRegistry;
-/**
- * The report of one failure: the text core writes, and whether a registered renderer produced it.
- * An unrendered report carries core's own text, which the plain fallback path writes beside the
- * diagnostic naming the renderer that could not answer.
- */
-export type FailureReport = {
-    kind: 'rendered';
-    text: string;
-} | {
-    kind: 'unrendered';
-    text: string;
-    reason: string;
-};
-/**
- * The text core writes for one failure. Resolution walks the failure's prototype chain most
- * derived first through the application's registrations, then falls to core's own text, so a
- * registration for a base class brands every failure below it.
- */
-export declare function describeFailure(registry: FailureRegistry, failure: LoomError): FailureReport;
 export {};

package/dist/errors.js

@@ -1,7 +1,20 @@
-/** The routed path names the Command a token fault belongs to; an empty path is the root. */
+/** The same subject at the start of a sentence, where a token fault names its Command. */
 function routedSentence(command) {
-    const name = command.at(-1);
-    return name === undefined ? 'The root Command' : commandSentence(name);
+    const subject = routedSubject(command);
+    return `${subject.slice(0, 1).toUpperCase()}${subject.slice(1)}`;
+}
+/** The sentence one results-lane fault reports, which names the Command that holds it. */
+function resultMessage(kind, command) {
+    if (kind === 'missing') {
+        return `${routedSentence(command)} declares a result and its action returned without emitting one. Call out.results() once.`;
+    }
+    if (kind === 'repeated') {
+        return `${routedSentence(command)} emitted its result twice. Call out.results() once.`;
+    }
+    if (kind === 'undeclared') {
+        return `${routedSentence(command)} declares no result. Declare one with result() or rows() before action().`;
+    }
+    return `A middleware called out.results() on ${routedSubject(command)}. Only the action emits a result.`;
 }
 /**
  * The clause that offers the candidates, which is absent when there are none: every child of the
@@ -17,12 +30,12 @@ function shortGroupMessage(fault) {
 }
 /**
  * Core's own text for one failure: its message under the category prefix its class carries, with
- * the trailing newline every renderer's text carries. The four categories are disjoint branches of
- * the hierarchy, so one ordered test reads every class, and a class without a prefix of its own
- * writes the sentence alone. A default rendering is the same kind of value as a custom one, so
- * nothing downstream composes the newline for it.
+ * the trailing newline every view's text carries. The four categories are disjoint branches of the
+ * hierarchy, so one ordered test reads every class, and a class without a prefix of its own writes
+ * the sentence alone. It is the default view of every failure class and the text the plain
+ * fallback path writes, so it runs no application code and nothing downstream composes its newline.
  */
-function defaultText(failure) {
+export function defaultText(failure) {
     if (failure instanceof UsageError) {
         return `Invalid input: ${failure.message}\n`;
     }
@@ -34,36 +47,15 @@ function defaultText(failure) {
     }
     return `${failure.message}\n`;
 }
-/** Every prototype in a failure's chain, most derived first, so one walk reads the registry. */
-function chainOf(failure) {
-    const chain = [];
-    let prototype = Object.getPrototypeOf(failure);
-    while (prototype !== null) {
-        chain.push(prototype);
-        prototype = Object.getPrototypeOf(prototype);
-    }
-    return chain;
-}
-/** Authored registrations register here, so the public type publishes nothing to reach. */
-const nodes = new WeakMap();
-/** The runtime value `renderFailure` returns. Its pair lives in the registry above. */
-class RegisteredFailure {
-    constructor(registration) {
-        nodes.set(this, registration);
-    }
-}
-/** Reads the pair behind a registered value; anything else is a declaration error. */
-function nodeOf(value, subject) {
-    const registration = nodes.get(value);
-    if (!registration) {
-        throw new DeclarationError(`${subject} holds a value that is not a failure renderer. Supply the value returned by renderFailure(type, renderer).`);
-    }
-    return registration;
-}
 /** How a diagnostic names one Command inside a sentence: by name, or as the unnamed root. */
 export function commandSubject(name) {
     return name === null ? 'the root Command' : `Command "${name}"`;
 }
+/** The routed path names the Command a sentence speaks of; an empty path is the root. */
+export function routedSubject(command) {
+    const name = command.at(-1);
+    return name === undefined ? 'the root Command' : commandSubject(name);
+}
 /** The same subject at the start of a sentence. */
 export function commandSentence(name) {
     const subject = commandSubject(name);
@@ -71,9 +63,9 @@ export function commandSentence(name) {
 }
 /**
  * Every failure `run()` reports is an instance of a public class. Each class carries the facts its
- * sentence interpolates, so a renderer reads them instead of parsing prose, and the exit status is
+ * sentence interpolates, so a view reads them instead of parsing prose, and the exit status is
  * a field of the base, so a subclass inherits it. `message` never carries a category prefix; the
- * default renderers add it.
+ * default views add it.
  */
 export class LoomError extends Error {
     exitCode;
@@ -193,7 +185,7 @@ export class FatalError extends LoomError {
         this.name = 'FatalError';
     }
 }
-/** Exit 1: an unexpected exception, a non-error throw, or a renderer that could not answer. */
+/** Exit 1: an unexpected exception, a non-error throw, or a view that could not answer. */
 export class InternalError extends LoomError {
     cause;
     constructor(message, cause) {
@@ -202,85 +194,36 @@ export class InternalError extends LoomError {
         this.name = 'InternalError';
     }
 }
+/**
+ * Exit 1: the promise a declared result makes was not kept. It wraps no thrown value, so its
+ * `cause` is `undefined`, and it extends `InternalError`, so an override of that class brands it
+ * and its default text carries the same prefix, while an override keyed by this class reaches it
+ * alone.
+ */
+export class ResultError extends InternalError {
+    path;
+    kind;
+    constructor(kind, path) {
+        super(resultMessage(kind, path), undefined);
+        this.kind = kind;
+        this.name = 'ResultError';
+        this.path = path;
+    }
+}
 /** What a diagnostic says about an unexpected value, whether or not it was an Error. */
 export function reasonOf(thrown) {
     return thrown instanceof Error ? thrown.message : 'An unknown error occurred.';
 }
 /**
- * Why a returned value is not the text a renderer owes. A renderer is synchronous, so a returned
- * promise is a non-string return like any other, and its rejection is adopted and swallowed here:
- * an unobserved rejection would end the process before the invocation could report anything.
+ * Why a returned value is not the text a view owes. A view is synchronous, so a returned promise is
+ * a non-string return like any other, and its rejection is adopted and swallowed here: an
+ * unobserved rejection would end the process before the invocation could report anything.
  */
 export function notTextReason(value) {
     void Promise.resolve(value).catch(() => undefined);
-    return `The renderer returned ${typeof value} instead of a string.`;
+    return `The view returned ${typeof value} instead of a string.`;
 }
 /** Every thrown value reaches reporting as a failure class; anything else is internal. */
 export function toFailure(thrown) {
     return thrown instanceof LoomError ? thrown : new InternalError(reasonOf(thrown), thrown);
 }
-/**
- * A registration pairing one failure class with a renderer for its instances. The helper is the
- * typed path for a class-keyed list, because an array literal cannot carry a different type
- * parameter per element.
- */
-export function renderFailure(type, renderer) {
-    return new RegisteredFailure({
-        name: 'name' in type && typeof type.name === 'string' ? type.name : 'a failure class',
-        prototype: 'prototype' in type ? type.prototype : undefined,
-        // Resolution reaches this registration through the same class, so the test always holds.
-        render: (failure) => (failure instanceof type ? renderer.render(failure) : undefined),
-    });
-}
-/**
- * One class answers to one renderer inside one contributor, so a second registration for it is a
- * declaration fault. The subject names the contributor: the Application, or an installed plugin.
- */
-export function buildFailures(failures, subject = 'The Application') {
-    const registry = new Map();
-    for (const failure of failures) {
-        const registration = nodeOf(failure, subject);
-        if (registry.has(registration.prototype)) {
-            throw new DeclarationError(`${subject} registers two failure renderers for "${registration.name}". Remove one registration.`);
-        }
-        registry.set(registration.prototype, registration);
-    }
-    return registry;
-}
-/**
- * One registry from every contributor's own, resolving first-in-wins: the application's
- * registrations, then each installed plugin's in installation order, then core's text.
- */
-export function mergeFailures(registries) {
-    const merged = new Map();
-    for (const registry of registries) {
-        for (const [type, registration] of registry) {
-            if (!merged.has(type)) {
-                merged.set(type, registration);
-            }
-        }
-    }
-    return merged;
-}
-/**
- * The text core writes for one failure. Resolution walks the failure's prototype chain most
- * derived first through the application's registrations, then falls to core's own text, so a
- * registration for a base class brands every failure below it.
- */
-export function describeFailure(registry, failure) {
-    const registration = chainOf(failure)
-        .map((prototype) => registry.get(prototype))
-        .find((entry) => entry !== undefined);
-    if (!registration) {
-        return { kind: 'rendered', text: defaultText(failure) };
-    }
-    try {
-        const text = registration.render(failure);
-        return typeof text === 'string'
-            ? { kind: 'rendered', text }
-            : { kind: 'unrendered', reason: notTextReason(text), text: defaultText(failure) };
-    }
-    catch (error) {
-        return { kind: 'unrendered', reason: reasonOf(error), text: defaultText(failure) };
-    }
-}

package/dist/extension.d.ts

@@ -91,5 +91,9 @@ interface ExtensionSlot {
  * the record, so a typed read compares by reference without the graph carrying a reference.
  */
 declare function buildExtensions(slot: ExtensionSlot): Readonly<Record<string, unknown>>;
+/** Layers validate in authoring order; replacement updates existing keys without reinsertion. */
+declare function buildCommandExtensions(slot: Omit<ExtensionSlot, 'declared' | 'target'> & {
+    layers: readonly unknown[];
+}): Readonly<Record<string, unknown>>;
 export type { AnyExtension, DeepReadonly, DescriptorRegistry, Extension, ExtensionRecords, ExtensionSubject, ExtensionTarget, ExtensionValue, };
-export { buildExtensions, extension, isDescriptor, readExtension, registerDescriptor };
+export { buildCommandExtensions, buildExtensions, extension, isDescriptor, readExtension, registerDescriptor, };

package/dist/extension.js

@@ -310,4 +310,21 @@ function buildExtensions(slot) {
     owners.set(frozen, defined);
     return frozen;
 }
-export { buildExtensions, extension, isDescriptor, readExtension, registerDescriptor };
+/** Layers validate in authoring order; replacement updates existing keys without reinsertion. */
+function buildCommandExtensions(slot) {
+    const stored = new Map();
+    const defined = new Map();
+    for (const declared of slot.layers) {
+        const layer = buildExtensions({ ...slot, declared, target: 'command' });
+        for (const [identity, value] of Object.entries(layer)) {
+            stored.set(identity, value);
+        }
+        for (const [identity, descriptor] of owners.get(layer) ?? []) {
+            defined.set(identity, descriptor);
+        }
+    }
+    const frozen = Object.freeze(Object.fromEntries(stored));
+    owners.set(frozen, defined);
+    return frozen;
+}
+export { buildCommandExtensions, buildExtensions, extension, isDescriptor, readExtension, registerDescriptor, };

package/dist/globals.d.ts

@@ -1,10 +1,8 @@
 import { DeclarationError } from './errors.js';
 import { compileOptions } from './options.js';
 import type { BuiltPlugin, PluginBuild } from './plugin.js';
-import type { DefaultConstraint, MultipleConstraint, NameConstraint, OptionConfig, OptionValue, ValidateOmittedConstraint } from './types.js';
+import type { OptionConfig, OptionValue } from './types.js';
 import type { InputDeclaration, OptionInput, ValidatedInputs } from './validation.js';
-/** Phantom key. It keeps the declared option types exact and holds no runtime value. */
-declare const declaredTypes: unique symbol;
 /**
  * Who declared one option that shares the globals table, or the Command that declares a local
  * option colliding with it. Every collision sentence is derived from a pair of these, so the
@@ -36,33 +34,24 @@ declare function spellingCollision(spelling: string, first: OptionSite, second:
  * validated and never reaches an action.
  */
 interface BuiltGlobals {
+    bind: (values: ValidatedInputs) => unknown;
     inputs: readonly InputDeclaration[];
     names: ReadonlyMap<string, OptionOwner>;
     options: ReturnType<typeof compileOptions>;
     plugins: readonly BuiltPlugin[];
-    source: unknown;
 }
-declare class GlobalOptionsBuilder<Options> {
-    #private;
-    readonly [declaredTypes]: Options;
-    constructor(inputs: readonly OptionInput[], bind: (values: ValidatedInputs) => Options);
-    option<const Name extends string, const Config extends OptionConfig>(name: Name, config: Config & NameConstraint<Name> & NoInfer<DefaultConstraint<Config>> & NoInfer<MultipleConstraint<Config>> & NoInfer<ValidateOmittedConstraint<Config>>): GlobalOptions<Options & Record<Name, OptionValue<Config>>>;
+/** The Application's private global declarations and their schema-derived value binder. */
+interface GlobalsState<Globals = unknown> {
+    bind: (values: ValidatedInputs) => Globals;
+    inputs: readonly OptionInput[];
 }
+declare function emptyGlobals(): GlobalsState<{}>;
+declare function declareGlobalOption<Globals, Name extends string, Config extends OptionConfig>(state: GlobalsState<Globals>, input: OptionInput<Name, Config>): GlobalsState<Globals & Record<Name, OptionValue<Config>>>;
 /**
- * Application-wide options. `option()` is the whole authoring surface: it returns a new value and
- * leaves its receiver unchanged. The value the declarations share is the application's globals.
- * The declarations themselves stay private, so no consumer can read or replace them.
+ * The one table the pre-scan reads: the application's global options in authoring order, then each
+ * installed plugin's options in installation order. Every collision between the two scopes, by key
+ * or by spelling, is reported here, so the pre-scan meets a table with one owner per name.
  */
-type GlobalOptions<Options = {}> = Pick<GlobalOptionsBuilder<Options>, typeof declaredTypes | 'option'>;
-/**
- * Whether a value is an authored GlobalOptions declaration, whichever call produced it. The
- * registry is the test, because `option()` returns a new declaration of its own and the exported
- * constructor is only the first of them.
- */
-declare function isGlobalOptions(value: unknown): boolean;
-/** Absent globals compile to an empty table whose source is `undefined`, like the declarations. */
-declare function buildGlobals(globals: object | undefined, plugins: readonly BuiltPlugin[], build: PluginBuild): BuiltGlobals;
-declare function bindGlobals<Options>(globals: GlobalOptions<Options> | undefined, values: ValidatedInputs): Options;
-declare const GlobalOptions: new () => GlobalOptions;
-export type { BuiltGlobals, OptionOwner, OptionSite };
-export { bindGlobals, buildGlobals, GlobalOptions, isGlobalOptions, keyCollision, spellingCollision, };
+declare function buildGlobals(node: GlobalsState, plugins: readonly BuiltPlugin[], build: PluginBuild): BuiltGlobals;
+export type { BuiltGlobals, GlobalsState, OptionOwner, OptionSite };
+export { buildGlobals, declareGlobalOption, emptyGlobals, keyCollision, spellingCollision };

package/dist/globals.js

@@ -2,7 +2,6 @@ import { DeclarationError } from './errors.js';
 import { buildExtensions } from './extension.js';
 import { checkDeprecated, checkDescription, checkHidden } from './facts.js';
 import { compileOptions } from './options.js';
-import { captureConfig } from './validation.js';
 const globalSubject = 'the global options';
 /** A collision sentence names a plugin first, then the application's globals, then a local. */
 const ranks = {
@@ -57,51 +56,21 @@ function spellingCollision(spelling, first, second) {
     const [leading, trailing] = ordered(first, second);
     return new DeclarationError(`Option spelling "${spelling}" is used by ${usedBy(leading)} and ${usedBy(trailing)}. Change one declaration.`);
 }
-/** Authored values register here, so the public type publishes no state to reach or replace. */
-const nodes = new WeakMap();
-class GlobalOptionsBuilder {
-    #bind;
-    #inputs;
-    constructor(inputs, bind) {
-        this.#bind = bind;
-        this.#inputs = inputs;
-        nodes.set(this, { bind, inputs, source: this });
-    }
-    option(name, config) {
-        const input = {
-            config: captureConfig(config),
-            kind: 'option',
-            name,
-        };
-        const previous = this.#bind;
-        return new GlobalOptionsBuilder([...this.#inputs, input], (values) => ({
-            ...previous(values),
-            ...values.option(input),
-        }));
-    }
+function emptyGlobals() {
+    return { bind: () => ({}), inputs: [] };
 }
-/** Reads the declarations behind an authored value; anything else is a declaration error. */
-function nodeOf(globals) {
-    const node = nodes.get(globals);
-    if (!node) {
-        throw new DeclarationError('The Application holds a value that is not a GlobalOptions declaration. Supply the value returned by new GlobalOptions().');
-    }
-    return node;
-}
-/**
- * Whether a value is an authored GlobalOptions declaration, whichever call produced it. The
- * registry is the test, because `option()` returns a new declaration of its own and the exported
- * constructor is only the first of them.
- */
-function isGlobalOptions(value) {
-    return typeof value === 'object' && value !== null && nodes.has(value);
+function declareGlobalOption(state, input) {
+    return {
+        bind: (values) => ({ ...state.bind(values), ...values.option(input) }),
+        inputs: [...state.inputs, input],
+    };
 }
 /**
  * The one table the pre-scan reads: the application's global options in authoring order, then each
  * installed plugin's options in installation order. Every collision between the two scopes, by key
  * or by spelling, is reported here, so the pre-scan meets a table with one owner per name.
  */
-function compileTable(node, plugins, build) {
+function buildGlobals(node, plugins, build) {
     const names = new Map();
     const application = { kind: 'application' };
     // A global option belongs to the application, not to one Command, so its facts read that way.
@@ -125,7 +94,7 @@ function compileTable(node, plugins, build) {
             options,
         });
     });
-    return { inputs: node.inputs, names, options, plugins, source: node.source };
+    return { bind: node.bind, inputs: node.inputs, names, options, plugins };
 }
 /** One plugin's options joining the table the application's globals already hold. */
 function join(owner, inputs, table) {
@@ -145,24 +114,4 @@ function join(owner, inputs, table) {
         options.set(spelling, option);
     }
 }
-/** Absent globals compile to an empty table whose source is `undefined`, like the declarations. */
-function buildGlobals(globals, plugins, build) {
-    const node = globals === undefined ? { bind: () => ({}), inputs: [], source: undefined } : nodeOf(globals);
-    return compileTable(node, plugins, build);
-}
-function bindGlobals(globals, values) {
-    const bound = globals === undefined ? {} : nodeOf(globals).bind(values);
-    // Last resort: no typed path exists. The public GlobalOptions type hides its declarations.
-    // The registry is the only bridge from a value to its binder, and a WeakMap cannot carry the
-    // Options type of its key. It holds because the registered binder belongs to this value alone.
-    // Its record composes exactly the declarations that its Options type records.
-    // A declaration without globals publishes `Options = {}`, and the empty record is exactly that.
-    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
-    return bound;
-}
-const GlobalOptions = class extends GlobalOptionsBuilder {
-    constructor() {
-        super([], () => ({}));
-    }
-};
-export { bindGlobals, buildGlobals, GlobalOptions, isGlobalOptions, keyCollision, spellingCollision, };
+export { buildGlobals, declareGlobalOption, emptyGlobals, keyCollision, spellingCollision };