flightdeck 0.2.28 → 0.2.29

package/dist/lib.d.ts

@@ -1,787 +1,1800 @@
 import { __export } from "./chunk-Cl8Af3a2.js";
 import { z } from "zod";
-import { Server } from "node:http";
-import { Future } from "atom.io/internal";
-import { ChildSocket } from "atom.io/realtime-server";
+import { ChildProcessWithoutNullStreams } from "node:child_process";
 import { CronJob } from "cron";
-import { FilesystemStorage } from "safedeposit";
 
+//#region ../atom.io/dist/transceivers/set-rtx/index.d.ts
+//#region src/transceivers/set-rtx/set-rtx.d.ts
+type SetUpdateType = `add` | `clear` | `del` | `tx`;
+type SetUpdate = `${SetUpdateType}:${string}`;
+type NumberedSetUpdate = `${number}=${SetUpdate}`;
+interface SetRTXJson<P extends primitive> extends Json.Object {
+  members: P[];
+  cache: (NumberedSetUpdate | null)[];
+  cacheLimit: number;
+  cacheIdx: number;
+  cacheUpdateNumber: number;
+}
+declare class SetRTX<P extends primitive> extends Set<P> implements Transceiver<NumberedSetUpdate>, Lineage {
+  mode: TransceiverMode;
+  readonly subject: Subject<SetUpdate>;
+  cacheLimit: number;
+  cache: (NumberedSetUpdate | null)[];
+  cacheIdx: number;
+  cacheUpdateNumber: number;
+  constructor(values?: Iterable<P>, cacheLimit?: number);
+  toJSON(): SetRTXJson<P>;
+  static fromJSON<P extends primitive>(json: SetRTXJson<P>): SetRTX<P>;
+  add(value: P): this;
+  clear(): void;
+  delete(value: P): boolean;
+  readonly parent: SetRTX<P> | null;
+  child: SetRTX<P> | null;
+  transactionUpdates: SetUpdate[] | null;
+  transaction(run: (child: SetRTX<P>) => boolean): void;
+  protected _subscribe(key: string, fn: (update: SetUpdate) => void): () => void;
+  subscribe(key: string, fn: (update: NumberedSetUpdate) => void): () => void;
+  emit(update: SetUpdate): void;
+  private doStep;
+  getUpdateNumber(update: NumberedSetUpdate): number;
+  do(update: NumberedSetUpdate): number | `OUT_OF_RANGE` | null;
+  undoStep(update: SetUpdate): void;
+  undo(update: NumberedSetUpdate): number | null;
+}
+
+//#endregion
+//#region ../atom.io/dist/main/index.d.ts
+//#endregion
+
+type RegularAtomFamilyToken<T, K extends Canonical> = {
+  key: string;
+  type: `atom_family`;
+  __T?: T;
+  __K?: K;
+};
+type MutableAtomFamilyToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = {
+  key: string;
+  type: `mutable_atom_family`;
+  __T?: T;
+  __J?: J;
+  __K?: K;
+};
+type AtomFamilyToken<T, K extends Canonical = Canonical> = MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamilyToken<T, K>;
+//#endregion
+//#region src/main/transaction.d.ts
+type TransactionToken<F extends Func> = {
+  key: string;
+  type: `transaction`;
+  __F?: F;
+};
+type StateCreation<Token extends ReadableToken<any>> = {
+  type: `state_creation`;
+  token: Token;
+};
+type AtomDisposal<Token extends ReadableToken<any>> = {
+  type: `state_disposal`;
+  subType: `atom`;
+  token: Token;
+  value: TokenType<Token>;
+};
+type SelectorDisposal<Token extends ReadableToken<any>> = {
+  type: `state_disposal`;
+  subType: `selector`;
+  token: Token;
+};
+type StateDisposal<Token extends ReadableToken<any>> = AtomDisposal<Token> | SelectorDisposal<Token>;
+type MoleculeCreation = {
+  type: `molecule_creation`;
+  key: Canonical;
+  provenance: Canonical;
+};
+type MoleculeDisposal = {
+  type: `molecule_disposal`;
+  key: Canonical;
+  provenance: stringified<Canonical>[];
+  values: [key: string, value: any][];
+};
+type MoleculeTransfer = {
+  type: `molecule_transfer`;
+  key: Canonical;
+  from: Canonical[];
+  to: Canonical[];
+};
+type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation | MoleculeDisposal | MoleculeTransfer | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
+type TransactionUpdate<F extends Func> = {
+  type: `transaction_update`;
+  key: string;
+  id: string;
+  epoch: number;
+  updates: TransactionUpdateContent[];
+  params: Parameters<F>;
+  output: ReturnType<F>;
+};
+type SetterToolkit = Readonly<{
+  get: typeof getState;
+  set: typeof setState;
+  find: typeof findState;
+  json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
+}>;
+type ActorToolkit = Readonly<{
+  get: typeof getState;
+  set: typeof setState;
+  find: typeof findState;
+  json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
+  dispose: typeof disposeState;
+  run: typeof runTransaction;
+  env: () => EnvironmentData;
+}>;
+declare function runTransaction<F extends Func>(token: TransactionToken<F>, id?: string): (...parameters: Parameters<F>) => ReturnType<F>;
+
+//#endregion
+//#region src/main/selector.d.ts
+
+type WritableSelectorFamilyToken<T, K extends Canonical> = {
+  key: string;
+  type: `selector_family`;
+  __T?: T;
+  __K?: K;
+};
+type ReadonlySelectorFamilyToken<T, K extends Canonical> = {
+  key: string;
+  type: `readonly_selector_family`;
+  __T?: T;
+  __K?: K;
+};
+type SelectorFamilyToken<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
+//#endregion
+//#region src/main/timeline.d.ts
+type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>;
+type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<any, any> ? AtomToken<any> : M extends AtomToken<any> ? M : never;
+type TimelineToken<M> = {
+  key: string;
+  type: `timeline`;
+  __M?: M;
+};
+type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation | TimelineMoleculeDisposal | TimelineSelectorUpdate<ManagedAtom> | TimelineStateCreation<AtomOnly<ManagedAtom>> | TimelineStateDisposal<AtomOnly<ManagedAtom>> | TimelineTransactionUpdate;
+//#endregion
+//#region src/main/dispose-state.d.ts
+/**
+* @public
+* Disposes of a state in the implicit store
+* @param token - The token of the state to dispose
+* @overload Default
+*/
+declare function disposeState(token: ReadableToken<any>): void;
+/**
+* @public
+* Disposes of a state family in the implicit store
+* @param token - The token of the state family to dispose
+* @param key - The unique key of the state to dispose
+*/
+declare function disposeState<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K): void;
+
+//#endregion
+//#region src/main/find-state.d.ts
+/**
+* @public
+* Finds a {@link MutableAtomToken} in the store
+* @param token - A {@link MutableAtomFamilyToken}
+* @param key - The key of the state
+* @returns
+* The current value of the state
+* @overload Mutable Atom
+*/
+declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>;
+/**
+* @public
+* Finds a state in the store
+* @param token - The token of the state family
+* @param key - The key of the state
+* @returns
+* The current value of the state
+* @overload Regular Atom
+*/
+declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
+/**
+* @public
+* Finds a state in the store
+* @param token - The token of the state family
+* @param key - The key of the state
+* @returns
+* The current value of the state
+* @overload Writable Selector
+*/
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K>;
+/**
+* @public
+* Finds a state in the store
+* @param token - The token of the state family
+* @param key - The key of the state
+* @returns
+* The current value of the state
+* @overload Readonly Selector
+*/
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K>;
+/**
+* @public
+* Finds a state in the store
+* @param token - The token of the state family
+* @param key - The key of the state
+* @returns
+* The current value of the state
+* @overload Writable State
+*/
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K>;
+/**
+* @public
+* Finds a {@link ReadableToken} in the store
+* @param token - A {@link ReadableFamilyToken}
+* @param key - The key of the state
+* @returns
+* The current value of the state
+* @overload Unknown
+* @default
+*/
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
+
+//#endregion
+//#region src/main/get-state.d.ts
+/**
+* @public
+* Get the current value of a state
+* @param token - The token of the state to get
+* @return The current value of the state
+* @overload Default
+* @default
+*/
+declare function getState<T>(token: ReadableToken<T>): T;
+/**
+* @public
+* Get the current value of a state family
+* @param token - The token of a state family
+* @param key - The unique key of the state to get
+* @return The current value of the state
+* @overload Streamlined
+*/
+declare function getState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): T;
+
+//#endregion
+//#region src/main/join.d.ts
+interface JoinOptions<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> extends JunctionSchemaBase<ASide, BSide>, Partial<JunctionEntriesBase<AType, BType, Content>> {
+  readonly key: string;
+  readonly cardinality: Cardinality;
+  readonly isAType: Refinement<string, AType>;
+  readonly isBType: Refinement<string, BType>;
+}
+//#endregion
+//#region src/main/logger.d.ts
+declare const LoggerIconDictionary: {
+  readonly "⌛": "Timeline event fully captured";
+  readonly "⏩": "Timeline redo";
+  readonly "⏪": "Timeline undo";
+  readonly "⏭️": "Transaction redo";
+  readonly "⏮️": "Transaction undo";
+  readonly "⏳": "Timeline event partially captured";
+  readonly "⏹️": "Time-travel complete";
+  readonly "✅": "Realtime transaction success";
+  readonly "✨": "Computation complete";
+  readonly "❌": "Conflict prevents attempted action";
+  readonly "⭕": "Operation start";
+  readonly "🔴": "Operation complete";
+  readonly "❗": "Operation blocked";
+  readonly "🟢": "Operation unblocked";
+  readonly "🐞": "Possible bug in AtomIO";
+  readonly "👀": "Subscription added";
+  readonly "👋": "Greeting";
+  readonly "👍": "Realtime acknowledgment";
+  readonly "👪": "Family member added";
+  readonly "💁": "Notice";
+  readonly "💥": "Caught";
+  readonly "📁": "Stow update";
+  readonly "📃": "Copy mutable";
+  readonly "📖": "Read state";
+  readonly "📝": "Write state";
+  readonly "📢": "Notify subscribers";
+  readonly "🔄": "Realtime transaction synchronized";
+  readonly "🔌": "Register dependency";
+  readonly "🔍": "Discover root";
+  readonly "🔥": "Delete state";
+  readonly "🔧": "Create mutable atom";
+  readonly "🔨": "Create immutable atom";
+  readonly "🗑": "Evict cached value";
+  readonly "🙈": "Subscription canceled";
+  readonly "🚀": "Performance measure";
+  readonly "🛄": "Apply transaction";
+  readonly "🛠️": "Install atom into store";
+  readonly "🛫": "Begin transaction";
+  readonly "🛬": "Complete transaction";
+  readonly "🧮": "Computing selector";
+  readonly "🧹": "Prepare to evict";
+  readonly "🪂": "Abort transaction";
+  readonly "🤞": "Realtime optimistic update enqueued";
+  readonly "👈": "Realtime confirmed update enqueued";
+  readonly "🧑‍⚖️": "Realtime update beginning reconciliation";
+  readonly "🛎️": "Realtime transaction received";
+  readonly "🔭": "Determining realtime perspective";
+  readonly "🖌": "Redacting realtime update";
+  readonly "👁": "Determining perspective";
+};
+type LoggerIcon = keyof typeof LoggerIconDictionary;
+type TokenDenomination = `atom_family` | `atom` | `continuity` | `molecule_family` | `molecule` | `mutable_atom_family` | `mutable_atom` | `readonly_selector_family` | `readonly_selector` | `selector_family` | `selector` | `state` | `timeline` | `transaction` | `unknown`;
+declare const LOG_LEVELS: readonly ["info", "warn", "error"];
+type LogLevel = (typeof LOG_LEVELS)[number];
+type LogFn = (icon: LoggerIcon, denomination: TokenDenomination, tokenKey: string, message: string, ...rest: unknown[]) => void;
+type LogFilter = (...params: Parameters<LogFn>) => boolean;
+type Logger = Record<LogLevel, LogFn>;
+declare class AtomIOLogger implements Logger {
+  logLevel: `error` | `info` | `warn` | null;
+  private readonly filter;
+  private readonly logger;
+  constructor(logLevel: `error` | `info` | `warn` | null, filter?: LogFilter, logger?: Logger);
+  error: LogFn;
+  info: LogFn;
+  warn: LogFn;
+}
+
+//#endregion
+//#region src/main/realm.d.ts
+declare const $claim: unique symbol;
+type Claim<K extends Canonical> = K & {
+  [$claim]?: true;
+};
+declare class Realm<H extends Hierarchy> {
+  store: Store;
+  constructor(store?: Store);
+  allocate<V extends Vassal<H>, A extends Above<V, H>>(provenance: A, key: V, attachmentStyle?: `all` | `any`): Claim<V>;
+  fuse<C extends CompoundFrom<H>, T extends (C extends CompoundTypedKey<infer t, any, any> ? t : never), A extends (C extends CompoundTypedKey<any, infer v, any> ? v : never), B extends (C extends CompoundTypedKey<any, any, infer m> ? m : never)>(type: T, reagentA: SingularTypedKey<A>, reagentB: SingularTypedKey<B>): Claim<CompoundTypedKey<T, A, B>>;
+  deallocate<V extends Vassal<H>>(claim: Claim<V>): void;
+  claim<V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): Claim<V>;
+}
+declare class Anarchy {
+  store: Store;
+  realm: Realm<any>;
+  constructor(store?: Store);
+  allocate(provenance: Canonical, key: Canonical, attachmentStyle?: `all` | `any`): void;
+  deallocate(key: Canonical): void;
+  claim(newProvenance: Canonical, key: Canonical, exclusive?: `exclusive`): void;
+}
+declare const T$ = "T$";
+type T$ = typeof T$;
+type TypeTag<T extends string> = `${T$}--${T}`;
+type SingularTypedKey<T extends string = string> = `${T}::${string}`;
+type CompoundTypedKey<A extends string = string, B extends string = string, C extends string = string> = `${TypeTag<A>}==${SingularTypedKey<B>}++${SingularTypedKey<C>}`;
+type TypedKey<A extends string = string, B extends string = string, C extends string = string> = CompoundTypedKey<A, B, C> | SingularTypedKey<A>;
+type Scope = SingularTypedKey[];
+type MutualFealty = {
+  above: Scope;
+  below: CompoundTypedKey;
+};
+type ExclusiveFealty = {
+  above: TypedKey | `root`;
+  below: Scope;
+};
+type Fealty = ExclusiveFealty | MutualFealty;
+type Hierarchy<F extends Fealty[] = Fealty[]> = Each<F>;
+type Vassal<H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : H[K] extends {
+  below: Array<infer V>;
+} ? V extends TypedKey ? V : never : never }[keyof H];
+type Above<TK extends TypedKey, H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? TK extends H[K][`below`] ? H[K][`above`] : never : H[K] extends {
+  below: Array<infer V>;
+} ? TK extends V ? H[K] extends ExclusiveFealty ? H[K][`above`] : never : never : never }[keyof H];
+type CompoundFrom<H extends Hierarchy> = { [K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : never }[keyof H];
+
+//#endregion
+//#region src/main/set-state.d.ts
+/**
+* @public
+* A function that sets the value of a state.
+* @param oldValue - The current value of the state.
+* @returns
+* The new value of the state.
+*/
+type Setter<T, New extends T> = (oldValue: T) => New;
+/**
+* @public
+* Set the value of a state into the implicit store.
+* @param token - An atom or writable selector token.
+* @param value - The new value of the state.
+* @overload Default
+* @default
+*/
+declare function setState<T, New extends T>(token: WritableToken<T>, value: New | Setter<T, New>): void;
+/**
+* @public
+* Set the value of a state into the implicit store.
+* @param token - An atom family or writable selector family token.
+* @param key - The unique key of the state to set.
+* @param value - The new value of the state.
+* @overload Streamlined
+*/
+declare function setState<T, K extends Canonical, New extends T, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, value: New | Setter<T, New>): void;
+
+//#endregion
+//#region src/main/silo.d.ts
+
+//#endregion
+//#region src/main/subscribe.d.ts
+type StateUpdate<T> = {
+  newValue: T;
+  oldValue: T;
+};
+type KeyedStateUpdate<T> = Flat<StateUpdate<T> & {
+  key: string;
+  type: `atom_update` | `selector_update`;
+  family?: FamilyMetadata;
+}>;
+//#endregion
+//#region src/main/validators.d.ts
+type TokenType<Comparison extends ReadableFamilyToken<any, any> | ReadableToken<any>> = Comparison extends ReadableToken<infer RepresentedValue> ? RepresentedValue : Comparison extends ReadableFamilyToken<infer RepresentedValue, any> ? RepresentedValue : never;
+/** @public */
+type RegularAtomToken<T, K extends Canonical = any> = {
+  /** The unique identifier of the atom. */
+  key: string;
+  /** Discriminator. */
+  type: `atom`;
+  /** Present if the atom belongs to a family. */
+  family?: FamilyMetadata<K>;
+  /** Never present. This is a marker that preserves the type of the atom's value. */
+  __T?: T;
+};
+/** @public */
+type MutableAtomToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical = any> = {
+  /** The unique identifier of the atom. */
+  key: string;
+  /** Discriminator. */
+  type: `mutable_atom`;
+  /** Present if the atom belongs to a family. */
+  family?: FamilyMetadata<K>;
+  /** Never present. This is a marker that preserves the JSON form of the atom's transceiver value. */
+  __J?: J;
+  /** Never present. This is a marker that preserves the type of the atom's transceiver value. */
+  __U?: T extends Transceiver<infer Update> ? Update : never;
+};
+/** @public */
+type AtomToken<T, K extends Canonical = any> = MutableAtomToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomToken<T, K>;
+/** @public */
+type WritableSelectorToken<T, K extends Canonical = any> = {
+  /** The unique identifier of the selector. */
+  key: string;
+  /** Discriminator. */
+  type: `selector`;
+  /** Present if the selector belongs to a family. */
+  family?: FamilyMetadata<K>;
+  /** Never present. This is a marker that preserves the type of the selector's value. */
+  __T?: T;
+};
+/** @public */
+type ReadonlySelectorToken<T, K extends Canonical = any> = {
+  /** The unique identifier of the selector. */
+  key: string;
+  /** Discriminator. */
+  type: `readonly_selector`;
+  /** Present if the selector belongs to a family. */
+  family?: FamilyMetadata<K>;
+  /** Never present. This is a marker that preserves the type of the selector's value. */
+  __T?: T;
+};
+/** @public */
+type SelectorToken<T, K extends Canonical = any> = ReadonlySelectorToken<T, K> | WritableSelectorToken<T, K>;
+/**
+* @public
+* These states can be set.
+*/
+type WritableToken<T, K extends Canonical = any> = AtomToken<T, K> | WritableSelectorToken<T, K>;
+/**
+* @public
+* These states cannot be set.
+*/
+type ReadableToken<T, K extends Canonical = any> = AtomToken<T, K> | SelectorToken<T, K>;
+/**
+* @public
+* States belonging to this family can be set.
+*/
+type WritableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
+/**
+* @public
+* States belonging to this family cannot be set.
+*/
+type ReadableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | SelectorFamilyToken<T, K>;
+/**
+* @public
+* Identifies a state's connection to its family.
+*/
+type FamilyMetadata<K extends Canonical = any> = {
+  /** The family's unique key. */
+  key: string;
+  /** The family member's unique identifier, in the form of a string. */
+  subKey: stringified<K>;
+};
+
+//#endregion
+//#region ../atom.io/dist/json/index.d.ts
+//#endregion
+//#region src/json/index.d.ts
+type primitive = boolean | number | string | null;
+declare namespace Json {
+  namespace Tree {
+    type Array<Element = unknown> = ReadonlyArray<Element>;
+    type Object<K extends string = string, V = unknown> = Record<K, V>;
+    type Fork = Array | Object;
+    type Leaf = primitive;
+    type Node = Fork | Leaf;
+  }
+  type Serializable = primitive | Readonly<{
+    [key: string]: Serializable;
+  }> | ReadonlyArray<Serializable>;
+  type Object<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
+  type Array<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
+}
+type stringified<J extends Json.Serializable> = J extends string ? `"${J}"` : J extends number ? `${J}` : J extends true ? `true` : J extends false ? `false` : J extends boolean ? `false` | `true` : J extends null ? `null` : string & {
+  __json?: J;
+};
+type Canonical = primitive | ReadonlyArray<Canonical>;
+type JsonInterface<T, J extends Json.Serializable = Json.Serializable> = {
+  toJson: (t: T) => J;
+  fromJson: (json: J) => T;
+};
+
+//#endregion
+//#region ../atom.io/dist/internal/index.d.ts
+//#region src/internal/store/circular-buffer.d.ts
+declare class CircularBuffer<T> {
+  protected _buffer: T[];
+  protected _index: number;
+  constructor(array: T[]);
+  constructor(length: number);
+  get buffer(): ReadonlyArray<T | undefined>;
+  get index(): number;
+  add(item: T): void;
+  copy(): CircularBuffer<T>;
+}
+
+//#endregion
+//#region src/internal/store/counterfeit.d.ts
+
+//#endregion
+//#region src/internal/utility-types.d.ts
+type Func = (...parameters: any[]) => any;
+type Flat<R extends { [K in PropertyKey]: any }> = { [K in keyof R]: R[K] };
+type Count<N extends number, A extends any[] = []> = [...A, any][`length`] extends N ? A[`length`] : A[`length`] | Count<N, [...A, any]>;
+type Each<E extends any[]> = { [P in Count<E[`length`]>]: E[P] };
+type Refinement<A, B extends A> = (a: A) => a is B;
+
+//#endregion
+//#region src/internal/junction.d.ts
+type JunctionEntriesBase<AType extends string, BType extends string, Content extends Json.Object | null> = {
+  readonly relations: ([AType, BType[]] | [BType, AType[]])[];
+  readonly contents: [string, Content][];
+};
+interface JunctionEntries<AType extends string, BType extends string, Content extends Json.Object | null> extends Json.Object, JunctionEntriesBase<AType, BType, Content> {}
+type JunctionSchemaBase<ASide extends string, BSide extends string> = {
+  readonly between: [a: ASide, b: BSide];
+  readonly cardinality: `1:1` | `1:n` | `n:n`;
+};
+interface JunctionSchema<ASide extends string, BSide extends string> extends Json.Object, JunctionSchemaBase<ASide, BSide> {}
+type BaseExternalStoreConfiguration = {
+  addRelation: (a: string, b: string) => void;
+  deleteRelation: (a: string, b: string) => void;
+  replaceRelationsSafely: (a: string, bs: string[]) => void;
+  replaceRelationsUnsafely: (a: string, bs: string[]) => void;
+  getRelatedKeys(key: string): Set<string> | undefined;
+  has: (a: string, b?: string) => boolean;
+};
+type ExternalStoreWithContentConfiguration<Content extends Json.Object> = {
+  getContent: (contentKey: string) => Content | undefined;
+  setContent: (contentKey: string, content: Content) => void;
+  deleteContent: (contentKey: string) => void;
+};
+type Empty<Obj extends object> = { [Key in keyof Obj]?: undefined };
+type ExternalStoreConfiguration<Content extends Json.Object | null> = Content extends Json.Object ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Json.Object>>;
+type JunctionAdvancedConfiguration<AType extends string, BType extends string, Content extends Json.Object | null> = {
+  warn?: (...args: any[]) => void;
+  externalStore?: ExternalStoreConfiguration<Content>;
+  isAType?: Refinement<string, AType>;
+  isBType?: Refinement<string, BType>;
+  isContent?: Refinement<unknown, Content>;
+  makeContentKey?: (a: AType, b: BType) => string;
+};
+type JunctionJSON<ASide extends string, AType extends string, BSide extends string, BType extends string, Content extends Json.Object | null> = JunctionEntries<AType, BType, Content> & JunctionSchema<ASide, BSide>;
+declare class Junction<ASide extends string, AType extends string, BSide extends string, BType extends string, Content extends Json.Object | null = null> {
+  readonly a: ASide;
+  readonly b: BSide;
+  readonly cardinality: `1:1` | `1:n` | `n:n`;
+  readonly relations: Map<AType | BType, Set<AType> | Set<BType>>;
+  readonly contents: Map<string, Content>;
+  isAType?: Refinement<string, AType> | null;
+  isBType?: Refinement<string, BType> | null;
+  isContent: Refinement<unknown, Content> | null;
+  makeContentKey: (a: AType, b: BType) => string;
+  warn?: (...args: any[]) => void;
+  getRelatedKeys(key: AType): Set<BType> | undefined;
+  getRelatedKeys(key: BType): Set<AType> | undefined;
+  getRelatedKeys(key: AType | BType): Set<AType> | Set<BType> | undefined;
+  protected addRelation(a: AType, b: BType): void;
+  protected deleteRelation(a: AType, b: BType): void;
+  protected replaceRelationsUnsafely(a: AType, bs: BType[]): void;
+  protected replaceRelationsUnsafely(b: BType, as: AType[]): void;
+  protected replaceRelationsSafely(a: AType, bs: BType[]): void;
+  protected replaceRelationsSafely(b: BType, as: AType[]): void;
+  protected getContentInternal(contentKey: string): Content | undefined;
+  protected setContent(contentKey: string, content: Content): void;
+  protected deleteContent(contentKey: string): void;
+  constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<NoInfer<AType>, NoInfer<BType>, Content>>, config?: JunctionAdvancedConfiguration<AType, BType, Content>);
+  toJSON(): JunctionJSON<ASide, AType, BSide, BType, Content>;
+  set(a: AType, ...rest: Content extends null ? [b: BType] : [b: BType, content: Content]): this;
+  set(relation: { [Key in ASide]: AType } & { [Key in BSide]: BType }, ...rest: Content extends null ? [] | [void?: undefined] : [content: Content]): this;
+  delete(a: AType, b?: BType): this;
+  delete(b: BType, a?: AType): this;
+  delete(relation: { [Key in ASide]: AType } | { [Key in BSide]: BType } | ({ [Key in ASide]: AType } & { [Key in BSide]: BType }), b?: undefined): this;
+  getRelatedKey(key: AType): BType | undefined;
+  getRelatedKey(key: BType): AType | undefined;
+  replaceRelations(a: AType, relations: Content extends null ? BType[] : Record<BType, Content>, config?: {
+    reckless: boolean;
+  }): this;
+  replaceRelations(b: BType, relations: Content extends null ? AType[] : Record<AType, Content>, config?: {
+    reckless: boolean;
+  }): this;
+  getContent(a: AType, b: BType): Content | undefined;
+  getRelationEntries(input: Record<ASide, AType>): [BType, Content][];
+  getRelationEntries(input: Record<BSide, BType>): [AType, Content][];
+  has(a: AType, b?: BType): boolean;
+  has(b: BType, a?: AType): boolean;
+}
+
+//#endregion
+//#region src/internal/transaction/abort-transaction.d.ts
+
+//#endregion
+//#region src/internal/subject.d.ts
+declare class Subject<T> {
+  Subscriber: (value: T) => void;
+  subscribers: Map<string, this[`Subscriber`]>;
+  subscribe(key: string, subscriber: this[`Subscriber`]): () => void;
+  private unsubscribe;
+  next(value: T): void;
+}
+declare class StatefulSubject<T> extends Subject<T> {
+  state: T;
+  constructor(initialState: T);
+  next(value: T): void;
+}
+
+//#endregion
+//#region src/internal/transaction/create-transaction.d.ts
+type Transaction<F extends Func> = {
+  key: string;
+  type: `transaction`;
+  install: (store: Store) => void;
+  subject: Subject<TransactionUpdate<F>>;
+  run: (parameters: Parameters<F>, id?: string) => ReturnType<F>;
+};
+type TransactionProgress<F extends Func> = {
+  phase: `applying` | `building`;
+  update: TransactionUpdate<F>;
+  toolkit: ActorToolkit;
+};
+type TransactionEpoch = {
+  epoch: Map<string, number>;
+  actionContinuities: Junction<`continuity`, string, `action`, string>;
+};
+
+//#endregion
+//#region src/internal/store/deposit.d.ts
+
+//#endregion
+//#region src/internal/molecule.d.ts
+type Molecule<K extends Canonical> = {
+  readonly key: K;
+  readonly stringKey: stringified<K>;
+  readonly dependsOn: `all` | `any`;
+};
+//#endregion
+//#region src/internal/join/join-internal.d.ts
+type JoinStateFamilies<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[AType, Content] | null, BType> } & { readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[BType, Content] | null, AType> } : {}) & { readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType | null, BType> } & { readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType | null, AType> } : Cardinality extends `1:n` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[AType, Content] | null, BType> } & { readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[BType, Content][], AType> } : {}) & { readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType | null, BType> } & { readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType> } : Cardinality extends `n:n` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[AType, Content][], BType> } & { readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[BType, Content][], AType> } : {}) & { readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType[], BType> } & { readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType> } : never;
+declare class Join<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null = null, ContentKey extends CompoundTypedKey<`content`, ASide, BSide> = CompoundTypedKey<`content`, ASide, BSide>> {
+  private toolkit;
+  options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>;
+  defaultContent: Content | undefined;
+  molecules: Map<string, Molecule<any>>;
+  relations: Junction<ASide, AType, BSide, BType, Content>;
+  states: JoinStateFamilies<ASide, AType, BSide, BType, Cardinality, Content>;
+  core: {
+    relatedKeysAtoms: MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
+  };
+  transact(toolkit: SetterToolkit, run: (join: Join<ASide, AType, BSide, BType, Cardinality, Content>) => void): void;
+  store: Store;
+  realm: Anarchy;
+  [Symbol.dispose](): void;
+  constructor(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content | undefined, store?: Store);
+}
+
+//#endregion
+//#region src/internal/join/get-join.d.ts
+
+//#endregion
+//#region src/internal/lineage.d.ts
+interface Lineage {
+  parent: typeof this | null;
+  child: typeof this | null;
+}
+//#endregion
+//#region src/internal/operation.d.ts
+type OperationProgress = {
+  open: false;
+} | {
+  open: true;
+  done: Set<string>;
+  prev: Map<string, any>;
+  time: number;
+  token: WritableToken<any>;
+};
+//#endregion
+//#region src/internal/timeline/create-timeline.d.ts
+type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = Flat<StateUpdate<TokenType<ManagedAtom>> & {
+  key: string;
+  type: `atom_update`;
+  timestamp: number;
+  family?: FamilyMetadata;
+}>;
+type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
+  key: string;
+  type: `selector_update`;
+  timestamp: number;
+  atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[];
+};
+type TimelineTransactionUpdate = Flat<TransactionUpdate<Func> & {
+  key: string;
+  type: `transaction_update`;
+  timestamp: number;
+}>;
+type TimelineStateCreation<T extends ReadableToken<any>> = Flat<StateCreation<T> & {
+  timestamp: number;
+}>;
+type TimelineStateDisposal<T extends ReadableToken<any>> = Flat<StateDisposal<T> & {
+  timestamp: number;
+}>;
+type TimelineMoleculeCreation = Flat<MoleculeCreation & {
+  timestamp: number;
+}>;
+type TimelineMoleculeDisposal = Flat<MoleculeDisposal & {
+  timestamp: number;
+}>;
+type Timeline<ManagedAtom extends TimelineManageable> = {
+  type: `timeline`;
+  key: string;
+  at: number;
+  shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<ManagedAtom>) => boolean;
+  timeTraveling: `into_future` | `into_past` | null;
+  history: TimelineUpdate<ManagedAtom>[];
+  selectorTime: number | null;
+  transactionKey: string | null;
+  install: (store: Store) => void;
+  subject: Subject<TimelineUpdate<ManagedAtom> | `redo` | `undo`>;
+  subscriptions: Map<string, () => void>;
+};
+//#endregion
+//#region src/internal/store/store.d.ts
+declare class Store implements Lineage {
+  parent: Store | null;
+  child: Store | null;
+  valueMap: Map<string, any>;
+  defaults: Map<string, any>;
+  atoms: Map<string, Atom<any>>;
+  selectors: Map<string, WritableSelector<any>>;
+  readonlySelectors: Map<string, ReadonlySelector<any>>;
+  atomsThatAreDefault: Set<string>;
+  selectorAtoms: Junction<`selectorKey`, string, `atomKey`, string>;
+  selectorGraph: Junction<`upstreamSelectorKey`, string, `downstreamSelectorKey`, string, {
+    source: string;
+  }>;
+  trackers: Map<string, Tracker<Transceiver<any>>>;
+  families: Map<string, MutableAtomFamily<any, any, any> | ReadonlySelectorFamily<any, any> | RegularAtomFamily<any, any> | WritableSelectorFamily<any, any>>;
+  joins: Map<string, Join<any, any, any, any, any, any>>;
+  transactions: Map<string, Transaction<Func>>;
+  transactionMeta: TransactionEpoch | TransactionProgress<Func>;
+  timelines: Map<string, Timeline<any>>;
+  timelineTopics: Junction<`timelineKey`, string, `topicKey`, string, {
+    topicType: `atom_family` | `atom` | `molecule_family` | `molecule`;
+  }>;
+  disposalTraces: CircularBuffer<{
+    key: string;
+    trace: string;
+  }>;
+  molecules: Map<string, Molecule<Canonical>>;
+  moleculeJoins: Junction<`moleculeKey`, stringified<Canonical>, `joinKey`, string>;
+  moleculeGraph: Junction<`upstreamMoleculeKey`, stringified<Canonical> | `root`, `downstreamMoleculeKey`, stringified<Canonical>, {
+    source: stringified<Canonical>;
+  }>;
+  moleculeData: Junction<`moleculeKey`, stringified<Canonical>, `stateFamilyKey`, string>;
+  miscResources: Map<string, Disposable>;
+  on: StoreEventCarrier;
+  operation: OperationProgress;
+  config: {
+    name: string;
+    lifespan: `ephemeral` | `immortal`;
+  };
+  loggers: AtomIOLogger[];
+  logger: Logger;
+  constructor(config: Store[`config`], store?: Store | null);
+}
+type StoreEventCarrier = {
+  atomCreation: Subject<AtomToken<unknown>>;
+  atomDisposal: Subject<AtomToken<unknown>>;
+  selectorCreation: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
+  selectorDisposal: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
+  timelineCreation: Subject<TimelineToken<unknown>>;
+  transactionCreation: Subject<TransactionToken<Func>>;
+  transactionApplying: StatefulSubject<TransactionProgress<Func> | null>;
+  operationClose: Subject<OperationProgress>;
+  moleculeCreation: Subject<MoleculeCreation>;
+  moleculeDisposal: Subject<MoleculeDisposal>;
+};
+declare global {
+  var ATOM_IO_IMPLICIT_STORE: Store | undefined;
+}
+//#endregion
+//#region src/internal/mutable/transceiver.d.ts
+interface Transceiver<S extends Json.Serializable> {
+  do: (update: S) => number | `OUT_OF_RANGE` | null;
+  undo: (update: S) => void;
+  subscribe: (key: string, fn: (update: S) => void) => () => void;
+  cacheUpdateNumber: number;
+  getUpdateNumber: (update: S) => number;
+}
+type TransceiverMode = `playback` | `record` | `transaction`;
+//#endregion
+//#region src/internal/mutable/tracker.d.ts
+/**
+* @internal Give the tracker a transceiver state and a store, and it will
+* subscribe to the transceiver's inner value. When the inner value changes,
+* the tracker will update its own state to reflect the change.
+*/
+declare class Tracker<Mutable extends Transceiver<any>> {
+  private initializeState;
+  private unsubscribeFromInnerValue;
+  private unsubscribeFromState;
+  private observeCore;
+  private updateCore;
+  mutableState: MutableAtomToken<Mutable, Json.Serializable>;
+  latestUpdateState: RegularAtomToken<(Mutable extends Transceiver<infer Signal> ? Signal : never) | null>;
+  [Symbol.dispose]: () => void;
+  constructor(mutableState: MutableAtomToken<Mutable, Json.Serializable>, store: Store);
+}
+
+//#endregion
+//#region src/internal/mutable/tracker-family.d.ts
+
+//#endregion
+//#region src/internal/future.d.ts
+/**
+* A Promise whose incoming value can be hot swapped.
+* @internal
+* @private
+* @typeParam T The type of the value that the promise will resolve to.
+*
+* @remarks
+* Can be constructed like a Promise, or from an existing Promise.
+*/
+declare class Future<T> extends Promise<T> {
+  private fate;
+  private resolve;
+  private reject;
+  done: boolean;
+  constructor(executor: Promise<T> | ((resolve: (value: T) => void, reject: (reason?: any) => void) => void));
+  private pass;
+  private fail;
+  use(value: Promise<T> | T): void;
+}
+
+//#endregion
+//#region src/internal/caching.d.ts
+
+//#endregion
+//#region src/internal/get-environment-data.d.ts
+type EnvironmentData = {
+  store: Store;
+};
+//#endregion
+//#region src/internal/index.d.ts
+type AtomIOState = {
+  key: string;
+  family?: FamilyMetadata;
+  install: (store: Store) => void;
+  subject: Subject<{
+    newValue: any;
+    oldValue: any;
+  }>;
+};
+type RegularAtom<T> = AtomIOState & {
+  type: `atom`;
+  default: T | (() => T);
+  cleanup?: () => void;
+};
+type MutableAtom<T extends Transceiver<any>, J extends Json.Serializable> = AtomIOState & JsonInterface<T, J> & {
+  type: `mutable_atom`;
+  default: () => T;
+  cleanup?: () => void;
+};
+type Atom<T> = RegularAtom<T> | (T extends Transceiver<any> ? MutableAtom<T, any> : never);
+type WritableSelector<T> = AtomIOState & {
+  type: `selector`;
+  get: () => T;
+  set: (newValue: T | ((oldValue: T) => T)) => void;
+};
+type ReadonlySelector<T> = AtomIOState & {
+  type: `readonly_selector`;
+  get: () => T;
+};
+type RegularAtomFamily<T, K extends Canonical> = RegularAtomFamilyToken<T, K> & {
+  (key: K): RegularAtomToken<T>;
+  subject: Subject<StateCreation<AtomToken<T>> | StateDisposal<AtomToken<T>>>;
+  install: (store: Store) => void;
+  internalRoles: string[] | undefined;
+};
+type MutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = JsonInterface<T, J> & MutableAtomFamilyToken<T, J, K> & {
+  (key: K): MutableAtomToken<T, J>;
+  subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>;
+  install: (store: Store) => void;
+  internalRoles: string[] | undefined;
+};
+type WritableSelectorFamily<T, K extends Canonical> = WritableSelectorFamilyToken<T, K> & ((key: K) => WritableSelectorToken<T>) & {
+  default: (key: K) => T;
+  subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>;
+  install: (store: Store) => void;
+  internalRoles: string[] | undefined;
+};
+type ReadonlySelectorFamily<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> & ((key: K) => ReadonlySelectorToken<T>) & {
+  default: (key: K) => T;
+  subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>;
+  install: (store: Store) => void;
+  internalRoles: string[] | undefined;
+};
+
+//#endregion
+//#region ../atom.io/dist/realtime-server/index.d.ts
+//#endregion
+//#region src/realtime-server/ipc-sockets/custom-socket.d.ts
+type Events = Json.Object<string, Json.Serializable[]>;
+declare class CustomSocket<I extends Events, O extends Events> implements Socket {
+  protected listeners: Map<keyof O, Set<(...args: Json.Array) => void>>;
+  protected globalListeners: Set<(event: string, ...args: Json.Array) => void>;
+  protected handleEvent<Event extends keyof I>(event: string, ...args: I[Event]): void;
+  id: string;
+  emit: <Event extends keyof I>(event: Event, ...args: I[Event]) => CustomSocket<I, O>;
+  constructor(emit: <Event extends keyof I>(event: Event, ...args: I[Event]) => CustomSocket<I, O>);
+  on<Event extends keyof O>(event: Event, listener: (...args: O[Event]) => void): this;
+  onAny(listener: (event: string, ...args: Json.Array) => void): this;
+  off<Event extends keyof O>(event: Event, listener?: (...args: O[Event]) => void): this;
+  offAny(listener: (event: string, ...args: Json.Array) => void): this;
+}
+
+//#endregion
+//#region src/realtime-server/ipc-sockets/child-socket.d.ts
+declare class ChildSocket<I extends Events, O extends Events> extends CustomSocket<I, O> {
+  protected incompleteData: string;
+  protected unprocessedEvents: string[];
+  protected incompleteLog: string;
+  protected unprocessedLogs: string[];
+  id: string;
+  process: ChildProcessWithoutNullStreams;
+  key: string;
+  logger: Pick<Console, `error` | `info` | `warn`>;
+  protected handleLog(arg: Json.Serializable): void;
+  constructor(process: ChildProcessWithoutNullStreams, key: string, logger?: Pick<Console, `error` | `info` | `warn`>);
+}
+
+//#endregion
+//#region src/realtime-server/ipc-sockets/parent-socket.d.ts
+
+//#endregion
+//#region src/realtime-server/index.d.ts
+type Socket = {
+  id: string | undefined;
+  on: (event: string, listener: (...args: Json.Serializable[]) => void) => void;
+  onAny: (listener: (event: string, ...args: Json.Serializable[]) => void) => void;
+  off: (event: string, listener: (...args: Json.Serializable[]) => void) => void;
+  offAny: (listener: (event: string, ...args: Json.Serializable[]) => void) => void;
+  emit: (event: string, ...args: Json.Serializable[]) => void;
+};
+
+//#endregion
+//#region ../safedeposit/dist/safedeposit.d.ts
+//#region src/filesystem-storage.d.ts
+type FilesystemStorageOptions = {
+  path: string;
+  eagerInit?: boolean;
+};
+declare class FilesystemStorage<T extends Record<string, string> = Record<string, string>> implements Storage {
+  rootDir: string;
+  get initialized(): boolean;
+  initialize(): void;
+  constructor(options: FilesystemStorageOptions);
+  getItem<K extends string & keyof T>(key: K): T[K] | null;
+  setItem<K extends string & keyof T>(key: K, value: T[K]): void;
+  removeItem<K extends string & keyof T>(key: K): void;
+  key(index: number): (string & keyof T) | null;
+  clear(): void;
+  get length(): number;
+}
+
+//#endregion
 //#region gen/lnav-format-schema.gen.d.ts
