@fougere/core 0.8.4-alpha.0 → 0.9.0-alpha.0

package/src/boot/bootstrap.ts

@@ -7,7 +7,13 @@ import { installFrond, type Assembly } from './install.js';
 import type { AuthRuntime } from './auth.js';
 import type { CreateAppOptions, App } from './types.js';
 import type { AppMiddleware } from '../wire/middleware.js';
-import { Logger } from '../builtin/logger.js';
+import { Carry, Logger } from '../builtin/logger.js';
+import type { LogRecord } from '../builtin/logger.js';
+import LogLine, { CARRIES_LINE } from '../builtin/LogLine.js';
+import { emitKeyOf, type Emit } from '../wire/emit.js';
+
+/** The fact the boot announces, spelled once. */
+const LOG_LINE = lowerFirst(LogLine.name);
 import { Config } from '../builtin/config.js';
 import { createRemoteRouter, createRemoteFacade } from './remote.js';
 import { registerFrames } from './together.js';
@@ -26,7 +32,8 @@ import { InFlight } from '../dispatch/InFlight.js';
 // The keys, each read from where its concept is declared — never respelled here.
 import { facadeKeyOf, contractsKeyOf, type RpcAnswer } from '../wire/call.js';
 import { identityCardOf } from './card.js';
-import { AppLifecycle } from './AppLifecycle.js';
+import { AppLifecycle, migrating } from './AppLifecycle.js';
+import { seeding } from './seed.js';
 import { inheritsCrud, subjectOf } from '../prefab/crud.js';
 import { repositoryKeyOf } from '../prefab/repository.js';
 import { storageKeyOf } from '../storage/port.js';
@@ -83,9 +90,20 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
 
   // Held out here, and not where the ascent reads it, because releasing needs it and
   // releasing has to work from the first line the boot takes something.
-  const appLifecycle = new AppLifecycle().add(...(options.extensions ?? []));
+  // The conventional ascent, ordered here: tables, then rows, then whatever the host took
+  // on. Four hosts assembled these two members themselves — the order is not theirs to
+  // choose, and a host that forgot lost its migration in silence.
+  const appLifecycle = new AppLifecycle().add(
+    migrating(options.migrate),
+    seeding(),
+    ...(options.extensions ?? []),
+  );
   /** The app once it exists — a refusal before that releases the two levels that do. */
   let built: App | undefined;
