@makaio/framework 1.0.0-dev-1789609124644 → 1.0.0-dev-1790066089222

package/dist/{index-Bg3WVL8n.d.mts → index-gNdH1F6r.d.mts}

@@ -1,16 +1,17 @@
-import { sr as AnyArtifactKindDefinition, vr as ArtifactLifecycleHookEvent, yr as ArtifactLifecycleHookRegistration$1 } from "./index-ClKwF6LE.mjs";
-import { s as AdapterProviderAuth$1 } from "./adapter-binding-BxjUfkOn.mjs";
-import { i as ExtensionService$1, n as NodeExtensionContext$1, t as ExtensionContext$1 } from "./extension-context-BH31eOMv.mjs";
-import { t as ExtensionAutomationTriggersContribution } from "./contribution-DDbHzCPF.mjs";
-import { n as ExtensionTransitionRulesContribution, t as ExtensionTransitionActionsContribution, v as WorkflowBlockCollection$1 } from "./transition-D-Lgbp1j.mjs";
-import { E as ClientDefinition$1, Q as VersionLiteral$1, et as VersionRange, f as ExtensionClientHookResponsesContribution } from "./hook-responses-Dq16X3Cb.mjs";
-import { c as ProviderDefinitionInput$1, r as ProtocolId$1 } from "./definition-ClWxAKQ2.mjs";
-import { t as RequiredTimeoutConfig } from "./index-DM72_93s.mjs";
-import { Qt as SESSION_EVENT_TYPES, bn as SessionMessage$1, i as MakaioSessionEvent$1 } from "./types-DhbllltK.mjs";
-import { D as EntityUIConfig$1, I as FormFieldProps } from "./index-De_oh9M-2.mjs";
-import { l as FacetNamespaceDefinition } from "./index-KdlZRuTp.mjs";
-import { t as ExtensionReactionsContribution } from "./index-C87P0WpY2.mjs";
-import { G as SurfaceBindingDefinition, p as ExtensionArtifactViewBuildersContribution } from "./view-builder-CHUTXJDl.mjs";
+import { sr as AnyArtifactKindDefinition, vr as ArtifactLifecycleHookEvent, yr as ArtifactLifecycleHookRegistration$1 } from "./index-Di-R1gmo.mjs";
+import { l as JsonValue$1 } from "./json-value-Bjl8jzom.mjs";
+import { s as AdapterProviderAuth$1 } from "./adapter-binding-CaYBrIkL.mjs";
+import { a as ExtensionService$1, n as ExtensionContext$1, r as NodeExtensionContext$1 } from "./extension-context-pQ7Uio_s.mjs";
+import { t as ExtensionAutomationTriggersContribution } from "./contribution-1GL7Rjaq.mjs";
+import { n as ExtensionTransitionRulesContribution, t as ExtensionTransitionActionsContribution, v as WorkflowBlockCollection$1 } from "./transition-DMv8cgEd.mjs";
+import { k as ClientDefinition$1, m as ExtensionClientHookResponsesContribution, rt as VersionRange, tt as VersionLiteral$1 } from "./hook-responses-B882RcQc.mjs";
+import { c as ProviderDefinitionInput$1, r as ProtocolId$1 } from "./definition-DLJg-P4G.mjs";
+import { t as RequiredTimeoutConfig } from "./index-BD1SbHpP.mjs";
+import { Qt as SESSION_EVENT_TYPES, bn as SessionMessage$1, i as MakaioSessionEvent$1 } from "./types-DNYO_Rxj.mjs";
+import { D as EntityUIConfig$1, I as FormFieldProps } from "./index-D6Uq1btG.mjs";
+import { l as FacetNamespaceDefinition } from "./index-BDcK7jqJ2.mjs";
+import { t as ExtensionReactionsContribution } from "./index-CmCLAMNs.mjs";
+import { G as SurfaceBindingDefinition, p as ExtensionArtifactViewBuildersContribution } from "./view-builder-DJGz9I-u.mjs";
 import { z } from "zod";
 import { MakaioBusLike, PayloadFilter, RegistrableBusNamespaceDefinition, SubjectSchema } from "@makaio/framework/core";
 import * as _$_makaio_contracts0 from "@makaio/framework/contracts";
@@ -1173,6 +1174,27 @@ interface ExtensionManifest {
    * whether a capability exists at all before prompting the user to configure it.
    */
   readonly provides?: readonly CapabilityToken[];
+  /**
+   * When `true`, the runtime cannot function without this extension.
+   *
+   * A critical extension aborts startup when it fails to initialize, refuses a
+   * disable request, and starts anyway when the enablement store records it as
+   * disabled. Optional extensions default to isolated failure so one extension
+   * cannot prevent the runtime from booting.
+   *
+   * The executable package that declares the flag is the only authority for
+   * it. A descriptor whose `entrypoints.server` exports the packages therefore
+   * must not declare `critical` at all — a server entrypoint can export several
+   * packages (`example`, `example.child`), each with its own criticality, so a
+   * single descriptor-level flag cannot describe them and the runtime never
+   * reads one. `ExtensionDescriptorSchema` rejects that combination.
+   *
+   * A descriptor with no server entrypoint — detached, CLI-only, browser-only —
+   * has no exported package to declare anything: the runtime synthesizes its
+   * single package straight from the descriptor, so the descriptor field *is*
+   * the package field and pre-load surfaces can read it directly.
+   */
+  readonly critical?: boolean;
   /** Windows this extension can open, keyed by {@link WindowManifest.id}. */
   readonly windows?: readonly WindowManifest[];
   /** System tray entry for this extension. */
@@ -1228,6 +1250,7 @@ declare const ExtensionManifestSchema: z.ZodObject<{
     version: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>], "type">>>>;
   provides: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<CapabilityToken, unknown, z.core.$ZodTypeInternals<CapabilityToken, unknown>>>>>;
+  critical: z.ZodOptional<z.ZodBoolean>;
   windows: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     style: z.ZodEnum<{
@@ -1379,6 +1402,39 @@ declare const ExtensionManifestSchema: z.ZodObject<{
   }, z.core.$strict>>;
 }, z.core.$strip>;
 //#endregion
+//#region core/contracts/src/extension/normalize-extension-export.d.ts
+/**
+ * Minimal structural check for a value that looks like an {@link ExtensionManifest}-shaped
+ * executable export.
+ *
+ * Only checks the identity fields every executable extension package must carry
+ * (`name`, `displayName`, `version`) — the remaining {@link ExtensionManifest}
+ * fields are optional and not required to treat a value as extension-shaped.
+ * @typeParam T - Concrete executable package shape to narrow `value` to.
+ * @param value - Candidate value, typically a server entry's default export or
+ *   one element of it.
+ * @returns Whether `value` carries the minimal extension package identity shape.
+ */
+declare function isExtensionManifestLike$1<T extends ExtensionManifest = ExtensionManifest>(value: unknown): value is T;
+/**
+ * Normalize a server entry default export into a validated list of executable packages
+ * anchored to one descriptor's identity.
+ *
+ * Single-package exports must match the descriptor name exactly. Array exports
+ * must keep every package under the descriptor's namespace, using the
+ * descriptor name exactly or a dot-prefixed child name such as
+ * `example-extension.settings`, must include a package named exactly
+ * `descriptorName`, and must not repeat a package name.
+ * @typeParam T - Concrete executable package shape to narrow the result to.
+ * @param value - Default export from the server entrypoint.
+ * @param descriptorName - Descriptor package name every entry must be anchored to.
+ * @param onInvalid - Called with a human-readable reason whenever `value` fails
+ *   validation, before this function returns `undefined`. Callers prefix this
+ *   with their own diagnostic label and log it.
+ * @returns Normalized package list, or `undefined` when invalid.
+ */
+declare function normalizeExtensionManifestExport$1<T extends ExtensionManifest = ExtensionManifest>(value: unknown, descriptorName: string, onInvalid: (reason: string) => void): T[] | undefined;
+//#endregion
 //#region core/contracts/src/extension/adapter-definition.d.ts
 /**
  * Adapter-side declaration of a supported provider.
@@ -1684,6 +1740,20 @@ interface ExtensionRuntimeOwnership {
   /** Owns the `session.sendMessage` orchestration handlers for this runtime. */
   readonly sessionOrchestrator?: boolean;
 }