+//#endregion
 declare const lnavFormatSchema: z.ZodObject<{
-    regex: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-        pattern: z.ZodOptional<z.ZodString>;
-        "module-format": z.ZodOptional<z.ZodBoolean>;
-    }, "strict", z.ZodTypeAny, {
-        pattern?: string | undefined;
-        "module-format"?: boolean | undefined;
-    }, {
-        pattern?: string | undefined;
-        "module-format"?: boolean | undefined;
-    }>, z.ZodNever]>>, Record<string, {
-        pattern?: string | undefined;
-        "module-format"?: boolean | undefined;
-    }>, Record<string, {
-        pattern?: string | undefined;
-        "module-format"?: boolean | undefined;
-    }>>>;
-    json: z.ZodOptional<z.ZodBoolean>;
-    "convert-to-local-time": z.ZodOptional<z.ZodBoolean>;
-    "hide-extra": z.ZodOptional<z.ZodBoolean>;
-    multiline: z.ZodOptional<z.ZodBoolean>;
-    "timestamp-divisor": z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
-    "file-pattern": z.ZodOptional<z.ZodString>;
-    converter: z.ZodOptional<z.ZodObject<{
-        type: z.ZodOptional<z.ZodString>;
-        header: z.ZodOptional<z.ZodObject<{
-            expr: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNever]>>, Record<string, string>, Record<string, string>>>;
-            size: z.ZodOptional<z.ZodNumber>;
-        }, "strict", z.ZodTypeAny, {
-            expr?: Record<string, string> | undefined;
-            size?: number | undefined;
-        }, {
-            expr?: Record<string, string> | undefined;
-            size?: number | undefined;
-        }>>;
-        command: z.ZodOptional<z.ZodString>;
-    }, "strict", z.ZodTypeAny, {
-        type?: string | undefined;
-        header?: {
-            expr?: Record<string, string> | undefined;
-            size?: number | undefined;
-        } | undefined;
-        command?: string | undefined;
-    }, {
-        type?: string | undefined;
-        header?: {
-            expr?: Record<string, string> | undefined;
-            size?: number | undefined;
-        } | undefined;
-        command?: string | undefined;
-    }>>;
-    "level-field": z.ZodOptional<z.ZodString>;
-    "level-pointer": z.ZodOptional<z.ZodString>;
-    "timestamp-field": z.ZodOptional<z.ZodString>;
-    "subsecond-field": z.ZodOptional<z.ZodString>;
-    "subsecond-units": z.ZodOptional<z.ZodEnum<["milli", "micro", "nano"]>>;
-    "time-field": z.ZodOptional<z.ZodString>;
-    "body-field": z.ZodOptional<z.ZodString>;
-    url: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
-    title: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    "timestamp-format": z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    "module-field": z.ZodOptional<z.ZodString>;
-    "opid-field": z.ZodOptional<z.ZodString>;
-    opid: z.ZodOptional<z.ZodObject<{
-        subid: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-            format: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                field: z.ZodOptional<z.ZodString>;
-                extractor: z.ZodOptional<z.ZodString>;
-                prefix: z.ZodOptional<z.ZodString>;
-                suffix: z.ZodOptional<z.ZodString>;
-                joiner: z.ZodOptional<z.ZodString>;
-            }, "strict", z.ZodTypeAny, {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }, {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }>, "many">>;
-        }, "strict", z.ZodTypeAny, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }>, z.ZodNever]>>, Record<string, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }>, Record<string, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }>>>;
-        "sub-description": z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-            format: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                field: z.ZodOptional<z.ZodString>;
-                extractor: z.ZodOptional<z.ZodString>;
-                prefix: z.ZodOptional<z.ZodString>;
-                suffix: z.ZodOptional<z.ZodString>;
-                joiner: z.ZodOptional<z.ZodString>;
-            }, "strict", z.ZodTypeAny, {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }, {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }>, "many">>;
-        }, "strict", z.ZodTypeAny, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }>, z.ZodNever]>>, Record<string, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }>, Record<string, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }>>>;
+  regex: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+    pattern: z.ZodOptional<z.ZodString>;
+    "module-format": z.ZodOptional<z.ZodBoolean>;
+  }, "strict", z.ZodTypeAny, {
+    pattern?: string | undefined;
+    "module-format"?: boolean | undefined;
+  }, {
+    pattern?: string | undefined;
+    "module-format"?: boolean | undefined;
+  }>, z.ZodNever]>>, Record<string, {
+    pattern?: string | undefined;
+    "module-format"?: boolean | undefined;
+  }>, Record<string, {
+    pattern?: string | undefined;
+    "module-format"?: boolean | undefined;
+  }>>>;
+  json: z.ZodOptional<z.ZodBoolean>;
+  "convert-to-local-time": z.ZodOptional<z.ZodBoolean>;
+  "hide-extra": z.ZodOptional<z.ZodBoolean>;
+  multiline: z.ZodOptional<z.ZodBoolean>;
+  "timestamp-divisor": z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodNumber]>>;
+  "file-pattern": z.ZodOptional<z.ZodString>;
+  converter: z.ZodOptional<z.ZodObject<{
+    type: z.ZodOptional<z.ZodString>;
+    header: z.ZodOptional<z.ZodObject<{
+      expr: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNever]>>, Record<string, string>, Record<string, string>>>;
+      size: z.ZodOptional<z.ZodNumber>;
     }, "strict", z.ZodTypeAny, {
-        description?: Record<string, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }> | undefined;
-        subid?: string | undefined;
-        "sub-description"?: Record<string, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }> | undefined;
+      expr?: Record<string, string> | undefined;
+      size?: number | undefined;
     }, {
-        description?: Record<string, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }> | undefined;
-        subid?: string | undefined;
-        "sub-description"?: Record<string, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }> | undefined;
+      expr?: Record<string, string> | undefined;
+      size?: number | undefined;
     }>>;