+  /** Where THIS boot's lines wait — never a process-wide slot, see `Carry`. */
+  const carry = new Carry();
+  /** Given back by `carry.to`, so a released app stops writing into a dead container. */
+  let stopAnnouncing: (() => void) | undefined;
 
   /**
    * Everything this app holds, let go in reverse of how it was taken: what an extension took on
@@ -97,6 +115,9 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
     // there and broken here, a refusing extension took the container and the connection
     // down with it, which is the leak this gesture exists to prevent.
     const refused: unknown[] = [];
+    // Whatever is still held will never reach a destination — the console had it.
+    stopAnnouncing?.();
+    carry.forget();
     const levels = [
       ...(built ? [() => appLifecycle.down(built!)] : []),
       () => container.dispose(),
@@ -119,14 +140,14 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
 
   try {
     // Boot chatter is debug by default; a host (e.g. the CLI) can quiet it.
-    const log = new Logger('boot:app');
+    const log = new Logger('boot:app', { carry });
 
     // Builtins — registered under class name (PascalCase) for type-based DI.
     // No level here and none anywhere: a logger consults `setLogLevel`'s value at each
     // emission, so this instance survives a level change and so does every handler that
     // was handed it. A frond declaring `class X extends Logger` takes this key over,
     // like any other port.
-    container.registerValue('Logger', new Logger('app'));
+    container.registerValue('Logger', new Logger('app', { carry }));
     container.register('Config', Config, { lifetime: 'singleton' });
     log.debug('builtins registered (Logger, Config)');
 
@@ -134,12 +155,20 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
     // it may read a disk; consuming it never does, which is the whole reason this file names
     // no builtin and a Worker can run what it builds.
     const scanStart = performance.now();
-    const { fronds, diagnostics } = await hostedBy(options);
+    // An extension's fronds sit beside the app's own: it is installed like any other, and
+    // its handlers resolve at call time — by which point the extension's `up` has put what
+    // they ask for in the container.
+    const brought = (options.extensions ?? [])
+      .flatMap((extension) => extension?.fronds ?? [])
+      .map((frond) => ({ ...frond, brought: true as const }));
+    const { fronds, diagnostics } = await hostedBy(
+      brought.length > 0 ? { ...options, fronds: [...(options.fronds ?? []), ...brought] } : options,
+    );
     // An app that states nothing AND scans nothing is a mistake — unless something else it
     // declares brings its own entities, which an auth provider does. Refused here and not in
     // `hostedBy`, which is handed the frond sources and cannot see the rest of the app. The
     // condition is the KEYS, not the count: a scan that found nothing is an ordinary answer.
-    if (!options.fronds && !options.scan && !options.auth) {
+    if (!options.fronds && !options.scan && !options.auth && brought.length === 0) {
       throw new Error(
         'createApp needs `fronds:` (what this app states) or `scan:` (what a scanner found). '
         + 'Neither was given, and nothing else declares entities of its own.',
@@ -233,15 +262,41 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
       return [...globalMiddlewares, ...scoped];
     }
 
+    /**
+     * The one place a middleware is taken on. `App.use` is its late form, and a frond's
+     * `middlewares/` its early one — the app does not exist yet while fronds install.
+     */
+    function use(middleware: AppMiddleware, entity?: string): void {
+      if (entity === undefined) {
+        globalMiddlewares.push(middleware);
+        return;
+      }
+      const scoped = scopedMiddlewares.get(entity) ?? [];
+      scoped.push(middleware);
+      scopedMiddlewares.set(entity, scoped);
+    }
+
     assertOneOwnerPerKey(fronds, options.remotes);
 
     // Every entity of every frond, by name — so a fact can be validated where it LANDS, and
     // so a `reads:` clause can name a neighbour's.
     const entityByName = fronds.schemas();
+    // The line is core's, so its SHAPE is too: a destination that declares only a handler
+    // would otherwise be handed a line with no `at` — the announcement stamps `created()`
+    // off the shape, and the strict judge refuses what it did not stamp. Measured on
+    // `demos/observability`, where the ring held 11 calls and 0 lines.
+    if (!entityByName.has(LOG_LINE)) entityByName.set(LOG_LINE, LogLine);
     // Which frond holds an entity — what turns "a member is remote" into a refusal that
     // names the frond rather than the entity, since `remotes:` is declared per frond.
     const frondOf = new Map(fronds.flatMap((f) => f.entities.map((e) => [e.name, f.name] as const)));
-    const emissions = new Emissions(fronds, entityByName, container, log, options.onEmit);
+    // Its own writer, which does NOT announce: this is what carries a fact, and a line
+    // about carrying one would come back here. See `LoggerOptions.carries`.
+    const emissions = new Emissions(
+      fronds, entityByName, container,
+      // No carry: this is what CARRIES a fact, and a line about carrying one comes back.
+      new Logger('boot:app'),
+      options.onEmit,
+    );
     /** Canonical operation tables, indexed by the same audience key as their facades. */
     const effectiveByKey = new Map<string, EffectiveOperationsMap>();
 
@@ -258,7 +313,7 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
     // table, one emission list — so what a frond serves is there for the next one to find.
     const assembly: Assembly = {
       container, routeRegistry, emissions, dispatcher, localDispatcher, effectiveByKey,
-      boundPorts, operationModel, entityByName, frondOf, contractsOf, getMiddlewares,
+      boundPorts, operationModel, entityByName, frondOf, contractsOf, getMiddlewares, use,
       log, options,
     };
     for (const frond of fronds) await installFrond(frond, assembly);
@@ -277,6 +332,28 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
     // Once every door exists: what is announced here and what is listened to are both known.
     emissions.register();
 