+/**
+ * Check whether one runtime ownership field is claimed.
+ *
+ * A field is claimed only when it is strictly `true` — `false`, `undefined`,
+ * and an absent `ownership` object all mean "not claimed". This is the one
+ * place that encodes the field-level `=== true` rule; the boot-time
+ * single-owner selector (`findRuntimeOwners` in `@makaio/runtime-node`) calls
+ * through this helper instead of re-testing the field itself, so the rule
+ * cannot drift between call sites.
+ * @param ownership - Runtime ownership declaration to inspect, or `undefined`.
+ * @param field - Ownership field to check.
+ * @returns `true` when `ownership[field]` is strictly `true`.
+ */
+declare function isRuntimeOwnershipFieldClaimed$1<K extends keyof ExtensionRuntimeOwnership>(ownership: ExtensionRuntimeOwnership | undefined, field: K): boolean;
 //#endregion
 //#region core/contracts/src/extension/contributions/session-event-action-types.d.ts
 /** Keyboard modifier flags for an action shortcut. */
@@ -2712,6 +2782,31 @@ type MakaioWebUiActions = Record<string, MakaioWebUiAction<unknown, unknown[]>>;
  * @typeParam TActions - The server-side action record shape.
  */
 type PromisifiedActions<TActions extends MakaioWebUiActions> = { [K in keyof TActions]: TActions[K] extends ((...args: infer Args) => Promise<infer Result>) ? (...args: Args) => Promise<Result> : never };
+/**
+ * Operator configuration provenance passed to custom config components.
+ *
+ * When an operator configuration source owns specific extension config keys,
+ * this object surfaces the ownership metadata so the component can render
+ * locked fields appropriately. Any `onChange` values for keys in `keys` are
+ * accepted by the hook layer, but the stored record is never updated for those
+ * keys — `setValues` strips operator-owned keys before persisting.
+ */
+interface ExtensionOperatorConfigProvenance {
+  /**
+   * Human-readable label identifying the operator configuration source.
+   *
+   * This is an opaque string supplied by the operator file loader — it may be
+   * a file path, a Vault secret path, or any other label. Do not assume it
+   * represents a file path.
+   */
+  readonly source: string;
+  /**
+   * Set of config keys owned by the operator configuration source.
+   *
+   * Fields for these keys should be rendered as read-only in the component.
+   */
+  readonly keys: ReadonlySet<string>;
+}
 /**
  * Props passed to a WebUI component.
  *
@@ -2762,6 +2857,12 @@ interface ExtensionConfigComponentProps<TConfig = unknown> {
   config: TConfig;
   /**
    * Called when configuration values change.
+   *
+   * Values for operator-owned keys (see {@link operatorConfig}) are accepted
+   * by the underlying hook but are never written to the stored layer — the hook
+   * strips those keys before persisting so the stored fallback is preserved.
+   * The component should render owned-key fields as read-only to communicate
+   * this to the user.
    * @param config - Updated configuration.
    */
   onChange: (config: TConfig) => void;