-    "ordered-by-time": z.ZodOptional<z.ZodBoolean>;
-    level: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodNever]>>, Record<string, string | number>, Record<string, string | number>>>;
-    value: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-        kind: z.ZodOptional<z.ZodEnum<["string", "integer", "float", "boolean", "json", "struct", "quoted", "xml"]>>;
-        collate: z.ZodOptional<z.ZodString>;
-        unit: z.ZodOptional<z.ZodObject<{
-            field: z.ZodOptional<z.ZodString>;
-            "scaling-factor": z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-                op: z.ZodOptional<z.ZodEnum<["identity", "multiply", "divide"]>>;
-                value: z.ZodOptional<z.ZodNumber>;
-            }, "strict", z.ZodTypeAny, {
-                value?: number | undefined;
-                op?: "identity" | "multiply" | "divide" | undefined;
-            }, {
-                value?: number | undefined;
-                op?: "identity" | "multiply" | "divide" | undefined;
-            }>, z.ZodNever]>>, Record<string, {
-                value?: number | undefined;
-                op?: "identity" | "multiply" | "divide" | undefined;
-            }>, Record<string, {
-                value?: number | undefined;
-                op?: "identity" | "multiply" | "divide" | undefined;
-            }>>>;
-        }, "strict", z.ZodTypeAny, {
-            field?: string | undefined;
-            "scaling-factor"?: Record<string, {
-                value?: number | undefined;
-                op?: "identity" | "multiply" | "divide" | undefined;
-            }> | undefined;
-        }, {
-            field?: string | undefined;
-            "scaling-factor"?: Record<string, {
-                value?: number | undefined;
-                op?: "identity" | "multiply" | "divide" | undefined;
-            }> | undefined;
-        }>>;
-        identifier: z.ZodOptional<z.ZodBoolean>;
-        "foreign-key": z.ZodOptional<z.ZodBoolean>;
-        hidden: z.ZodOptional<z.ZodBoolean>;
-        "action-list": z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        rewriter: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-    }, "strict", z.ZodTypeAny, {
-        description?: string | undefined;
-        kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
-        collate?: string | undefined;
-        unit?: {
-            field?: string | undefined;
-            "scaling-factor"?: Record<string, {
-                value?: number | undefined;
-                op?: "identity" | "multiply" | "divide" | undefined;
-            }> | undefined;
-        } | undefined;
-        identifier?: boolean | undefined;
-        "foreign-key"?: boolean | undefined;
-        hidden?: boolean | undefined;
-        "action-list"?: string[] | undefined;
-        rewriter?: string | undefined;
-    }, {
-        description?: string | undefined;
-        kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
-        collate?: string | undefined;
-        unit?: {
-            field?: string | undefined;
-            "scaling-factor"?: Record<string, {
-                value?: number | undefined;
-                op?: "identity" | "multiply" | "divide" | undefined;
-            }> | undefined;
-        } | undefined;
-        identifier?: boolean | undefined;
-        "foreign-key"?: boolean | undefined;
-        hidden?: boolean | undefined;
-        "action-list"?: string[] | undefined;
-        rewriter?: string | undefined;
-    }>, z.ZodNever]>>, Record<string, {
-        description?: string | undefined;
-        kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
-        collate?: string | undefined;
-        unit?: {
-            field?: string | undefined;
-            "scaling-factor"?: Record<string, {
-                value?: number | undefined;
-                op?: "identity" | "multiply" | "divide" | undefined;
-            }> | undefined;
-        } | undefined;
-        identifier?: boolean | undefined;
-        "foreign-key"?: boolean | undefined;
-        hidden?: boolean | undefined;
-        "action-list"?: string[] | undefined;
-        rewriter?: string | undefined;
-    }>, Record<string, {
-        description?: string | undefined;
-        kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
-        collate?: string | undefined;
-        unit?: {
-            field?: string | undefined;
-            "scaling-factor"?: Record<string, {
-                value?: number | undefined;
-                op?: "identity" | "multiply" | "divide" | undefined;
-            }> | undefined;
-        } | undefined;
-        identifier?: boolean | undefined;
-        "foreign-key"?: boolean | undefined;
-        hidden?: boolean | undefined;
-        "action-list"?: string[] | undefined;
-        rewriter?: string | undefined;
-    }>>>;
-    tags: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-        paths: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            glob: z.ZodOptional<z.ZodString>;
-        }, "strict", z.ZodTypeAny, {
-            glob?: string | undefined;
-        }, {
-            glob?: string | undefined;
-        }>, "many">>;
-        pattern: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        level: z.ZodOptional<z.ZodEnum<["trace", "debug5", "debug4", "debug3", "debug2", "debug", "info", "stats", "notice", "warning", "error", "critical", "fatal"]>>;
-    }, "strict", z.ZodTypeAny, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        description?: string | undefined;
-        paths?: {
-            glob?: string | undefined;
-        }[] | undefined;
-    }, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        description?: string | undefined;
-        paths?: {
-            glob?: string | undefined;
-        }[] | undefined;
-    }>, z.ZodNever]>>, Record<string, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        description?: string | undefined;
-        paths?: {
-            glob?: string | undefined;
-        }[] | undefined;
-    }>, Record<string, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        description?: string | undefined;
-        paths?: {
-            glob?: string | undefined;
-        }[] | undefined;
-    }>>>;
-    partitions: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-        paths: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            glob: z.ZodOptional<z.ZodString>;
-        }, "strict", z.ZodTypeAny, {
-            glob?: string | undefined;
-        }, {
-            glob?: string | undefined;
-        }>, "many">>;
-        pattern: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        level: z.ZodOptional<z.ZodEnum<["trace", "debug5", "debug4", "debug3", "debug2", "debug", "info", "stats", "notice", "warning", "error", "critical", "fatal"]>>;
-    }, "strict", z.ZodTypeAny, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        description?: string | undefined;
-        paths?: {
-            glob?: string | undefined;
-        }[] | undefined;
-    }, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        description?: string | undefined;
-        paths?: {
-            glob?: string | undefined;
-        }[] | undefined;
-    }>, z.ZodNever]>>, Record<string, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        description?: string | undefined;
-        paths?: {
-            glob?: string | undefined;
-        }[] | undefined;
-    }>, Record<string, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        description?: string | undefined;
-        paths?: {
-            glob?: string | undefined;
-        }[] | undefined;
-    }>>>;
-    action: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodObject<{
-        label: z.ZodOptional<z.ZodString>;
-        "capture-output": z.ZodOptional<z.ZodBoolean>;
-        cmd: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strict", z.ZodTypeAny, {
-        label?: string | undefined;
-        "capture-output"?: boolean | undefined;
-        cmd?: string[] | undefined;
-    }, {
-        label?: string | undefined;
-        "capture-output"?: boolean | undefined;
-        cmd?: string[] | undefined;
-    }>]>, z.ZodNever]>>, Record<string, string | {
-        label?: string | undefined;
-        "capture-output"?: boolean | undefined;
-        cmd?: string[] | undefined;
-    }>, Record<string, string | {
-        label?: string | undefined;
-        "capture-output"?: boolean | undefined;
-        cmd?: string[] | undefined;
-    }>>>;
-    sample: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        description: z.ZodOptional<z.ZodString>;
-        line: z.ZodOptional<z.ZodString>;
-        level: z.ZodOptional<z.ZodEnum<["trace", "debug5", "debug4", "debug3", "debug2", "debug", "info", "stats", "notice", "warning", "error", "critical", "fatal"]>>;
-    }, "strict", z.ZodTypeAny, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        description?: string | undefined;
-        line?: string | undefined;
-    }, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        description?: string | undefined;
-        line?: string | undefined;
-    }>, "many">>;
-    "line-format": z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+    command: z.ZodOptional<z.ZodString>;
+  }, "strict", z.ZodTypeAny, {
+    type?: string | undefined;
+    header?: {
+      expr?: Record<string, string> | undefined;
+      size?: number | undefined;
+    } | undefined;
+    command?: string | undefined;
+  }, {
+    type?: string | undefined;
+    header?: {
+      expr?: Record<string, string> | undefined;
+      size?: number | undefined;
+    } | undefined;
+    command?: string | undefined;
+  }>>;
+  "level-field": z.ZodOptional<z.ZodString>;
+  "level-pointer": z.ZodOptional<z.ZodString>;
+  "timestamp-field": z.ZodOptional<z.ZodString>;
+  "subsecond-field": z.ZodOptional<z.ZodString>;
+  "subsecond-units": z.ZodOptional<z.ZodEnum<["milli", "micro", "nano"]>>;
+  "time-field": z.ZodOptional<z.ZodString>;
+  "body-field": z.ZodOptional<z.ZodString>;
+  url: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString, "many">, z.ZodString]>>;
+  title: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  "timestamp-format": z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+  "module-field": z.ZodOptional<z.ZodString>;
+  "opid-field": z.ZodOptional<z.ZodString>;
+  opid: z.ZodOptional<z.ZodObject<{
+    subid: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+      format: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodOptional<z.ZodString>;
-        "default-value": z.ZodOptional<z.ZodString>;
-        "timestamp-format": z.ZodOptional<z.ZodString>;
-        "min-width": z.ZodOptional<z.ZodNumber>;
-        "auto-width": z.ZodOptional<z.ZodBoolean>;
-        "max-width": z.ZodOptional<z.ZodNumber>;
-        align: z.ZodOptional<z.ZodEnum<["left", "right"]>>;
-        overflow: z.ZodOptional<z.ZodEnum<["abbrev", "truncate", "dot-dot", "last-word"]>>;
-        "text-transform": z.ZodOptional<z.ZodEnum<["none", "uppercase", "lowercase", "capitalize"]>>;
+        extractor: z.ZodOptional<z.ZodString>;
         prefix: z.ZodOptional<z.ZodString>;
         suffix: z.ZodOptional<z.ZodString>;
-    }, "strict", z.ZodTypeAny, {
-        "timestamp-format"?: string | undefined;
+        joiner: z.ZodOptional<z.ZodString>;
+      }, "strict", z.ZodTypeAny, {
         field?: string | undefined;
+        extractor?: string | undefined;
         prefix?: string | undefined;
         suffix?: string | undefined;
-        "default-value"?: string | undefined;
-        "min-width"?: number | undefined;
-        "auto-width"?: boolean | undefined;
-        "max-width"?: number | undefined;
-        align?: "left" | "right" | undefined;
-        overflow?: "abbrev" | "truncate" | "dot-dot" | "last-word" | undefined;
-        "text-transform"?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
-    }, {
-        "timestamp-format"?: string | undefined;
+        joiner?: string | undefined;
+      }, {
         field?: string | undefined;
+        extractor?: string | undefined;
         prefix?: string | undefined;
         suffix?: string | undefined;
-        "default-value"?: string | undefined;
-        "min-width"?: number | undefined;
-        "auto-width"?: boolean | undefined;
-        "max-width"?: number | undefined;
-        align?: "left" | "right" | undefined;
-        overflow?: "abbrev" | "truncate" | "dot-dot" | "last-word" | undefined;
-        "text-transform"?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
-    }>]>, "many">>;
-    "search-table": z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-        pattern: z.ZodOptional<z.ZodString>;
-        glob: z.ZodOptional<z.ZodString>;
-        level: z.ZodOptional<z.ZodEnum<["trace", "debug5", "debug4", "debug3", "debug2", "debug", "info", "stats", "notice", "warning", "error", "critical", "fatal"]>>;
+        joiner?: string | undefined;
+      }>, "many">>;
     }, "strict", z.ZodTypeAny, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        glob?: string | undefined;