+    // The boot's own lines, and every line after them. Held until here because a boot
+    // writes most of what a process logs and writes it before any door exists — so the
+    // lines that say what this app is made of are the ones a destination would miss.
+    // `LogLine` is core's for this reason: naming it costs no optional package.
+    // Which doors carry a line, read from who SUBSCRIBED — so a third party's destination
+    // is left alone by the two middlewares that observe every operation.
+    for (const door of emissions.doorsFor(LOG_LINE)) {
+      CARRIES_LINE.add(door.replace(/Handler$/, '').replace(/^./, (c) => c.toLowerCase()));
+      CARRIES_LINE.add(door);
+    }
+
+    if (emissions.listensTo().includes(LOG_LINE)) {
+      const emit = container.resolve<Emit<LogLine>>(emitKeyOf(LogLine.name));
+      // `at` is the record's own epoch, and the entity says `created()` — so the line
+      // keeps WHEN IT WAS WRITTEN rather than when it was handed over, which for a held
+      // boot line is a different moment.
+      stopAnnouncing = carry.to(({ at, ...line }: LogRecord) => void emit({ ...line, at: new Date(at) }));
+    } else {
+      // No destination in this app: the console had them, and holding more would grow.
+      carry.forget();
+    }
+
     /** The last resort, held by the container so every resolution path shares it. */
     container.setFallback?.((name) => {
       if (!remoteRouter) return undefined;
@@ -485,14 +562,9 @@ export async function createApp(options: CreateAppOptions): Promise<App> {
         return dispatchLifecycle.add(observer);
       },
       use(...args: [AppMiddleware] | [string, AppMiddleware]): void {
-        if (typeof args[0] === 'string') {
-          const [entity, mw] = args as [string, AppMiddleware];
-          const list = scopedMiddlewares.get(entity) ?? [];
-          list.push(mw);
-          scopedMiddlewares.set(entity, list);
-        } else {
-          globalMiddlewares.push(args[0] as AppMiddleware);
-        }
+        return typeof args[0] === 'string'
+          ? use(args[1] as AppMiddleware, args[0])
+          : use(args[0] as AppMiddleware);
       },
       auth: authRuntime,
     };

package/src/boot/hosted.ts

@@ -12,7 +12,8 @@ export interface HostedSources {
 }
 
 /** The members a frond takes from a scan when it named none of its own. */
-type Fillable = 'providers' | 'entities' | 'handlers' | 'presenters' | 'collectors' | 'seeds';
+type Fillable = 'providers' | 'entities' | 'handlers' | 'presenters' | 'collectors' | 'seeds'
+  | 'middlewares';
 
 /** A frond the host passed, completed by what a scan found under the same name. */
 function completed(given: FrondDescriptor, found: FrondDescriptor | undefined): FrondDescriptor {
@@ -33,6 +34,7 @@ function completed(given: FrondDescriptor, found: FrondDescriptor | undefined):
     presenters: fill('presenters'),
     collectors: fill('collectors'),
     seeds: fill('seeds'),
+    middlewares: fill('middlewares'),
   };
 }
 

package/src/boot/install.ts

@@ -52,6 +52,8 @@ export interface Assembly {
   contractsOf: (operations: EffectiveOperationsMap) => OperationsMap;
   /** Read at call time and never at boot, so a late registration still applies. */
   getMiddlewares: (entity: string) => AppMiddleware[];
+  /** Take a middleware on — every entity when no entity is named. */
+  use: (middleware: AppMiddleware, entity?: string) => void;
   log: Logger;
   options: CreateAppOptions;
 }