@@ -2771,6 +2872,14 @@ interface ExtensionConfigComponentProps<TConfig = unknown> {
   isSaving: boolean;
   /** Validation errors keyed by field name. */
   errors?: Record<string, string>;
+  /**
+   * Operator configuration provenance, when an operator source owns some keys.
+   *
+   * `undefined` when no operator configuration is active for this extension.
+   * When present, the component should render the fields for owned keys as
+   * read-only and surface the source to the user.
+   */
+  operatorConfig?: ExtensionOperatorConfigProvenance;
 }
 /**
  * Async loader for registering custom form field types.
@@ -2781,6 +2890,35 @@ interface ExtensionConfigComponentProps<TConfig = unknown> {
 type ExtensionFieldTypeLoader = () => Promise<{
   default: ComponentType<FormFieldProps>;
 }>;
+/**
+ * Registration metadata paired with a field type's loader.
+ *
+ * Field types that render more than one focusable control (e.g. a grouped
+ * capability picker) have no single element a `<label htmlFor>` could
+ * target. Declaring `composite: true` here tells the host's field registry —
+ * and through it the host-owned form layout/shell — to name the rendered
+ * group through `aria-labelledby` on a wrapping element instead of
+ * associating a label with a single control.
+ */
+interface ExtensionFieldTypeRegistration {
+  /** Lazy loader for the field type's component. */
+  loader: ExtensionFieldTypeLoader;
+  /**
+   * Whether the field type renders more than one focusable control.
+   * Defaults to `false` — most field types render exactly one control.
+   */
+  composite?: boolean;
+}
+/**
+ * A single `fieldTypes` contribution entry.
+ *
+ * Accepts either a bare {@link ExtensionFieldTypeLoader} — the common case,
+ * for field types that render exactly one control — or an
+ * {@link ExtensionFieldTypeRegistration} object for field types that must
+ * declare `composite: true`. Registration code should branch on
+ * `typeof entry === 'function'` to distinguish the two shapes.
+ */
+type ExtensionFieldTypeEntry = ExtensionFieldTypeLoader | ExtensionFieldTypeRegistration;
 /**
  * Async loader for a custom extension configuration component.
  *
@@ -2926,22 +3064,34 @@ interface ExtensionUiContribution {
    * Tool call formatter declarations.
    *
    * Formatters customize how specific tool calls are rendered in the chat
-   * UI. Registered with `ToolCallFormatterRegistry` on extension load.
+   * UI. Registered with the host's tool-call formatter registry on extension
+   * load.
    */
   readonly toolFormatters?: readonly ToolCallFormatterDeclaration[];
   /**
    * Custom field type loaders for schema-driven forms.
    *
    * Maps field type identifiers to lazy-loaded React components that accept
-   * `FormFieldProps`. Registered with `FormFieldRegistry` on extension load.
-   * @example
+   * `FormFieldProps`. Registered with the host's field registry on extension
+   * load. Each entry is either a bare loader — for field types that render
+   * exactly one control, the common case — or an
+   * {@link ExtensionFieldTypeRegistration} object declaring `composite: true`
+   * for field types that render more than one focusable control (see
+   * {@link ExtensionFieldTypeEntry}).
+   * @example Single-control field type
    * ```typescript
    * fieldTypes: {
    *   'image-upload': () => import('./ui/ImageUploadField.js'),
    * }
    * ```
+   * @example Composite field type
+   * ```typescript
+   * fieldTypes: {
+   *   'grid-field': { loader: () => import('./ui/GridField.js'), composite: true },
+   * }
+   * ```
    */
-  readonly fieldTypes?: Record<string, ExtensionFieldTypeLoader>;
+  readonly fieldTypes?: Record<string, ExtensionFieldTypeEntry>;
   /**
    * Fully custom configuration component loader.
    *
@@ -3257,14 +3407,6 @@ interface MakaioExtension$1<THostContext extends ExtensionContext$1 = NodeExtens
    * services before package startup begins.
    */
   readonly runtimeBoot?: ExtensionRuntimeBootContribution<THostContext>;
-  /**
-   * When true, startup fails if this extension fails to initialize.
-   *
-   * Optional extensions default to isolated failure so one extension cannot
-   * prevent the runtime from booting. Framework and host core extensions set
-   * this to true when the runtime cannot safely continue without them.
-   */
-  readonly critical?: boolean;
   /**
    * Executable CLI contribution registered under `makaio <name>`.
    *
@@ -3766,6 +3908,8 @@ declare function isDetachedDescriptor$1(descriptor: ExtensionDescriptor$1): desc
  * - `execution === 'detached'` requires `transport`; `entrypoints` is optional.
  * - All other modes (including the default embedded mode) require `entrypoints`.
  * - `prebundleDependencies` requires a `browser` entrypoint.
+ * - `critical` is forbidden alongside a `server` entrypoint, whose exported
+ *   packages own that flag (see {@link ExtensionManifest.critical}).
  *
  * Note: `satisfies z.ZodType<ExtensionDescriptor>` is intentionally omitted
  * because `superRefine` wraps the schema in `ZodEffects`, which is incompatible
@@ -3794,6 +3938,7 @@ declare const ExtensionDescriptorSchema: z.ZodObject<{
     version: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>], "type">>>>;
   provides: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodType<_$_makaio_contracts0.CapabilityToken, unknown, z.core.$ZodTypeInternals<_$_makaio_contracts0.CapabilityToken, unknown>>>>>;
+  critical: z.ZodOptional<z.ZodBoolean>;
   windows: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     style: z.ZodEnum<{
@@ -4070,6 +4215,366 @@ interface ExtensionConfigProvider$1 {
    * @returns `false` to skip the package at boot, `true` or `undefined` to start normally.
    */
   loadEnabled(name: string): boolean | undefined;