+      format?: {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
     }, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        glob?: string | undefined;
+      format?: {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
     }>, z.ZodNever]>>, Record<string, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        glob?: string | undefined;
+      format?: {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
     }>, Record<string, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        glob?: string | undefined;
+      format?: {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
     }>>>;
-    highlights: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
-        pattern: z.ZodOptional<z.ZodString>;
-        color: z.ZodOptional<z.ZodString>;
-        "background-color": z.ZodOptional<z.ZodString>;
-        underline: z.ZodOptional<z.ZodBoolean>;
-        blink: z.ZodOptional<z.ZodBoolean>;
+    "sub-description": z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+      format: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        field: z.ZodOptional<z.ZodString>;
+        extractor: z.ZodOptional<z.ZodString>;
+        prefix: z.ZodOptional<z.ZodString>;
+        suffix: z.ZodOptional<z.ZodString>;
+        joiner: z.ZodOptional<z.ZodString>;
+      }, "strict", z.ZodTypeAny, {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }, {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }>, "many">>;
     }, "strict", z.ZodTypeAny, {
-        pattern?: string | undefined;
-        color?: string | undefined;
-        "background-color"?: string | undefined;
-        underline?: boolean | undefined;
-        blink?: boolean | undefined;
+      format?: {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
     }, {
-        pattern?: string | undefined;
-        color?: string | undefined;
-        "background-color"?: string | undefined;
-        underline?: boolean | undefined;
-        blink?: boolean | undefined;
+      format?: {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
     }>, z.ZodNever]>>, Record<string, {
-        pattern?: string | undefined;
-        color?: string | undefined;
-        "background-color"?: string | undefined;
-        underline?: boolean | undefined;
-        blink?: boolean | undefined;
+      format?: {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
     }>, Record<string, {
-        pattern?: string | undefined;
-        color?: string | undefined;
-        "background-color"?: string | undefined;
-        underline?: boolean | undefined;
-        blink?: boolean | undefined;
+      format?: {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
     }>>>;
-    "file-type": z.ZodOptional<z.ZodEnum<["text", "json", "csv"]>>;
-    "max-unrecognized-lines": z.ZodOptional<z.ZodNumber>;
-}, "strict", z.ZodTypeAny, {
-    level?: Record<string, string | number> | undefined;
-    value?: Record<string, {
-        description?: string | undefined;
-        kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
-        collate?: string | undefined;
-        unit?: {
-            field?: string | undefined;
-            "scaling-factor"?: Record<string, {
-                value?: number | undefined;
-                op?: "identity" | "multiply" | "divide" | undefined;
-            }> | undefined;
-        } | undefined;
-        identifier?: boolean | undefined;
-        "foreign-key"?: boolean | undefined;
-        hidden?: boolean | undefined;
-        "action-list"?: string[] | undefined;
-        rewriter?: string | undefined;
+  }, "strict", z.ZodTypeAny, {
+    description?: Record<string, {
+      format?: {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
     }> | undefined;
-    regex?: Record<string, {
-        pattern?: string | undefined;
-        "module-format"?: boolean | undefined;
+    subid?: string | undefined;
+    "sub-description"?: Record<string, {
+      format?: {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
     }> | undefined;
-    json?: boolean | undefined;
-    "convert-to-local-time"?: boolean | undefined;
-    "hide-extra"?: boolean | undefined;
-    multiline?: boolean | undefined;
-    "timestamp-divisor"?: number | undefined;
-    "file-pattern"?: string | undefined;
-    converter?: {
-        type?: string | undefined;
-        header?: {
-            expr?: Record<string, string> | undefined;
-            size?: number | undefined;
-        } | undefined;
-        command?: string | undefined;
+  }, {
+    description?: Record<string, {
+      format?: {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
+    }> | undefined;
+    subid?: string | undefined;
+    "sub-description"?: Record<string, {
+      format?: {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
+    }> | undefined;
+  }>>;
+  "ordered-by-time": z.ZodOptional<z.ZodBoolean>;
+  level: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodNever]>>, Record<string, string | number>, Record<string, string | number>>>;
+  value: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+    kind: z.ZodOptional<z.ZodEnum<["string", "integer", "float", "boolean", "json", "struct", "quoted", "xml"]>>;
+    collate: z.ZodOptional<z.ZodString>;
+    unit: z.ZodOptional<z.ZodObject<{
+      field: z.ZodOptional<z.ZodString>;
+      "scaling-factor": z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        op: z.ZodOptional<z.ZodEnum<["identity", "multiply", "divide"]>>;
+        value: z.ZodOptional<z.ZodNumber>;
+      }, "strict", z.ZodTypeAny, {
+        value?: number | undefined;
+        op?: "identity" | "multiply" | "divide" | undefined;
+      }, {
+        value?: number | undefined;
+        op?: "identity" | "multiply" | "divide" | undefined;
+      }>, z.ZodNever]>>, Record<string, {
+        value?: number | undefined;
+        op?: "identity" | "multiply" | "divide" | undefined;
+      }>, Record<string, {
+        value?: number | undefined;
+        op?: "identity" | "multiply" | "divide" | undefined;
+      }>>>;
+    }, "strict", z.ZodTypeAny, {
+      field?: string | undefined;
+      "scaling-factor"?: Record<string, {
+        value?: number | undefined;
+        op?: "identity" | "multiply" | "divide" | undefined;
+      }> | undefined;
+    }, {
+      field?: string | undefined;
+      "scaling-factor"?: Record<string, {
+        value?: number | undefined;
+        op?: "identity" | "multiply" | "divide" | undefined;
+      }> | undefined;
+    }>>;
+    identifier: z.ZodOptional<z.ZodBoolean>;
+    "foreign-key": z.ZodOptional<z.ZodBoolean>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    "action-list": z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    rewriter: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+  }, "strict", z.ZodTypeAny, {
+    description?: string | undefined;
+    kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
+    collate?: string | undefined;
+    unit?: {
+      field?: string | undefined;
+      "scaling-factor"?: Record<string, {
+        value?: number | undefined;
+        op?: "identity" | "multiply" | "divide" | undefined;
+      }> | undefined;
     } | undefined;
-    "level-field"?: string | undefined;
-    "level-pointer"?: string | undefined;
-    "timestamp-field"?: string | undefined;
-    "subsecond-field"?: string | undefined;
-    "subsecond-units"?: "milli" | "micro" | "nano" | undefined;
-    "time-field"?: string | undefined;
-    "body-field"?: string | undefined;
-    url?: string | string[] | undefined;
-    title?: string | undefined;
+    identifier?: boolean | undefined;
+    "foreign-key"?: boolean | undefined;
+    hidden?: boolean | undefined;
+    "action-list"?: string[] | undefined;
+    rewriter?: string | undefined;
+  }, {
     description?: string | undefined;
-    "timestamp-format"?: string[] | undefined;
-    "module-field"?: string | undefined;
-    "opid-field"?: string | undefined;
-    opid?: {
-        description?: Record<string, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }> | undefined;
-        subid?: string | undefined;
-        "sub-description"?: Record<string, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }> | undefined;
+    kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
+    collate?: string | undefined;
+    unit?: {
+      field?: string | undefined;
+      "scaling-factor"?: Record<string, {
+        value?: number | undefined;
+        op?: "identity" | "multiply" | "divide" | undefined;
+      }> | undefined;
     } | undefined;
-    "ordered-by-time"?: boolean | undefined;
-    tags?: Record<string, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        description?: string | undefined;
-        paths?: {
-            glob?: string | undefined;
-        }[] | undefined;
-    }> | undefined;
-    partitions?: Record<string, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        description?: string | undefined;
-        paths?: {
-            glob?: string | undefined;
-        }[] | undefined;
-    }> | undefined;
-    action?: Record<string, string | {
-        label?: string | undefined;
-        "capture-output"?: boolean | undefined;
-        cmd?: string[] | undefined;
-    }> | undefined;
-    sample?: {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        description?: string | undefined;
-        line?: string | undefined;
+    identifier?: boolean | undefined;
+    "foreign-key"?: boolean | undefined;
+    hidden?: boolean | undefined;
+    "action-list"?: string[] | undefined;
+    rewriter?: string | undefined;
+  }>, z.ZodNever]>>, Record<string, {
+    description?: string | undefined;
+    kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
+    collate?: string | undefined;
+    unit?: {
+      field?: string | undefined;
+      "scaling-factor"?: Record<string, {
+        value?: number | undefined;
+        op?: "identity" | "multiply" | "divide" | undefined;
+      }> | undefined;
+    } | undefined;
+    identifier?: boolean | undefined;
+    "foreign-key"?: boolean | undefined;
+    hidden?: boolean | undefined;
+    "action-list"?: string[] | undefined;
+    rewriter?: string | undefined;
+  }>, Record<string, {
+    description?: string | undefined;
+    kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
+    collate?: string | undefined;
+    unit?: {
+      field?: string | undefined;
+      "scaling-factor"?: Record<string, {
+        value?: number | undefined;
+        op?: "identity" | "multiply" | "divide" | undefined;
+      }> | undefined;
+    } | undefined;
+    identifier?: boolean | undefined;
+    "foreign-key"?: boolean | undefined;
+    hidden?: boolean | undefined;
+    "action-list"?: string[] | undefined;
+    rewriter?: string | undefined;
+  }>>>;
+  tags: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+    paths: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      glob: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+      glob?: string | undefined;
+    }, {
+      glob?: string | undefined;
+    }>, "many">>;
+    pattern: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    level: z.ZodOptional<z.ZodEnum<["trace", "debug5", "debug4", "debug3", "debug2", "debug", "info", "stats", "notice", "warning", "error", "critical", "fatal"]>>;
+  }, "strict", z.ZodTypeAny, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    description?: string | undefined;
+    paths?: {
+      glob?: string | undefined;
+    }[] | undefined;
+  }, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    description?: string | undefined;
+    paths?: {
+      glob?: string | undefined;
     }[] | undefined;