@@ -59,7 +61,7 @@ export interface Assembly {
 export async function installFrond(frond: FrondDescriptor, assembly: Assembly): Promise<void> {
   const {
     container, routeRegistry, emissions, dispatcher, localDispatcher, effectiveByKey,
-    boundPorts, operationModel, entityByName, frondOf, contractsOf, getMiddlewares,
+    boundPorts, operationModel, entityByName, frondOf, contractsOf, getMiddlewares, use,
     log, options,
   } = assembly;
 
@@ -126,10 +128,22 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
   // reaches the realization instead of the base class it is declared against.
   // Registered AFTER the loop above so a port key always wins over the base's
   // own registration — same precedence as a declared repository over its default.
-  for (const [port, impl] of portBindings(frond.providers, (n) => scope.has(n), options.ports)) {
-    scope.register(port, impl.ctor, { deps: impl.deps });
+  for (const [port, chain] of portBindings(frond.providers, (n) => scope.has(n), options.ports)) {
+    // Registered from the INSIDE OUT, each wrapper asking for the one it stands in front
+    // of: the container resolves a dep by NAME, so wrapping is a substituted key and
+    // needs nothing of the container itself. The outermost answers under the port.
+    let inner = nameOf(chain.at(-1)!);
+    for (const wrapper of [...chain.slice(0, -1)].reverse()) {
+      const deps = wrapper.deps.map((dep) => (dep === port ? inner : dep));
+      inner = nameOf(wrapper);
+      scope.register(inner, wrapper.ctor, { deps });
+    }
+    const outermost = chain[0]!;
+    scope.register(port, outermost.ctor, {
+      deps: outermost.deps.map((dep) => (dep === port ? nameOf(chain[1]!) : dep)),
+    });
     boundPorts.add(port);
-    frondLog.debug(`port ${port} → ${impl.ctor.name}`);
+    frondLog.debug(`port ${port} → ${chain.map((one) => one.ctor.name).join(' → ')}`);
   }
   if (frond.providers.length > 0) {
     frondLog.debug(`${frond.providers.length} provider(s): ${frond.providers.map(nameOf).join(', ')}`);
@@ -226,6 +240,23 @@ export async function installFrond(frond: FrondDescriptor, assembly: Assembly):
     frondLog.debug(`${frond.collectors.length} collector(s): ${frond.collectors.map((c) => c.typeName).join(', ')}`);
   }
 
+  // Register middlewares in scope, then take them on. Resolved per call and never here:
+  // a middleware asking for something request-scoped would otherwise be handed the one
+  // instance the boot built — the same reason `getMiddlewares` is read at call time.
+  for (const middleware of frond.middlewares) {
+    scope.register(middleware.name, middleware.ctor, { deps: middleware.deps });
+    const around: AppMiddleware = (context, next) =>
+      scope.resolve<{ around: AppMiddleware }>(middleware.name).around(context, next);
+
+    if (middleware.scope === 'app') use(around);
+    // Its own frond means every address its handlers answer to — wider than its entities,
+    // since a handler without one runs behind it too.
+    else for (const address of new Set(frond.handlers.map((h) => h.address))) use(around, address);
+  }
+  if (frond.middlewares.length > 0) {
+    frondLog.debug(`${frond.middlewares.length} middleware(s): ${frond.middlewares.map((m) => `${m.name} (${m.scope})`).join(', ')}`);
+  }
+
   // Build handler facades → registered in ROOT container (public contract)
   const defaultHandlers = frond.handlers.filter((h) => !h.surface);
   const surfaceHandlers = frond.handlers.filter((h) => h.surface);

package/src/boot/ports.ts

@@ -1,11 +1,20 @@
-import type { ProviderEntry } from '../descriptor/frond.js';
+import { nameOf, type ProviderEntry } from '../descriptor/frond.js';
 
-/** A port is a class something already answers under. */
+/**
+ * A port is a class something already answers under, and what answers it may be a CHAIN:
+ * the realization, wrapped by whoever stands in front of it.
+ *
+ * A wrapper is recognized by its FORM — it extends the port AND asks for it. Nothing
+ * declares it, the way nothing declares a realization.
+ *
+ * Returns, per port, the chain from the OUTSIDE IN: the last entry is the realization,
+ * every one before it wraps what follows.
+ */
 export function portBindings(
   providers: ProviderEntry[],
   answers: (name: string) => boolean,
-  chosen: Record<string, string> | undefined,
-): Map<string, ProviderEntry> {
+  chosen: Record<string, string | readonly string[]> | undefined,
+): Map<string, ProviderEntry[]> {
   // port class name → the classes that extend it, in scan order.
   const candidates = new Map<string, ProviderEntry[]>();
   for (const provider of providers) {
@@ -22,32 +31,67 @@ export function portBindings(
     candidates.set(port, [...(candidates.get(port) ?? []), provider]);
   }
 
-  const bound = new Map<string, ProviderEntry>();
-  for (const [port, impls] of candidates) {
-    const named = chosen?.[port];
-    if (named) {
-      const pick = impls.find((i) => i.ctor.name === named);
+  const bound = new Map<string, ProviderEntry[]>();
+  for (const [port, all] of candidates) {
+    /** It extends the port and asks for it: it stands in front of what answers. */
+    const wraps = (one: ProviderEntry) => one.deps.includes(port);
+    const wrappers = all.filter(wraps);
+    const impls = all.filter((one) => !wraps(one));
+    const stated = chosen?.[port];
+
+    bound.set(port, chain(port, impls, wrappers, stated));
+  }
+
+  return bound;
+}
+
+function chain(
+  port: string,
+  impls: ProviderEntry[],
+  wrappers: ProviderEntry[],
+  stated: string | readonly string[] | undefined,
+): ProviderEntry[] {
+  // The whole chain, outside in — a string is a chain of one, and the last name is what
+  // actually answers. What a deployment wraps its realization with is the same kind of
+  // decision as which realization it uses, so it is the same key.
+  if (stated !== undefined) {
+    const order = typeof stated === 'string' ? [stated] : stated;
+    const all = [...wrappers, ...impls];
+
+    return order.map((name) => {
+      const pick = all.find((one) => nameOf(one) === name);
       if (!pick) {
         throw new Error(
-          `[ports] ${port}: '${named}' does not extend it. `
-          + `What does: ${impls.map((i) => i.ctor.name).join(', ')}.`,
+          `[ports] ${port}: '${name}' does not extend it. `
+          + `What does: ${all.map(nameOf).join(', ')}.`,
         );
       }
-      bound.set(port, pick);
-      continue;
-    }
-    if (impls.length > 1) {
-      // Refusing rather than keeping one, for the reason `remotes` refuses two owners
-      // of an entity: whichever won would depend on scan order, and the handler would
-      // charge the wrong provider without a word.
-      throw new Error(
-        `[ports] ${impls.map((i) => i.ctor.name).join(' and ')} both extend ${port}, `
-        + 'and nothing says which one answers it. Which realization a deployment uses is '
-        + `not a fact about the code — state it: ports: { ${port}: '${impls[0].ctor.name}' } `
-        + 'in fougere.config.ts.',
-      );
-    }
-    bound.set(port, impls[0]);
+
+      return pick;
+    });
   }
-  return bound;
+
+  if (impls.length > 1) {
+    // Refusing rather than keeping one, for the reason `remotes` refuses two owners
+    // of an entity: whichever won would depend on scan order, and the handler would
+    // charge the wrong provider without a word.
+    throw new Error(
+      `[ports] ${impls.map(nameOf).join(' and ')} both extend ${port}, `
+      + 'and nothing says which one answers it. Which realization a deployment uses is '
+      + `not a fact about the code — state it: ports: { ${port}: '${nameOf(impls[0]!)}' } `
+      + 'in fougere.config.ts.',
+    );
+  }
+
+  if (wrappers.length > 1) {
+    // Same refusal one layer out: two wrappers are an ORDER, and scan order is not one.
+    throw new Error(
+      `[ports] ${wrappers.map(nameOf).join(' and ')} both wrap ${port}, `
+      + 'and nothing says which stands in front. State the chain, outside in: '
+      + `ports: { ${port}: [${[...wrappers, ...impls].map((one) => `'${nameOf(one)}'`).join(', ')}] } `
+      + 'in fougere.config.ts.',
+    );
+  }
+
+  return [...wrappers, ...impls];
 }

package/src/boot/remote.ts

@@ -2,7 +2,7 @@
 import type { FrondCall, Transport } from '../wire/call.js';
 import { assertIdentityCard, RPC_ENTITY } from '../wire/call.js';
 import { runMiddlewares, type AppMiddleware, type OperationContext } from '../wire/middleware.js';
-import { EMPTY_INVOCATION, type InvocationContext } from '../wire/Invocation.js';
+import { type InvocationContext, Invocation } from '../wire/Invocation.js';
 import { FougereError, ErrorCode } from '../wire/errors.js';
 import { Card, type SchemaView, type SchemaDescriptor } from '@fougere/schema';
 import { dynamicOperations } from '../entry/facade.js';
@@ -43,7 +43,7 @@ export function createRemoteRouter(
         const transport = transports.get(url) ?? makeTransport(url);
         transports.set(url, transport);
         try {
-          const answer = await transport({ entity: RPC_ENTITY, op: 'discover' }, EMPTY_INVOCATION);
+          const answer = await transport({ entity: RPC_ENTITY, op: 'discover' }, Invocation.empty);
           // Judged below and not here: this catch means "unreachable, retry", and a
           // refusal thrown inside it would be swallowed into another silent retry.
           return { label, url, transport, answer };
@@ -118,7 +118,7 @@ export function createRemoteFacade(
   router: RemoteRouter,
   middlewaresFor: (address: string) => AppMiddleware[],
 ): Facade {
-  const opFn = (op: string) => async (invocation: InvocationContext = EMPTY_INVOCATION) => {
+  const opFn = (op: string) => async (invocation: InvocationContext = Invocation.empty) => {
     const { frond, transport } = await router.route(entity);
     const call: FrondCall = { frond, entity, op };
     const ctx: OperationContext = {

package/src/boot/types.ts

@@ -28,6 +28,16 @@ export interface CreateAppOptions {
   sourceOf?: (entityName: string) => string;
   transacts?: (source: string) => boolean;
   transacted?: <R>(source: string, fn: (storageFactory: StorageFactory) => Promise<R>) => Promise<R>;
+  /**
+   * Bring the shape of what lives here up to date — a source's own gesture, declared on
+   * `Source.migrate` and handed over whole.
+   *
+   * Handed here rather than assembled by the host: four of them wrote
+   * `migrating(storage.migrate)` themselves, one of them as a string inside generated
+   * code, and eight demos wrote nothing — so they had no migration and nothing said it.
+   * The ASCENT is core's to order, since rows after tables is not a host's preference.
+   */
+  migrate?: (app: App) => Promise<void> | void;
   /** Whether that source refuses a constraint at the rows — the boot says so when it does not. */
   enforces?: (source: string, constraint: Constraint) => boolean;
   /** Builds the cross-source reader a frond gets when it declares `reads:`. */
@@ -47,7 +57,12 @@ export interface CreateAppOptions {
    * Which realization answers which port — see `FougereConfig.ports`. Needed only
    * when two classes extend the same port; one is resolved by convention.
    */
-  ports?: Record<string, string>;
+  /**
+   * What answers a port. A string names the realization; a LIST is the chain, from the
+   * outside in — `['Retrying', 'Stripe']` puts `Retrying` in front of `Stripe`, and the
+   * last name is what actually charges.
+   */
+  ports?: Record<string, string | readonly string[]>;
   /** What this app takes on beyond its fronds, each stating what it does and what it undoes. */
   extensions?: readonly (Extension | undefined)[];
   /**

package/src/builtin/LogLine.ts

@@ -0,0 +1,38 @@
+import { entity, oneOf, text, json, list, optional, created } from '@fougere/schema';
+
+/**
+ * One line. A fact about the process, announced like any other — which is what makes a
+ * destination an ordinary handler and `remotes:` the only thing that decides where it runs.
+ *
+ * Here and not in `@fougere/log`, because the BOOT announces: core would otherwise have to
+ * name an optional package's entity to reach its own lines. What is optional is where a
+ * line GOES, and that is what `@fougere/log` ships.
+ *
+ * No `primary()`: an id costs 87 µs to generate (cuid2), and nothing addresses a line
+ * by one. `at` is `created()`, so announcing is what fills it.
+ */
+export default class LogLine extends entity({
+  level: oneOf('debug', 'info', 'warn', 'error'),
+  /** Who wrote it — 'app', 'app:catalog'. */
+  name: text(),
+  message: text({ min: 1 }),
+  /** What the writer passed beside the message — most lines pass none. */
+  args: optional(list(json())),
+  at: created(),
+}) {}
+
+/** The fact a boot announces, spelled once. */
+export const LOG_LINE = 'logLine';
+
+/**
+ * The addresses whose operations CARRY a line — every destination this app installed.
+ *
+ * Whatever carries a fact must not produce one, or the emission refuses it by name:
+ * keeping a line is a DISPATCH, so logging it announces a line inside the announcement of
+ * one. FILLED BY THE BOOT from what binds `logLine`, not written down — a hard-coded list
+ * cannot know a third party's destination, and the app already knows who subscribed.
+ *
+ * Read by `loggerMiddleware` and by `observability`'s `trace()`, both of which observe
+ * every operation and would otherwise observe the observation.
+ */
+export const CARRIES_LINE = new Set<string>();