+  /**
+   * Write a changed enabled state to persistent storage.
+   *
+   * Optional — a provider that has no durable backing store may omit this.
+   * When present the coordinator calls it on every operator `setEnabled`
+   * request to durably record the preference; the seam is persist-only — it
+   * never applies the change to the running process, only on the next boot.
+   * @param name - Extension package name.
+   * @param enabled - Desired enabled state to persist.
+   */
+  persistEnabled?(name: string, enabled: boolean): Promise<void>;
+}
+//#endregion
+//#region core/contracts/src/extension/extension-name-path-segment.d.ts
+/**
+ * Extension name path-segment codec.
+ *
+ * Encodes an extension name into a single filesystem path segment safe for use
+ * as a directory name (for per-extension data directories) or as an
+ * operator-config file stem. Both uses share one rule so a name valid for one
+ * is valid for both.
+ * @packageDocumentation
+ */
+/**
+ * Characters an encoded path segment reproduces verbatim.
+ *
+ * Deliberately narrow: lowercase letters, digits, and the three punctuation
+ * marks that already appear in ordinary extension names. Everything else is
+ * percent-escaped, which keeps path separators, drive-letter colons, and shell
+ * metacharacters out of the segment entirely — and, deliberately, keeps every
+ * uppercase `A`–`Z` out of it too. An uppercase byte is escaped exactly like
+ * any other byte outside this set, so a canonical segment never contains a
+ * literal uppercase letter; see the case-folding property in
+ * {@link encodeExtensionNameAsPathSegment} for why that closes the
+ * case-insensitive-filesystem hazard rather than merely working around it.
+ *
+ * Exported so every consumer — the data-dir resolver, the operator-config loader,
+ * and any tool that creates either — shares one definition of the rule instead of
+ * restating it.
+ *
+ * Position-independent, with two exceptions the encoder applies on top of it: a
+ * `.` in first position is escaped, so no segment names a hidden file or
+ * directory, and a `.` in last position is escaped, so no segment is one a
+ * Windows path component resolver silently shortens. See
+ * {@link encodeExtensionNameAsPathSegment}.
+ */
+declare const EXTENSION_NAME_PATH_SEGMENT_UNRESERVED: RegExp;
+/**
+ * Suffix every operator-config file carries; JSON is the only accepted format.
+ *
+ * Exported because a file name is its stem followed by this suffix, and both
+ * halves belong to one contract: the length bound below bounds the whole name,
+ * and a loader that strips a suffix before decoding must strip exactly this one.
+ */
+declare const EXTENSION_OPERATOR_CONFIG_FILE_SUFFIX$1 = ".json";
+/**
+ * Longest operator-config file name, in UTF-8 bytes, including the suffix.
+ *
+ * 255 bytes is the per-component limit of every filesystem a Makaio home is
+ * likely to live on — ext4, XFS, btrfs, APFS, and NTFS all stop there or lower.
+ * Percent-encoding expands one non-ASCII character to as many as twelve ASCII
+ * ones, so a name well inside any manifest rule can still produce a segment that
+ * no filesystem accepts; without this bound such a name would be reported as
+ * addressable and then fail at `open` with `ENAMETOOLONG`.
+ *
+ * The bound is on the encoded form rather than on the manifest name, because the
+ * encoded form is what has to fit on disk.
+ *
+ * The bound reserves room for the {@link EXTENSION_OPERATOR_CONFIG_FILE_SUFFIX}
+ * even when encoding a data directory name. This is intentional: a name that
+ * encodes within the limit is valid for both uses, so there is one addressability
+ * rule for the whole codec.
+ */
+declare const MAX_OPERATOR_CONFIG_FILE_NAME_BYTES = 255;
+/**
+ * Directory segment under the Makaio home that holds all per-extension data
+ * directories.
+ *
+ * The full path for an extension's data directory is
+ * `$MAKAIO_HOME/EXTENSION_DATA_DIR_SEGMENT/<encoded>`, where `<encoded>` is
+ * the percent-encoded path segment produced by
+ * {@link encodeExtensionNameAsPathSegment}. Exporting this constant here keeps
+ * the resolver ({@link encodeExtensionNameAsPathSegment}) and every consumer of
+ * the layout in agreement on which subdirectory stores extension data, instead
+ * of each one hardcoding the literal.
+ */
+declare const EXTENSION_DATA_DIR_SEGMENT$1 = "data";
+/**
+ * Encode an extension name as a single filesystem path segment.
+ *
+ * The rule is percent-encoding over UTF-8: every byte outside
+ * {@link EXTENSION_NAME_PATH_SEGMENT_UNRESERVED} becomes `%` followed by two
+ * uppercase hex digits. That was chosen over a substitution scheme such as a
+ * doubled separator because it is the encoding operators already recognise from
+ * URLs, and because it cannot collide — no unreserved character can stand for an
+ * escaped one.
+ *
+ * Four properties matter and all four hold:
+ *
+ * - **Defined for every addressable name**, including scoped and non-ASCII
+ *   ones. The names it is not defined for are the ones no path segment can stand
+ *   for (see `isAddressableExtensionName`) and the ones whose encoded form would
+ *   not fit a filesystem component (see {@link MAX_OPERATOR_CONFIG_FILE_NAME_BYTES}).
+ * - **A single path segment.** `@acme/weather-tools` becomes
+ *   `%40acme%2Fweather-tools`, never a nested directory.
+ * - **Identity on the common case.** `gateway` stays `gateway`, and so does any
+ *   name built from lowercase letters, digits, `.`, `_`, and `-` — which is also
+ *   the package-name convention every extension name in this codebase already
+ *   follows — so the usual segment is the extension name typed out unchanged.
+ *   An uppercase letter changes shape: `Gateway` becomes `%47ateway`, not
+ *   `Gateway`. That is the point, not an accident; see case 4 below.
+ * - **Injective.** Two different addressable names never produce one segment,
+ *   and — because no canonical segment can contain a literal uppercase letter —
+ *   no two *distinct* canonical segments can ever be folded onto each other by a
+ *   case-insensitive comparison either. A segment names exactly one extension on
+ *   every host, including one whose default filesystem ignores case.
+ *
+ * A leading `.` is escaped for a reason that is not about path syntax: it is
+ * unreserved everywhere else in the segment, but a segment that begins with it
+ * would produce a path hidden from the operator who has to inspect it, and
+ * would be indistinguishable from the editor and platform bookkeeping a
+ * Makaio home collects. Escaping it as `%2E` means a canonical segment never
+ * begins with a dot, so `.hidden` is addressable as `%2Ehidden` while
+ * `.DS_Store` remains something this rule cannot have produced.
+ *
+ * The four properties above are stated per name; the codec owes callers a
+ * fifth one across names: **a name must yield exactly one usable directory on
+ * every supported host — macOS, Linux, and Windows — not only on whichever
+ * host happens to be running.** A name and a segment that satisfy the four
+ * per-name properties can still fail the fifth one, because a host can look at
+ * an encoded segment and read a different path component than the bytes that
+ * were written, or no component at all. Every way a supported host does that
+ * is enumerated here, together with which of the two mechanisms below closes
+ * it — so this list, not a changelog of review rounds, is what a future
+ * reviewer checks a new host quirk against:
+ *
+ * 1. **Reserved Windows device basenames** (`CON`, `NUL`, `COM1`, `LPT1`,
+ *    …) — {@link isAddressableExtensionName} rejects a name whose basename up
+ *    to its first `.` is one of these, case-insensitively, because `CreateFile`
+ *    on a name in this set opens a device, not a path, no matter which
+ *    directory precedes it or what follows the first `.` (`CON.txt`,
+ *    `NUL.tar.gz`). No escape can rescue this — the whole point of the name is
+ *    to open the device — so it is rejected rather than escaped, on every host,
+ *    not only Windows. A name that merely *resembles* one, such as `CONSOLE`
+ *    or `COM10`, keeps its segment.
+ * 2. **A trailing `.` on a Windows path component is stripped** by the Win32
+ *    layer before the name is resolved, the same mechanism that lets `CON.`
+ *    open the device that `CON` does — so `gateway` and `gateway.` would
+ *    resolve to the same directory on Windows even though they are two
+ *    distinct, valid segments by every property above. Unlike a reserved
+ *    basename, this is rescuable: escaping the segment's *last* character as
+ *    `%2E` when it is a literal `.` means no canonical segment ends with a
+ *    dot, so `gateway.` is addressable as `gateway%2E` and stays distinct from
+ *    `gateway` on every host, mirroring the leading-dot escape above. Because
+ *    this closes the hazard at the encoding, no case-insensitive-style
+ *    collision entry is needed for it — the two names never produce
+ *    colliding segments in the first place.
+ * 3. **A trailing space on a Windows path component is stripped** the same
+ *    way, so `gateway` and `gateway ` would collide by the same mechanism as
+ *    (2). This needs no dedicated escape: a space is outside
+ *    {@link EXTENSION_NAME_PATH_SEGMENT_UNRESERVED} and is therefore *always*
+ *    percent-escaped to `%20` regardless of position, so a canonical segment
+ *    can never end — or contain — a literal space for Windows to strip. A name
+ *    such as `NUL ` (a reserved basename with a trailing space) is addressable
+ *    for the same reason: its segment is `NUL%20`, which is neither the
+ *    reserved basename nor something Windows shortens into it.
+ * 4. **Case folding on a case-insensitive filesystem** (the default on macOS
+ *    and Windows) cannot keep two segments apart that differ only in case —
+ *    and, unlike (2) and (3), this cannot be closed by checking the *loaded*
+ *    name set, because the other half of a colliding pair need not be loaded
+ *    at all: an extension can be uninstalled and leave its data directory
+ *    behind, or be filtered onto a different surface, and either way it is
+ *    absent from any set a coordinator could inspect while the survivor
+ *    starts and is handed the same directory unknowingly. The only knowledge
+ *    that is always available is the one name being encoded right now, so the
+ *    fix has to live here: every uppercase `A`–`Z` byte is percent-escaped,
+ *    exactly like any other byte outside
+ *    {@link EXTENSION_NAME_PATH_SEGMENT_UNRESERVED}, so a canonical segment
+ *    never contains a literal uppercase letter at all. The only uppercase ASCII
+ *    that can appear in a canonical segment is the hex digits `A`–`F` inside an
+ *    escape triplet (`%`, followed by two uppercase hex digits), and `%` itself
+ *    is always escaped when literal, so every `%` in a canonical segment
+ *    starts such a triplet. Case-folding a canonical segment therefore only
+ *    ever touches those hex digits, uniformly and in lockstep between any two
+ *    segments that agree everywhere else — it can never turn one *distinct*
+ *    canonical segment into another, because doing so would require an
+ *    uppercase letter outside a triplet to fold onto a literal character, and
+ *    no literal character is ever uppercase. `Gateway` and `gateway` — the
+ *    case this closes concretely — encode to `%47ateway` and `gateway`, which
+ *    share no literal uppercase letter to fold and therefore cannot collide on
+ *    any host. This is why no load-set collision detector is needed for this
+ *    codec any more: distinctness is now a property of one name at a time, not
+ *    of a set the coordinator happens to have assembled.
+ * 5. **Unicode normalisation-insensitive comparison**, which macOS's default
+ *    APFS format performs (verified directly: creating a directory named with
+ *    the NFC form of `café` and then the NFD form of the same text on this
+ *    codec's own development host fails the second `mkdir` with `EEXIST`,
+ *    even though the two names are different byte sequences), cannot collide
+ *    two segments this function produces, because normalisation-insensitive
+ *    comparison only folds *combining* Unicode sequences into their composed
+ *    or decomposed equivalent, and every byte outside
+ *    {@link EXTENSION_NAME_PATH_SEGMENT_UNRESERVED} — which is exactly the set
+ *    of bytes normalisation could ever fold — is percent-escaped into three
+ *    literal ASCII characters that are not combining sequences and do not
+ *    themselves have a second normalised form. Two Unicode-normalisation
+ *    variants of one name, such as the NFC and NFD spellings of `café`,
+ *    therefore encode to two segments (`caf%C3%A9` and `cafe%CC%81`) that stay
+ *    distinct on every host without any additional escape or collision check.
+ *
+ * Two more properties of the encoding matter because a host has no
+ * normalisation to defend against them: a name whose basename is a reserved
+ * Windows device name has no rescuable segment (case 1, above, restated as an
+ * exhaustiveness note), and 8.3 short-name generation on NTFS — a Windows
+ * feature, often disabled, that derives a second, shortened alias for a long
+ * name from filesystem-generated state this codec cannot predict — is a known,
+ * unaddressed limitation: a manifest name could in principle collide with
+ * another extension's *generated* short alias, but only NTFS decides that
+ * alias, so no encoding choice here can rule it out. The failure mode is a
+ * loud `EEXIST` at directory creation, not the silent data-sharing every other
+ * item in this list defends against, so it is documented rather than
+ * engineered around.
+ *
+ * The encoded segment fits within {@link MAX_OPERATOR_CONFIG_FILE_NAME_BYTES}
+ * minus the {@link EXTENSION_OPERATOR_CONFIG_FILE_SUFFIX} length. This shared
+ * bound means a name encodable as a data-directory segment is also encodable as
+ * an operator-config file stem, and vice versa.
+ * @param extensionName - Extension manifest name to encode.
+ * @returns The path segment for that name, or `undefined` when no segment can
+ *   address the name on every supported host (empty name, dot segment,
+ *   non-well-formed Unicode, a reserved Windows device basename, or encoded
+ *   form too long for a filesystem component).
+ */
+declare function encodeExtensionNameAsPathSegment$1(extensionName: string): string | undefined;
+/**
+ * Decode an encoded path segment back to the extension name it addresses.
+ *
+ * The inverse of {@link encodeExtensionNameAsPathSegment}, and strict about it:
+ * a segment is accepted only when it is exactly what encoding that name produces.
+ * Lowercase escapes, escapes for characters that need none, and unescaped
+ * characters outside the unreserved set are all rejected, so one extension has
+ * one spelling and a scan cannot bind two segments to the same extension.
+ *
+ * Rejection is not a failure to report to an operator by itself — a segment that
+ * does not decode simply does not address any extension. The caller decides
+ * whether that deserves a diagnostic, exactly as it does for a segment that
+ * decodes to an extension it has not loaded.
+ * @param segment - Candidate path segment, with any file extension already removed
+ *   when decoding an operator-config file stem.
+ * @returns The extension name, or `undefined` when the segment is not a canonical
+ *   encoding of one. A segment that spells a name no file can address — the empty
+ *   name, a dot segment, or one that is not well-formed Unicode — is rejected by
+ *   the same round-trip, because encoding such a name produces no segment at all —
+ *   and so is a segment that begins or ends with a literal dot, or one whose
+ *   encoded form would exceed {@link MAX_OPERATOR_CONFIG_FILE_NAME_BYTES}. A name
+ *   that contains dots anywhere but first or last, such as `com.example.tools`, is
+ *   accepted; a name that begins or ends with one is spelled `%2Ehidden` or
+ *   `gateway%2E`, never `.hidden` or `gateway.`. A segment spelled `CON` or
+ *   `COM1.log` is rejected too, because a reserved Windows device basename has no
+ *   segment at all — encoding it produces `undefined`, not a literal spelling for
+ *   the round-trip to match.
+ */
+declare function decodeExtensionNamePathSegment$1(segment: string): string | undefined;
+//#endregion
+//#region core/contracts/src/extension/extension-operator-config.d.ts
+/**
+ * Why an operator-supplied configuration entry cannot be turned into a
+ * configuration object.
+ *
+ * The values describe the shape of the problem, not its origin: the layer that
+ * produces entries is free to source them from anywhere, and reports the
+ * concrete origin through {@link ExtensionOperatorConfigFailure.source}.
+ */
+type ExtensionOperatorConfigFailureReason = /** The entry's backing store could not be read at all. */'unreadable' /** The entry's payload is not well-formed JSON. */ | 'invalid-json' /** The entry's payload is well-formed JSON whose top-level value is not an object. */ | 'not-an-object';
+/** Fields shared by every {@link ExtensionOperatorConfigEntry} variant. */
+interface ExtensionOperatorConfigEntryBase {
+  /**
+   * Opaque, human-readable label identifying where this entry came from.
+   *
+   * Reproduced verbatim in diagnostics so an operator can find and correct the
+   * offending input. The consumer never parses or interprets it.
+   */
+  readonly source: string;
+}
+/** An operator-supplied configuration object for one extension. */
+interface ExtensionOperatorConfigValue extends ExtensionOperatorConfigEntryBase {
+  /** Discriminant selecting the usable variant. */
+  readonly kind: 'config';
+  /**
+   * The operator's configuration object for the extension.
+   *
+   * Applied as the highest-precedence layer of the extension's configuration
+   * chain. It is not validated by the producer — the extension's own config
+   * schema is the authority.
+   *
+   * Typed as JSON values because the layer merges one level deep: a key the
+   * operator declares replaces the lower layers' value for that key. `undefined`
+   * is not a JSON value and must never appear, or a key the operator never
+   * meant to touch would be blanked out rather than overridden.
+   */
+  readonly config: Readonly<Record<string, JsonValue$1>>;
+}
+/** An operator-supplied configuration entry that could not be read or parsed. */
+interface ExtensionOperatorConfigFailure extends ExtensionOperatorConfigEntryBase {
+  /** Discriminant selecting the failure variant. */
+  readonly kind: 'failure';
+  /** Category of the problem, used to phrase the diagnostic. */
+  readonly reason: ExtensionOperatorConfigFailureReason;
+  /**
+   * Underlying error text, when the producer has one.
+   *
+   * Appended to the diagnostic raised when the affected extension activates,
+   * which is logged and persisted as the extension's failure reason. Producers
+   * supply a short explanation of why the entry could not be used — never the
+   * entry's own content, which may be large or hold values an operator does not
+   * expect to see echoed. The consumer flattens control characters and bounds
+   * the length regardless.
+   */
+  readonly detail?: string;
+}
+/**
+ * One operator-supplied configuration entry: either a usable configuration
+ * object or a source-aware failure.
+ */
+type ExtensionOperatorConfigEntry$1 = ExtensionOperatorConfigValue | ExtensionOperatorConfigFailure;
+/**
+ * Abstract, operator-owned configuration layer keyed by extension name.
+ *
+ * Supplied by the host composition root and consulted at every extension
+ * configuration-resolution point. It is the highest-precedence layer: its
+ * values override both descriptor/host defaults and stored configuration
+ * records, because an operator entry is an explicit, hand-authored decision
+ * that a later write from another tier must not silently erase.
+ *
+ * The contract is deliberately free of storage vocabulary. A producer decides
+ * where entries come from; the consumer only distinguishes "usable
+ * configuration" from "unusable, and here is where it came from".
+ *
+ * Implementations are expected to be immutable for the lifetime of the
+ * coordinator that consumes them, so an extension that is stopped and started
+ * again resolves against the same values.
+ */
+interface ExtensionOperatorConfigSource$1 {
+  /**
+   * Look up the operator entry for one extension.
+   *
+   * **Must not throw, and must be stable.** For the lifetime of the coordinator
+   * that holds the source, the same name must yield an equivalent entry — the
+   * same variant, the same `source`, and the same configuration values. A
+   * producer therefore captures its inputs once, up front, and answers every
+   * later lookup from that immutable snapshot rather than re-reading them.
+   *
+   * Stability is what lets an extension be stopped and started again without
+   * its configuration changing underneath it, and what lets read-only callers
+   * resolve an already-active extension's context knowing the operator layer
+   * cannot newly reject it.
+   * @param extensionName - Extension package name to look up.
+   * @returns The operator entry, or `undefined` when the operator supplied
+   *   nothing for this extension.
+   */
+  get(extensionName: string): ExtensionOperatorConfigEntry$1 | undefined;
 }
 //#endregion