-    "line-format"?: (string | {
-        "timestamp-format"?: string | undefined;
+  }>, z.ZodNever]>>, Record<string, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    description?: string | undefined;
+    paths?: {
+      glob?: string | undefined;
+    }[] | undefined;
+  }>, Record<string, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    description?: string | undefined;
+    paths?: {
+      glob?: string | undefined;
+    }[] | undefined;
+  }>>>;
+  partitions: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+    paths: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      glob: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+      glob?: string | undefined;
+    }, {
+      glob?: string | undefined;
+    }>, "many">>;
+    pattern: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    level: z.ZodOptional<z.ZodEnum<["trace", "debug5", "debug4", "debug3", "debug2", "debug", "info", "stats", "notice", "warning", "error", "critical", "fatal"]>>;
+  }, "strict", z.ZodTypeAny, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    description?: string | undefined;
+    paths?: {
+      glob?: string | undefined;
+    }[] | undefined;
+  }, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    description?: string | undefined;
+    paths?: {
+      glob?: string | undefined;
+    }[] | undefined;
+  }>, z.ZodNever]>>, Record<string, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    description?: string | undefined;
+    paths?: {
+      glob?: string | undefined;
+    }[] | undefined;
+  }>, Record<string, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    description?: string | undefined;
+    paths?: {
+      glob?: string | undefined;
+    }[] | undefined;
+  }>>>;
+  action: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodUnion<[z.ZodString, z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+    "capture-output": z.ZodOptional<z.ZodBoolean>;
+    cmd: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+  }, "strict", z.ZodTypeAny, {
+    label?: string | undefined;
+    "capture-output"?: boolean | undefined;
+    cmd?: string[] | undefined;
+  }, {
+    label?: string | undefined;
+    "capture-output"?: boolean | undefined;
+    cmd?: string[] | undefined;
+  }>]>, z.ZodNever]>>, Record<string, string | {
+    label?: string | undefined;
+    "capture-output"?: boolean | undefined;
+    cmd?: string[] | undefined;
+  }>, Record<string, string | {
+    label?: string | undefined;
+    "capture-output"?: boolean | undefined;
+    cmd?: string[] | undefined;
+  }>>>;
+  sample: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodString>;
+    level: z.ZodOptional<z.ZodEnum<["trace", "debug5", "debug4", "debug3", "debug2", "debug", "info", "stats", "notice", "warning", "error", "critical", "fatal"]>>;
+  }, "strict", z.ZodTypeAny, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    description?: string | undefined;
+    line?: string | undefined;
+  }, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    description?: string | undefined;
+    line?: string | undefined;
+  }>, "many">>;
+  "line-format": z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+    field: z.ZodOptional<z.ZodString>;
+    "default-value": z.ZodOptional<z.ZodString>;
+    "timestamp-format": z.ZodOptional<z.ZodString>;
+    "min-width": z.ZodOptional<z.ZodNumber>;
+    "auto-width": z.ZodOptional<z.ZodBoolean>;
+    "max-width": z.ZodOptional<z.ZodNumber>;
+    align: z.ZodOptional<z.ZodEnum<["left", "right"]>>;
+    overflow: z.ZodOptional<z.ZodEnum<["abbrev", "truncate", "dot-dot", "last-word"]>>;
+    "text-transform": z.ZodOptional<z.ZodEnum<["none", "uppercase", "lowercase", "capitalize"]>>;
+    prefix: z.ZodOptional<z.ZodString>;
+    suffix: z.ZodOptional<z.ZodString>;
+  }, "strict", z.ZodTypeAny, {
+    "timestamp-format"?: string | undefined;
+    field?: string | undefined;
+    prefix?: string | undefined;
+    suffix?: string | undefined;
+    "default-value"?: string | undefined;
+    "min-width"?: number | undefined;
+    "auto-width"?: boolean | undefined;
+    "max-width"?: number | undefined;
+    align?: "left" | "right" | undefined;
+    overflow?: "abbrev" | "truncate" | "dot-dot" | "last-word" | undefined;
+    "text-transform"?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+  }, {
+    "timestamp-format"?: string | undefined;
+    field?: string | undefined;
+    prefix?: string | undefined;
+    suffix?: string | undefined;
+    "default-value"?: string | undefined;
+    "min-width"?: number | undefined;
+    "auto-width"?: boolean | undefined;
+    "max-width"?: number | undefined;
+    align?: "left" | "right" | undefined;
+    overflow?: "abbrev" | "truncate" | "dot-dot" | "last-word" | undefined;
+    "text-transform"?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+  }>]>, "many">>;
+  "search-table": z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+    pattern: z.ZodOptional<z.ZodString>;
+    glob: z.ZodOptional<z.ZodString>;
+    level: z.ZodOptional<z.ZodEnum<["trace", "debug5", "debug4", "debug3", "debug2", "debug", "info", "stats", "notice", "warning", "error", "critical", "fatal"]>>;
+  }, "strict", z.ZodTypeAny, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    glob?: string | undefined;
+  }, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    glob?: string | undefined;
+  }>, z.ZodNever]>>, Record<string, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    glob?: string | undefined;
+  }>, Record<string, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    glob?: string | undefined;
+  }>>>;
+  highlights: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+    pattern: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+    "background-color": z.ZodOptional<z.ZodString>;
+    underline: z.ZodOptional<z.ZodBoolean>;
+    blink: z.ZodOptional<z.ZodBoolean>;
+  }, "strict", z.ZodTypeAny, {
+    pattern?: string | undefined;
+    color?: string | undefined;
+    "background-color"?: string | undefined;
+    underline?: boolean | undefined;
+    blink?: boolean | undefined;
+  }, {
+    pattern?: string | undefined;
+    color?: string | undefined;
+    "background-color"?: string | undefined;
+    underline?: boolean | undefined;
+    blink?: boolean | undefined;
+  }>, z.ZodNever]>>, Record<string, {
+    pattern?: string | undefined;
+    color?: string | undefined;
+    "background-color"?: string | undefined;
+    underline?: boolean | undefined;
+    blink?: boolean | undefined;
+  }>, Record<string, {
+    pattern?: string | undefined;
+    color?: string | undefined;
+    "background-color"?: string | undefined;
+    underline?: boolean | undefined;
+    blink?: boolean | undefined;
+  }>>>;
+  "file-type": z.ZodOptional<z.ZodEnum<["text", "json", "csv"]>>;
+  "max-unrecognized-lines": z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+  level?: Record<string, string | number> | undefined;
+  value?: Record<string, {
+    description?: string | undefined;
+    kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
+    collate?: string | undefined;
+    unit?: {
+      field?: string | undefined;
+      "scaling-factor"?: Record<string, {
+        value?: number | undefined;
+        op?: "identity" | "multiply" | "divide" | undefined;
+      }> | undefined;
+    } | undefined;
+    identifier?: boolean | undefined;
+    "foreign-key"?: boolean | undefined;
+    hidden?: boolean | undefined;
+    "action-list"?: string[] | undefined;
+    rewriter?: string | undefined;
+  }> | undefined;
+  regex?: Record<string, {
+    pattern?: string | undefined;
+    "module-format"?: boolean | undefined;
+  }> | undefined;
+  json?: boolean | undefined;
+  "convert-to-local-time"?: boolean | undefined;
+  "hide-extra"?: boolean | undefined;
+  multiline?: boolean | undefined;
+  "timestamp-divisor"?: number | undefined;
+  "file-pattern"?: string | undefined;
+  converter?: {
+    type?: string | undefined;
+    header?: {
+      expr?: Record<string, string> | undefined;
+      size?: number | undefined;
+    } | undefined;
+    command?: string | undefined;
+  } | undefined;
+  "level-field"?: string | undefined;
+  "level-pointer"?: string | undefined;
+  "timestamp-field"?: string | undefined;
+  "subsecond-field"?: string | undefined;
+  "subsecond-units"?: "milli" | "micro" | "nano" | undefined;
+  "time-field"?: string | undefined;
+  "body-field"?: string | undefined;
+  url?: string | string[] | undefined;
+  title?: string | undefined;
+  description?: string | undefined;
+  "timestamp-format"?: string[] | undefined;
+  "module-field"?: string | undefined;
+  "opid-field"?: string | undefined;
+  opid?: {
+    description?: Record<string, {
+      format?: {
         field?: string | undefined;
+        extractor?: string | undefined;
         prefix?: string | undefined;
         suffix?: string | undefined;
-        "default-value"?: string | undefined;
-        "min-width"?: number | undefined;
-        "auto-width"?: boolean | undefined;
-        "max-width"?: number | undefined;
-        align?: "left" | "right" | undefined;
-        overflow?: "abbrev" | "truncate" | "dot-dot" | "last-word" | undefined;
-        "text-transform"?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
-    })[] | undefined;
-    "search-table"?: Record<string, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        glob?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
     }> | undefined;
-    highlights?: Record<string, {
-        pattern?: string | undefined;
-        color?: string | undefined;
-        "background-color"?: string | undefined;
-        underline?: boolean | undefined;
-        blink?: boolean | undefined;
+    subid?: string | undefined;
+    "sub-description"?: Record<string, {
+      format?: {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
     }> | undefined;
-    "file-type"?: "json" | "text" | "csv" | undefined;
-    "max-unrecognized-lines"?: number | undefined;
+  } | undefined;
+  "ordered-by-time"?: boolean | undefined;
+  tags?: Record<string, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    description?: string | undefined;
+    paths?: {
+      glob?: string | undefined;
+    }[] | undefined;
+  }> | undefined;
+  partitions?: Record<string, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    description?: string | undefined;
+    paths?: {
+      glob?: string | undefined;
+    }[] | undefined;
+  }> | undefined;
+  action?: Record<string, string | {
+    label?: string | undefined;
+    "capture-output"?: boolean | undefined;
+    cmd?: string[] | undefined;
+  }> | undefined;
+  sample?: {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    description?: string | undefined;
+    line?: string | undefined;
+  }[] | undefined;
+  "line-format"?: (string | {
+    "timestamp-format"?: string | undefined;
+    field?: string | undefined;
+    prefix?: string | undefined;
+    suffix?: string | undefined;
+    "default-value"?: string | undefined;
+    "min-width"?: number | undefined;
+    "auto-width"?: boolean | undefined;
+    "max-width"?: number | undefined;
+    align?: "left" | "right" | undefined;
+    overflow?: "abbrev" | "truncate" | "dot-dot" | "last-word" | undefined;
+    "text-transform"?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+  })[] | undefined;
+  "search-table"?: Record<string, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    glob?: string | undefined;
+  }> | undefined;
+  highlights?: Record<string, {
+    pattern?: string | undefined;
+    color?: string | undefined;
+    "background-color"?: string | undefined;
+    underline?: boolean | undefined;
+    blink?: boolean | undefined;
+  }> | undefined;
+  "file-type"?: "json" | "text" | "csv" | undefined;
+  "max-unrecognized-lines"?: number | undefined;
 }, {
-    level?: Record<string, string | number> | undefined;
-    value?: Record<string, {
-        description?: string | undefined;
-        kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
-        collate?: string | undefined;
-        unit?: {
-            field?: string | undefined;
-            "scaling-factor"?: Record<string, {
-                value?: number | undefined;
-                op?: "identity" | "multiply" | "divide" | undefined;
-            }> | undefined;
-        } | undefined;
-        identifier?: boolean | undefined;
-        "foreign-key"?: boolean | undefined;
-        hidden?: boolean | undefined;
-        "action-list"?: string[] | undefined;
-        rewriter?: string | undefined;
-    }> | undefined;
-    regex?: Record<string, {
-        pattern?: string | undefined;
-        "module-format"?: boolean | undefined;
-    }> | undefined;
-    json?: boolean | undefined;
-    "convert-to-local-time"?: boolean | undefined;
-    "hide-extra"?: boolean | undefined;
-    multiline?: boolean | undefined;
-    "timestamp-divisor"?: number | undefined;
-    "file-pattern"?: string | undefined;
-    converter?: {
-        type?: string | undefined;
-        header?: {
-            expr?: Record<string, string> | undefined;
-            size?: number | undefined;
-        } | undefined;
-        command?: string | undefined;
-    } | undefined;
-    "level-field"?: string | undefined;
-    "level-pointer"?: string | undefined;
-    "timestamp-field"?: string | undefined;
-    "subsecond-field"?: string | undefined;
-    "subsecond-units"?: "milli" | "micro" | "nano" | undefined;
-    "time-field"?: string | undefined;
-    "body-field"?: string | undefined;
-    url?: string | string[] | undefined;
-    title?: string | undefined;
+  level?: Record<string, string | number> | undefined;
+  value?: Record<string, {
     description?: string | undefined;
-    "timestamp-format"?: string[] | undefined;
-    "module-field"?: string | undefined;
-    "opid-field"?: string | undefined;
-    opid?: {
-        description?: Record<string, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }> | undefined;
-        subid?: string | undefined;
-        "sub-description"?: Record<string, {
-            format?: {
-                field?: string | undefined;
-                extractor?: string | undefined;
-                prefix?: string | undefined;
-                suffix?: string | undefined;
-                joiner?: string | undefined;
-            }[] | undefined;
-        }> | undefined;
+    kind?: "string" | "boolean" | "integer" | "float" | "json" | "struct" | "quoted" | "xml" | undefined;
+    collate?: string | undefined;
+    unit?: {
+      field?: string | undefined;
+      "scaling-factor"?: Record<string, {
+        value?: number | undefined;
+        op?: "identity" | "multiply" | "divide" | undefined;
+      }> | undefined;
     } | undefined;
-    "ordered-by-time"?: boolean | undefined;
-    tags?: Record<string, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        description?: string | undefined;
-        paths?: {
-            glob?: string | undefined;
-        }[] | undefined;
-    }> | undefined;
-    partitions?: Record<string, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        description?: string | undefined;
-        paths?: {
-            glob?: string | undefined;
-        }[] | undefined;
-    }> | undefined;
-    action?: Record<string, string | {
-        label?: string | undefined;
-        "capture-output"?: boolean | undefined;
-        cmd?: string[] | undefined;
-    }> | undefined;
-    sample?: {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        description?: string | undefined;
-        line?: string | undefined;
-    }[] | undefined;
-    "line-format"?: (string | {
-        "timestamp-format"?: string | undefined;
+    identifier?: boolean | undefined;
+    "foreign-key"?: boolean | undefined;
+    hidden?: boolean | undefined;
+    "action-list"?: string[] | undefined;
+    rewriter?: string | undefined;
+  }> | undefined;
+  regex?: Record<string, {
+    pattern?: string | undefined;
+    "module-format"?: boolean | undefined;
+  }> | undefined;
+  json?: boolean | undefined;
+  "convert-to-local-time"?: boolean | undefined;
+  "hide-extra"?: boolean | undefined;
+  multiline?: boolean | undefined;
+  "timestamp-divisor"?: number | undefined;
+  "file-pattern"?: string | undefined;
+  converter?: {
+    type?: string | undefined;
+    header?: {
+      expr?: Record<string, string> | undefined;
+      size?: number | undefined;
+    } | undefined;
+    command?: string | undefined;
+  } | undefined;
+  "level-field"?: string | undefined;
+  "level-pointer"?: string | undefined;
+  "timestamp-field"?: string | undefined;
+  "subsecond-field"?: string | undefined;
+  "subsecond-units"?: "milli" | "micro" | "nano" | undefined;
+  "time-field"?: string | undefined;
+  "body-field"?: string | undefined;
+  url?: string | string[] | undefined;
+  title?: string | undefined;
+  description?: string | undefined;
+  "timestamp-format"?: string[] | undefined;
+  "module-field"?: string | undefined;
+  "opid-field"?: string | undefined;
+  opid?: {
+    description?: Record<string, {
+      format?: {
         field?: string | undefined;
+        extractor?: string | undefined;
         prefix?: string | undefined;
         suffix?: string | undefined;
-        "default-value"?: string | undefined;
-        "min-width"?: number | undefined;
-        "auto-width"?: boolean | undefined;
-        "max-width"?: number | undefined;
-        align?: "left" | "right" | undefined;
-        overflow?: "abbrev" | "truncate" | "dot-dot" | "last-word" | undefined;
-        "text-transform"?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
-    })[] | undefined;
-    "search-table"?: Record<string, {
-        level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
-        pattern?: string | undefined;
-        glob?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
     }> | undefined;
-    highlights?: Record<string, {
-        pattern?: string | undefined;
-        color?: string | undefined;
-        "background-color"?: string | undefined;
-        underline?: boolean | undefined;
-        blink?: boolean | undefined;
+    subid?: string | undefined;
+    "sub-description"?: Record<string, {
+      format?: {
+        field?: string | undefined;
+        extractor?: string | undefined;
+        prefix?: string | undefined;
+        suffix?: string | undefined;
+        joiner?: string | undefined;
+      }[] | undefined;
     }> | undefined;
-    "file-type"?: "json" | "text" | "csv" | undefined;
-    "max-unrecognized-lines"?: number | undefined;
+  } | undefined;
+  "ordered-by-time"?: boolean | undefined;
+  tags?: Record<string, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    description?: string | undefined;
+    paths?: {
+      glob?: string | undefined;
+    }[] | undefined;
+  }> | undefined;
+  partitions?: Record<string, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    description?: string | undefined;
+    paths?: {
+      glob?: string | undefined;
+    }[] | undefined;
+  }> | undefined;
+  action?: Record<string, string | {
+    label?: string | undefined;
+    "capture-output"?: boolean | undefined;
+    cmd?: string[] | undefined;
+  }> | undefined;
+  sample?: {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    description?: string | undefined;
+    line?: string | undefined;
+  }[] | undefined;
+  "line-format"?: (string | {
+    "timestamp-format"?: string | undefined;
+    field?: string | undefined;
+    prefix?: string | undefined;
+    suffix?: string | undefined;
+    "default-value"?: string | undefined;
+    "min-width"?: number | undefined;
+    "auto-width"?: boolean | undefined;
+    "max-width"?: number | undefined;
+    align?: "left" | "right" | undefined;
+    overflow?: "abbrev" | "truncate" | "dot-dot" | "last-word" | undefined;
+    "text-transform"?: "none" | "uppercase" | "lowercase" | "capitalize" | undefined;
+  })[] | undefined;
+  "search-table"?: Record<string, {
+    level?: "info" | "trace" | "debug5" | "debug4" | "debug3" | "debug2" | "debug" | "stats" | "notice" | "warning" | "error" | "critical" | "fatal" | undefined;
+    pattern?: string | undefined;
+    glob?: string | undefined;
+  }> | undefined;
+  highlights?: Record<string, {
+    pattern?: string | undefined;
+    color?: string | undefined;
+    "background-color"?: string | undefined;
+    underline?: boolean | undefined;
+    blink?: boolean | undefined;
+  }> | undefined;
+  "file-type"?: "json" | "text" | "csv" | undefined;
+  "max-unrecognized-lines"?: number | undefined;
 }>;
 type LnavFormat = z.infer<typeof lnavFormatSchema>;
 