-export { PluginToolCallFormatterInput as $, ContributionManifestSchema as $n, SessionEventActionDeclaration as $t, BootstrapImportResult as A, TrayManifest$1 as An, GatheredEntry as At, LogImportContribution as B, CapabilityToken as Bn, ActionShortcutModifiers as Bt, BootstrapAsset as C, ExtensionManifestSchema as Cn, UiContextValueMap as Ct, BootstrapExportContext as D, StorageDialect$1 as Dn, UiScope$1 as Dt, BootstrapDiscoverContext as E, STORAGE_DIALECTS as En, UiRuntimeNavigationLevel as Et, ExtensionHashTriggersContribution as F, WindowParamSpecSchema as Fn, HashTriggerStage as Ft, LoaderContext as G, AdapterManifest as Gn, ExecuteResult as Gt, ExtensionConfigComponentLoader as H, CapabilityTokenSchema as Hn, EntrypointConfig as Ht, ExtensionNamespaceContribution as I, WindowStyle as In, HashTriggerSuggestResult as It, MakaioWebUiComponentProps as J, ArtifactLifecycleHookManifest as Jn, PickerConfig as Jt, MakaioWebUiAction as K, AdapterManifestSchema as Kn, MessageEventFilter as Kt, ExtensionSessionEventActionsContribution as L, allMigrationsPaths as Ln, ActionCategory as Lt, ExtensionBootstrap as M, WindowManifest as Mn, HashTrigger as Mt, getBootstrapAssetKey as N, WindowManifestSchema as Nn, HashTriggerContext as Nt, BootstrapExportResult as O, StorageManifest as On, UiScopeMap as Ot, AdapterContribution as P, WindowParamSpec as Pn, HashTriggerMetadata as Pt, PluginFormattedToolCallOutput as Q, ContributionManifest as Qn, SessionEventActionContext as Qt, ExtensionToolsContribution as R, dep$1 as Rn, ActionCategoryMap as Rt, MakaioNodeExtension$1 as S, ExtensionManifest as Sn, UiContextSnapshot$1 as St, BootstrapChoice as T, RuntimeRequirementSchema as Tn, UiNavigationLevelMap as Tt, ExtensionConfigComponentProps as U, AdapterClientRef$1 as Un, EventFilter as Ut, ExtensionWorkflowBlocksContribution as V, CapabilityTokenMap as Vn, CreateSessionEventActionResult as Vt, ExtensionFieldTypeLoader as W, AdapterClientRefSchema as Wn, ExecuteContext as Wt, MakaioWebUiRoute as X, ClientManifest as Xn, SelectionChangeContext as Xt, MakaioWebUiLoader as Y, ArtifactLifecycleHookManifestSchema as Yn, PickerOpenContext as Yt, PromisifiedActions as Z, ClientManifestSchema as Zn, SelectionFeedback as Zt, ExtensionArtifactLifecycleHooksContribution as _, CliManifestSchema as _n, TileDeclaration as _t, DetachedTransportSchema as a, ExtensionCliBeforeRunResult as an, ProtocolConfig as ar, PageMode as at, ExtensionRuntimeBootContribution as b, ExtensionDependency as bn, TileRenderers as bt, ExtensionDescriptorBase as c, ExtensionCliInteractiveContext as cn, ProtocolRefSchema as cr, SlotId as ct, ExtensionEntrypoints as d, AdapterDefinitionContract$1 as dn, SessionEventActionManifest as dr, WidgetDeclaration as dt, SessionEventActionOptions as en, HashTriggerManifest as er, PluginTransformedContent as et, ExtensionEntrypointsSchema as f, AdapterProviderDefinitionContract$1 as fn, SessionEventActionManifestSchema as fr, WidgetDefinition as ft, ArtifactLifecycleHooksContributionContext as g, CliManifest as gn, BrowserEntrypointSchema$1 as gr, TileCapabilities as gt, safeParseExtensionDescriptor$1 as h, CliArgManifestSchema as hn, BrowserEntrypoint as hr, WidgetSize$1 as ht, DetachedTransportConfig as i, ExtensionCliBeforeRunContext as in, LogImporterManifestSchema as ir, PageDeclaration as it, BootstrapResult as j, TrayManifestSchema as jn, HashSuggestion as jt, BootstrapImportContext as k, StorageManifestSchema as kn, GatheredContext as kt, ExtensionDescriptorParseResult as l, ExtensionCliOutputWriter as ln, ProviderManifest as lr, SlotPlacementDeclaration as lt, parseExtensionDescriptor$1 as m, CliArgManifest as mn, UiSurfaceFlagsSchema as mr, WidgetRenderers as mt, parseExtensionConfig as n, WhenContext as nn, HashTriggerStageManifest as nr, ToolCallFormatterDeclaration as nt, EmbeddedDescriptor as o, ExtensionCliContribution as on, ProtocolConfigSchema as or, SlotContentDeclaration as ot, isDetachedDescriptor$1 as p, AdapterProviderRef$1 as pn, UiSurfaceFlags as pr, WidgetProps as pt, MakaioWebUiActions as q, ArtifactLifecycleHookEventSchema as qn, MessageRole as qt, DetachedDescriptor as r, ExtensionRuntimeOwnership as rn, LogImporterManifest as rr, PageComponentProps as rt, ExtensionDescriptor$1 as s, ExtensionCliHandlerContext as sn, ProtocolRef as sr, SlotDeclaration as st, ExtensionConfigProvider$1 as t, StructuralEventFilter as tn, HashTriggerManifestSchema as tr, PluginTransformedContentType as tt, ExtensionDescriptorSchema as u, ExtensionCliSubcommandEntry as un, ProviderManifestSchema as ur, WidgetSize as ut, ExtensionContributionProcessor$1 as v, CliSubcommandManifest as vn, TileIconLoader as vt, BootstrapAssetKey as w, RuntimeRequirement as wn, UiNavigationLevel$1 as wt, MakaioExtension$1 as x, ExtensionDependencySchema as xn, UiContextDimension as xt, ExtensionRuntimeBootContext as y, CliSubcommandManifestSchema as yn, TileProps as yt, ExtensionUiContribution as z, primaryMigrationsPath$1 as zn, ActionShortcut as zt };
+export { ExtensionConfigComponentLoader as $, WindowStyle as $n, ActionShortcut as $t, ExtensionRuntimeBootContext as A, normalizeExtensionManifestExport$1 as An, UiSurfaceFlags as Ar, TileCapabilities as At, BootstrapImportContext as B, ExtensionManifestSchema as Bn, UiRuntimeNavigationLevel as Bt, ExtensionEntrypointsSchema as C, ExtensionCliInteractiveContext as Cn, ProtocolConfigSchema as Cr, SlotPlacementDeclaration as Ct, ArtifactLifecycleHooksContributionContext as D, AdapterProviderDefinitionContract$1 as Dn, ProviderManifestSchema as Dr, WidgetProps as Dt, safeParseExtensionDescriptor$1 as E, AdapterDefinitionContract$1 as En, ProviderManifest as Er, WidgetDefinition as Et, BootstrapAssetKey as F, CliSubcommandManifest as Fn, UiContextDimension as Ft, AdapterContribution as G, StorageManifest as Gn, HashSuggestion as Gt, BootstrapResult as H, RuntimeRequirementSchema as Hn, UiScopeMap as Ht, BootstrapChoice as I, CliSubcommandManifestSchema as In, UiContextSnapshot$1 as It, ExtensionSessionEventActionsContribution as J, TrayManifestSchema as Jn, HashTriggerMetadata as Jt, ExtensionHashTriggersContribution as K, StorageManifestSchema as Kn, HashTrigger as Kt, BootstrapDiscoverContext as L, ExtensionDependency as Ln, UiContextValueMap as Lt, MakaioExtension$1 as M, CliArgManifestSchema as Mn, BrowserEntrypoint as Mr, TileIconLoader as Mt, MakaioNodeExtension$1 as N, CliManifest as Nn, BrowserEntrypointSchema$1 as Nr, TileProps as Nt, ExtensionArtifactLifecycleHooksContribution as O, AdapterProviderRef$1 as On, SessionEventActionManifest as Or, WidgetRenderers as Ot, BootstrapAsset as P, CliManifestSchema as Pn, TileRenderers as Pt, ExtensionWorkflowBlocksContribution as Q, WindowParamSpecSchema as Qn, ActionCategoryMap as Qt, BootstrapExportContext as R, ExtensionDependencySchema as Rn, UiNavigationLevel$1 as Rt, ExtensionEntrypoints as S, ExtensionCliHandlerContext as Sn, ProtocolConfig as Sr, SlotId as St, parseExtensionDescriptor$1 as T, ExtensionCliSubcommandEntry as Tn, ProtocolRefSchema as Tr, WidgetDeclaration as Tt, ExtensionBootstrap as U, STORAGE_DIALECTS as Un, GatheredContext as Ut, BootstrapImportResult as V, RuntimeRequirement as Vn, UiScope$1 as Vt, getBootstrapAssetKey as W, StorageDialect$1 as Wn, GatheredEntry as Wt, ExtensionUiContribution as X, WindowManifestSchema as Xn, HashTriggerSuggestResult as Xt, ExtensionToolsContribution as Y, WindowManifest as Yn, HashTriggerStage as Yt, LogImportContribution as Z, WindowParamSpec as Zn, ActionCategory as Zt, EmbeddedDescriptor as _, ExtensionRuntimeOwnership as _n, HashTriggerManifest as _r, PageComponentProps as _t, ExtensionOperatorConfigValue as a, ExecuteResult as an, CapabilityTokenSchema as ar, LoaderContext as at, ExtensionDescriptorParseResult as b, ExtensionCliBeforeRunResult as bn, LogImporterManifest as br, SlotContentDeclaration as bt, EXTENSION_OPERATOR_CONFIG_FILE_SUFFIX$1 as c, PickerConfig as cn, AdapterManifest as cr, MakaioWebUiComponentProps as ct, encodeExtensionNameAsPathSegment$1 as d, SelectionFeedback as dn, ArtifactLifecycleHookManifest as dr, PromisifiedActions as dt, ActionShortcutModifiers as en, allMigrationsPaths as er, ExtensionConfigComponentProps as et, ExtensionConfigProvider$1 as f, SessionEventActionContext as fn, ArtifactLifecycleHookManifestSchema as fr, PluginFormattedToolCallOutput as ft, DetachedTransportSchema as g, WhenContext as gn, ContributionManifestSchema as gr, ToolCallFormatterDeclaration as gt, DetachedTransportConfig as h, StructuralEventFilter as hn, ContributionManifest as hr, PluginTransformedContentType as ht, ExtensionOperatorConfigSource$1 as i, ExecuteContext as in, CapabilityTokenMap as ir, ExtensionOperatorConfigProvenance as it, ExtensionRuntimeBootContribution as j, CliArgManifest as jn, UiSurfaceFlagsSchema as jr, TileDeclaration as jt, ExtensionContributionProcessor$1 as k, isExtensionManifestLike$1 as kn, SessionEventActionManifestSchema as kr, WidgetSize$1 as kt, MAX_OPERATOR_CONFIG_FILE_NAME_BYTES as l, PickerOpenContext as ln, AdapterManifestSchema as lr, MakaioWebUiLoader as lt, DetachedDescriptor as m, SessionEventActionOptions as mn, ClientManifestSchema as mr, PluginTransformedContent as mt, ExtensionOperatorConfigFailure as n, EntrypointConfig as nn, primaryMigrationsPath$1 as nr, ExtensionFieldTypeLoader as nt, EXTENSION_DATA_DIR_SEGMENT$1 as o, MessageEventFilter as on, AdapterClientRef$1 as or, MakaioWebUiAction as ot, parseExtensionConfig as p, SessionEventActionDeclaration as pn, ClientManifest as pr, PluginToolCallFormatterInput as pt, ExtensionNamespaceContribution as q, TrayManifest$1 as qn, HashTriggerContext as qt, ExtensionOperatorConfigFailureReason as r, EventFilter as rn, CapabilityToken as rr, ExtensionFieldTypeRegistration as rt, EXTENSION_NAME_PATH_SEGMENT_UNRESERVED as s, MessageRole as sn, AdapterClientRefSchema as sr, MakaioWebUiActions as st, ExtensionOperatorConfigEntry$1 as t, CreateSessionEventActionResult as tn, dep$1 as tr, ExtensionFieldTypeEntry as tt, decodeExtensionNamePathSegment$1 as u, SelectionChangeContext as un, ArtifactLifecycleHookEventSchema as ur, MakaioWebUiRoute as ut, ExtensionDescriptor$1 as v, isRuntimeOwnershipFieldClaimed$1 as vn, HashTriggerManifestSchema as vr, PageDeclaration as vt, isDetachedDescriptor$1 as w, ExtensionCliOutputWriter as wn, ProtocolRef as wr, WidgetSize as wt, ExtensionDescriptorSchema as x, ExtensionCliContribution as xn, LogImporterManifestSchema as xr, SlotDeclaration as xt, ExtensionDescriptorBase as y, ExtensionCliBeforeRunContext as yn, HashTriggerStageManifest as yr, PageMode as yt, BootstrapExportResult as z, ExtensionManifest as zn, UiNavigationLevelMap as zt };