@@ -793,95 +1806,82 @@ declare const FLIGHTDECK_UPDATE_PHASES: readonly ["notified", "confirmed"];
 type FlightDeckUpdatePhase = (typeof FLIGHTDECK_UPDATE_PHASES)[number];
 declare function isVersionNumber(version: string): boolean;
 type FlightDeckOptions<S extends string = string> = {
-    packageName: string;
-    services: {
-        [service in S]: {
-            run: string;
-            waitFor: boolean;
-        };
-    };
-    scripts: {
-        download: string;
-        install: string;
-        checkAvailability?: string;
-    };
-    port?: number | undefined;
-    flightdeckRootDir?: string | undefined;
-    jsonLogging?: boolean | undefined;
+  packageName: string;
+  services: { [service in S]: {
+    run: string;
+    waitFor: boolean;
+  } };
+  scripts: {
+    download: string;
+    install: string;
+    checkAvailability?: string;
+  };
+  port?: number | undefined;
+  flightdeckRootDir?: string | undefined;
+  jsonLogging?: boolean | undefined;
 };
 declare class FlightDeck<S extends string = string> {
-    readonly options: FlightDeckOptions<S>;
-    protected safety: number;
-    protected storage: FilesystemStorage<{
-        setupPhase: FlightDeckSetupPhase;
-        updatePhase: FlightDeckUpdatePhase;
-        updateAwaitedVersion: string;
-    }>;
-    protected webhookServer: Server;
-    protected services: {
-        [service in S]: ChildSocket<{
-            timeToStop: [];
-            updatesReady: [];
-        }, {
-            readyToUpdate: [];
-            alive: [];
-        }> | null;
-    };
-    protected serviceIdx: {
-        readonly [service in S]: number;
-    };
-    defaultServicesReadyToUpdate: {
-        readonly [service in S]: boolean;
-    };
-    servicesReadyToUpdate: {
-        [service in S]: boolean;
-    };
-    autoRespawnDeadServices: boolean;
-    protected logger: Pick<Console, `error` | `info` | `warn`>;
-    protected serviceLoggers: {
-        readonly [service in S]: FlightDeckLogger;
-    };
-    protected updateAvailabilityChecker: CronJob | null;
-    servicesLive: Future<void>[];
-    servicesDead: Future<void>[];
-    live: Future<unknown>;
-    dead: Future<unknown>;
-    protected restartTimes: number[];
-    constructor(options: FlightDeckOptions<S>);
-    protected seekUpdate(version: string): Promise<void>;
-    protected announceUpdate(): void;
-    protected tryUpdate(): void;
-    protected startAllServices(): Future<unknown>;
-    protected startService(serviceName: S): void;
-    protected downloadPackage(): void;
-    protected installPackage(): void;
-    stopAllServices(): Future<unknown>;
-    stopService(serviceName: S): void;
+  readonly options: FlightDeckOptions<S>;
+  protected safety: number;
+  protected storage: FilesystemStorage<{
+    setupPhase: FlightDeckSetupPhase;
+    updatePhase: FlightDeckUpdatePhase;
+    updateAwaitedVersion: string;
+  }>;
+  protected services: { [service in S]: ChildSocket<{
+    timeToStop: [];
+    updatesReady: [];
+  }, {
+    readyToUpdate: [];
+    alive: [];
+  }> | null };
+  protected serviceIdx: { readonly [service in S]: number };
+  defaultServicesReadyToUpdate: { readonly [service in S]: boolean };
+  servicesReadyToUpdate: { [service in S]: boolean };
+  autoRespawnDeadServices: boolean;
+  protected logger: Pick<Console, `error` | `info` | `warn`>;
+  protected serviceLoggers: { readonly [service in S]: FlightDeckLogger };
+  protected updateAvailabilityChecker: CronJob | null;
+  servicesLive: Future<void>[];
+  servicesDead: Future<void>[];
+  live: Future<unknown>;
+  dead: Future<unknown>;
+  protected restartTimes: number[];
+  constructor(options: FlightDeckOptions<S>);
+  protected seekUpdate(version: string): Promise<void>;
+  protected announceUpdate(): void;
+  protected tryUpdate(): void;
+  protected startAllServices(): Future<unknown>;
+  protected startService(serviceName: S): void;
+  protected downloadPackage(): void;
+  protected installPackage(): void;
+  stopAllServices(): Future<unknown>;
+  stopService(serviceName: S): void;
 }
 declare const FLIGHTDECK_INFO = "info";
 declare const FLIGHTDECK_WARN = "warn";
 declare const FLIGHTDECK_ERROR = "ERR!";
 declare const flightDeckLogSchema: z.ZodObject<{
-    level: z.ZodUnion<[z.ZodLiteral<"info">, z.ZodLiteral<"warn">, z.ZodLiteral<"ERR!">]>;
-    timestamp: z.ZodNumber;
-    package: z.ZodString;
-    service: z.ZodOptional<z.ZodString>;
-    process: z.ZodNumber;
-    body: z.ZodString;
+  level: z.ZodUnion<[z.ZodLiteral<"info">, z.ZodLiteral<"warn">, z.ZodLiteral<"ERR!">]>;
+  timestamp: z.ZodNumber;
+  package: z.ZodString;
+  service: z.ZodOptional<z.ZodString>;
+  process: z.ZodNumber;
+  body: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    level: "info" | "warn" | "ERR!";
-    timestamp: number;
-    package: string;
-    process: number;
-    body: string;
-    service?: string | undefined;
+  level: "info" | "warn" | "ERR!";
+  timestamp: number;
+  package: string;
+  process: number;
+  body: string;
+  service?: string | undefined;
 }, {
-    level: "info" | "warn" | "ERR!";
-    timestamp: number;
-    package: string;
-    process: number;
-    body: string;
-    service?: string | undefined;
+  level: "info" | "warn" | "ERR!";
+  timestamp: number;
+  package: string;
+  process: number;
+  body: string;
+  service?: string | undefined;
 }>;
 type FlightDeckLog = z.infer<typeof flightDeckLogSchema>;
 declare const LINE_FORMAT = "line-format";
@@ -891,130 +1891,129 @@ type LnavFormatBreakdown = Exclude<LnavFormat[`value`], undefined>;
 type MemberOf<T> = T[keyof T];
 type LnavFormatValueDefinition = MemberOf<LnavFormatBreakdown>;
 type FlightDeckFormat = {
-    [LINE_FORMAT]: (string | (LnavFormatVisualComponent & {
-        field: keyof FlightDeckLog | `__level__` | `__timestamp__`;
-    }))[];
-    [VALUE]: {
-        [K in keyof FlightDeckLog]: LnavFormatValueDefinition & {
-            kind: FlightDeckLog[K] extends number | undefined ? `integer` : FlightDeckLog[K] extends string | undefined ? `string` : never;
-        };
-    };
+  [LINE_FORMAT]: (string | (LnavFormatVisualComponent & {
+    field: keyof FlightDeckLog | `__level__` | `__timestamp__`;
+  }))[];
+  [VALUE]: { [K in keyof FlightDeckLog]: LnavFormatValueDefinition & {
+    kind: FlightDeckLog[K] extends number | undefined ? `integer` : FlightDeckLog[K] extends string | undefined ? `string` : never;
+  } };
 };
 declare const FLIGHTDECK_LNAV_FORMAT: {
-    readonly title: "FlightDeck Log";
-    readonly description: "Format for events logged by the FlightDeck process manager.";
-    readonly "file-type": "json";
-    readonly "timestamp-field": "timestamp";
-    readonly "timestamp-divisor": 1000;
-    readonly "module-field": "package";
-    readonly "opid-field": "service";
-    readonly "level-field": "level";
+  readonly title: "FlightDeck Log";
+  readonly description: "Format for events logged by the FlightDeck process manager.";
+  readonly "file-type": "json";
+  readonly "timestamp-field": "timestamp";
+  readonly "timestamp-divisor": 1000;
+  readonly "module-field": "package";
+  readonly "opid-field": "service";
+  readonly "level-field": "level";
+  readonly level: {
+    readonly info: "info";
+    readonly warning: "warn";
+    readonly error: "ERR!";
+  };
+  readonly "line-format": [{
+    readonly field: "level";
+  }, {
+    readonly prefix: " ";
+    readonly field: "__timestamp__";
+    readonly "timestamp-format": "%Y-%m-%dT%H:%M:%S.%L%Z";
+  }, {
+    readonly prefix: " ";
+    readonly field: "process";
+    readonly "min-width": 5;
+  }, {
+    readonly prefix: ":";
+    readonly field: "package";
+  }, {
+    readonly prefix: ":";
+    readonly field: "service";
+    readonly "default-value": "";
+  }, {
+    readonly prefix: ": ";
+    readonly field: "body";
+  }];
+  readonly value: {
+    readonly timestamp: {
+      readonly kind: "integer";
+    };
     readonly level: {
-        readonly info: "info";
-        readonly warning: "warn";
-        readonly error: "ERR!";
+      readonly kind: "string";
     };
-    readonly "line-format": [{
-        readonly field: "level";
-    }, {
-        readonly prefix: " ";
-        readonly field: "__timestamp__";
-        readonly "timestamp-format": "%Y-%m-%dT%H:%M:%S.%L%Z";
-    }, {
-        readonly prefix: " ";
-        readonly field: "process";
-        readonly "min-width": 5;
-    }, {
-        readonly prefix: ":";
-        readonly field: "package";
-    }, {
-        readonly prefix: ":";
-        readonly field: "service";
-        readonly "default-value": "";
-    }, {
-        readonly prefix: ": ";
-        readonly field: "body";
-    }];
-    readonly value: {
-        readonly timestamp: {
-            readonly kind: "integer";
-        };
-        readonly level: {
-            readonly kind: "string";
-        };
-        readonly package: {
-            readonly kind: "string";
-        };
-        readonly service: {
-            readonly kind: "string";
-        };
-        readonly process: {
-            readonly kind: "integer";
-        };
-        readonly body: {
-            readonly kind: "string";
-        };
+    readonly package: {
+      readonly kind: "string";
     };
+    readonly service: {
+      readonly kind: "string";
+    };
+    readonly process: {
+      readonly kind: "integer";
+    };
+    readonly body: {
+      readonly kind: "string";
+    };
+  };
 };
 declare class FlightDeckLogger implements Pick<Console, `error` | `info` | `warn`> {
-    readonly packageName: string;
-    readonly serviceName?: string;
-    readonly jsonLogging: boolean;
-    processCode: number;
-    constructor(packageName: string, processCode: number, serviceName?: string, options?: {
-        jsonLogging: boolean;
-    });
-    protected log(level: typeof FLIGHTDECK_ERROR | typeof FLIGHTDECK_INFO | typeof FLIGHTDECK_WARN, ...messages: unknown[]): void;
-    info(...messages: unknown[]): void;
-    warn(...messages: unknown[]): void;
-    error(...messages: unknown[]): void;
+  readonly packageName: string;
+  readonly serviceName?: string;
+  readonly jsonLogging: boolean;
+  processCode: number;
+  constructor(packageName: string, processCode: number, serviceName?: string, options?: {
+    jsonLogging: boolean;
+  });
+  protected log(level: typeof FLIGHTDECK_ERROR | typeof FLIGHTDECK_INFO | typeof FLIGHTDECK_WARN, ...messages: unknown[]): void;
+  info(...messages: unknown[]): void;
+  warn(...messages: unknown[]): void;
+  error(...messages: unknown[]): void;
 }
 
 //#endregion
 //#region src/klaxon.lib.d.ts
-
 declare namespace klaxon_lib_d_exports {
-  export { AlertOptions, ChangesetsPublishResult, ChangesetsPublishedPackage, PackageConfig, ScrambleOptions, ScrambleResult, SecretsConfig, alert, scramble, }
+  export { AlertOptions, ChangesetsPublishResult, ChangesetsPublishedPackage, PackageConfig, ScrambleOptions, ScrambleResult, SecretsConfig, alert, scramble };
 }
 type AlertOptions = {
-    secret: string;
-    endpoint: string;
-    version: string;
+  secret: string;
+  endpoint: string;
+  version: string;
 };
-declare function alert({ secret, endpoint, version, }: AlertOptions): Promise<Response>;
+declare function alert({
+  secret,
+  endpoint,
+  version
+}: AlertOptions): Promise<Response>;
 /**
-* @see https://github.com/changesets/action/blob/main/src/run.ts
-*/
+ * @see https://github.com/changesets/action/blob/main/src/run.ts
+ */
 type ChangesetsPublishedPackage = {
-    name: string;
-    version: string;
+  name: string;
+  version: string;
 };
 /**
-* @see https://github.com/changesets/action/blob/main/src/run.ts
-*/
+ * @see https://github.com/changesets/action/blob/main/src/run.ts
+ */
 type ChangesetsPublishResult = {
-    published: true;
-    publishedPackages: ChangesetsPublishedPackage[];
+  published: true;
+  publishedPackages: ChangesetsPublishedPackage[];
 } | {
-    published: false;
-};
-type PackageConfig<K extends string> = {
-    [key in K]: {
-        endpoint: string;
-    };
-};
-type SecretsConfig<K extends string> = {
-    [key in K]: string;
+  published: false;
 };
+type PackageConfig<K extends string> = { [key in K]: {
+  endpoint: string;
+} };
+type SecretsConfig<K extends string> = { [key in K]: string };
 type ScrambleOptions<K extends string = string> = {
-    packageConfig: PackageConfig<K>;
-    secretsConfig: SecretsConfig<K>;
-    publishedPackages: ChangesetsPublishedPackage[];
-};
-type ScrambleResult<K extends string = string> = {
-    [key in K]: Response;
+  packageConfig: PackageConfig<K>;
+  secretsConfig: SecretsConfig<K>;
+  publishedPackages: ChangesetsPublishedPackage[];
 };
-declare function scramble<K extends string = string>({ packageConfig, secretsConfig, publishedPackages, }: ScrambleOptions<K>): Promise<ScrambleResult<K>>;
+type ScrambleResult<K extends string = string> = { [key in K]: Response };
+declare function scramble<K extends string = string>({
+  packageConfig,
+  secretsConfig,
+  publishedPackages
+}: ScrambleOptions<K>): Promise<ScrambleResult<K>>;
 
 //#endregion
 export { FLIGHTDECK_ERROR, FLIGHTDECK_INFO, FLIGHTDECK_LNAV_FORMAT, FLIGHTDECK_SETUP_PHASES, FLIGHTDECK_UPDATE_PHASES, FLIGHTDECK_WARN, FlightDeck, FlightDeckFormat, FlightDeckLog, FlightDeckLogger, FlightDeckOptions, FlightDeckSetupPhase, FlightDeckUpdatePhase, klaxon_lib_d_exports as Klaxon, LnavFormatBreakdown, LnavFormatValueDefinition, LnavFormatVisualComponent, MemberOf, flightDeckLogSchema, isVersionNumber };