@almadar/shell-web 0.0.0-stage → 0.1.0

package/dist/runtime/index.d.ts

@@ -0,0 +1,440 @@
+import { EventPayload, OrbitalDefinition, SchemaMetadata, PersistenceAdapter, ServiceParams, UserContext, ResolvedTraitBinding, ResolvedPage, ResolvedEntity, ResolvedTrait, ResolvedIR, OrbitalSchema, PatternConfig, ResolvedPatternProps, EventSource, SExpr, EntityData, ViewerAuthority, TraitValue, TraitValueMountResult, BehaviorRef, BehaviorValueMountResult } from '@almadar/core';
+export { ResolvedEntity, ResolvedIR, ResolvedPage, ResolvedTrait, ResolvedTraitBinding } from '@almadar/core';
+import { TraitState } from '@almadar/shell-runtime/client/trait-types';
+import { EventTransport, AccessTokenProvider } from '@almadar/shell-runtime/client/EventTransport';
+export { AccessTokenProvider } from '@almadar/shell-runtime/client/EventTransport';
+import '../verification-C5pTeMJv.js';
+import { S as ServerBridgeTransport } from '../ServerBridge-Cm1On51b.js';
+import { EntityBindingSource, AwaitingSkeletonSource } from '../providers/index.js';
+export { a as EntitySchemaContextValue, b as EntitySchemaProvider, c as EntitySchemaProviderProps, d as ServerBridgeContextValue, e as ServerBridgeProvider, T as TraitContext, f as TraitContextValue, g as TraitInstance, h as TraitProvider, i as TraitProviderProps, u as useEntitySchema, j as useEntitySchemaOptional, k as useServerBridge, l as useTrait, m as useTraitContext } from '../ServerBridge-Cm1On51b.js';
+import { useUISlots } from '../context/index.js';
+export { w as wrapCallbackForEvent } from '../wrapCallbackForEvent-B9QLbhxX.js';
+export { a as PERF_NAMESPACE, P as PerfEntry, c as clearPerf, p as perfEnd, b as perfStart, d as perfTime } from '../perf-Dr28-AgT.js';
+import React__default, { ReactNode } from 'react';
+import { UserData } from '../context/index.js';
+import { SchemaLoader } from '@almadar/shell-runtime/kernel/wire';
+import { KernelLoader, LanguageLoader, SeedProgramLoader } from '../providers/index.js';
+import { KeyCaptureTable } from '../components/index.js';
+export { S as SlotHostManifest, a as SlotHostRegion, b as assertUniqueSlotsPerHost } from '../slot-host-CPzrxLo9.js';
+export { p as profilerOnRender, u as usePerfBuffer } from '../perf-CKiBKbkw.js';
+import '../useUISlots-CiobNFGb.js';
+import '@almadar/core/patterns';
+
+interface TraitStateMachineResult {
+    /** Current state for each trait. */
+    traitStates: Map<string, TraitState>;
+    /** Send an event — broadcasts to every currently-mounted trait that can
+     *  handle it, decomposed into one targeted `kernel.dispatch` per trait
+     *  (the client role requires exactly one seed trait per call). */
+    sendEvent: (eventKey: string, payload?: EventPayload) => void;
+    getTraitState: (traitName: string) => TraitState | undefined;
+    canHandleEvent: (traitName: string, eventKey: string) => boolean;
+    /** Live per-trait binding surface for `EntityBindingContext`. */
+    entityBindingSource: EntityBindingSource;
+    /** Awaiting-server skeletons for `AwaitingSkeletonContext`. */
+    awaitingSkeletonSource: AwaitingSkeletonSource;
+}
+interface UseTraitStateMachineOptions {
+    onEventProcessed?: (eventKey: string, payload?: EventPayload) => void;
+    navigate?: (path: string, params?: Record<string, string>, crumb?: string) => void;
+    navigateBack?: () => void;
+    initPayload?: EventPayload;
+    /** The mounted page's identity; with `initPayload` it keys the once-per-mount lifecycle guard (Runtime Spec Clause 4.1). */
+    mountKey?: string;
+    /** The route the page is opened at; the kernel's mounts for it are what the hook runs (EXEC-ENDPOINT-3). */
+    routePath?: string;
+    /** The resolved schema's full orbital set — `buildTraitIndex`'s one input. */
+    orbitals: readonly OrbitalDefinition[];
+    /** The program's `_metadata` (a compiled client program's operator sites and dispatch facts), handed to the kernel. */
+    metadata?: SchemaMetadata;
+    /** Caller-owned transport (server bridge). Omitted + `persistence` set =
+     *  offline preview (plan G7); omitted + no `persistence` = fully local,
+     *  nothing ever posts. */
+    transport?: EventTransport;
+    carriesCircuitState?: boolean;
+    /** Hold every dispatch until the transport's topology is known. */
+    awaitTopology?: boolean;
+    persistence?: PersistenceAdapter;
+    /** The browser store for `[persistent: x, browser]` entities (see `useCircuitKernel`). */
+    browserStore?: PersistenceAdapter;
+    callService?: (service: string, action: string, params?: ServiceParams) => Promise<EventPayload>;
+    embeddedTraits?: ReadonlySet<string>;
+    callsiteCaptureChildrenByTrait?: ReadonlyMap<string, ReadonlySet<string>>;
+    debug?: boolean;
+    logContext?: {
+        behavior?: string;
+        orbitalName?: string;
+    };
+    /** Explicit viewer override (e.g. a persona switcher's picked identity
+     *  threaded down as a prop rather than through `UserContext`). Wins over
+     *  `useUser()`'s context value when supplied. */
+    user?: UserContext;
+}
+declare function useTraitStateMachine(traitBindings: ResolvedTraitBinding[], uiSlots: ReturnType<typeof useUISlots>, options: UseTraitStateMachineOptions): TraitStateMachineResult;
+
+/**
+ * useResolvedSchema Hook
+ *
+ * Resolves OrbitalSchema to IR for the OrbitalRuntime.
+ * Uses the shared resolver to ensure consistency with the compiler.
+ *
+ * TRAIT-DRIVEN ARCHITECTURE:
+ * - Pages have traits, NOT sections
+ * - UI is produced by trait effects (render_ui)
+ * - No backwards compatibility with legacy formats
+ *
+ * @packageDocumentation
+ */
+
+interface ResolvedSchemaResult {
+    /** The resolved page (or undefined if not found) */
+    page: ResolvedPage | undefined;
+    /** Trait bindings for this page */
+    traits: ResolvedTraitBinding[];
+    /** Entities used by this page */
+    entities: Map<string, ResolvedEntity>;
+    /** All entities from schema */
+    allEntities: Map<string, ResolvedEntity>;
+    /** All resolved traits */
+    allTraits: Map<string, ResolvedTrait>;
+    /** Loading state */
+    loading: boolean;
+    /** Error message if resolution failed */
+    error: string | null;
+    /** Full IR (for debugging) */
+    ir: ResolvedIR | null;
+}
+/**
+ * Hook to resolve an OrbitalSchema to IR.
+ *
+ * @param schema - The OrbitalSchema to resolve
+ * @param pageName - Optional page name (defaults to first page or initial page)
+ * @returns Resolved schema data including page, traits, and entities
+ */
+declare function useResolvedSchema(schema: OrbitalSchema | null | undefined, pageName?: string): ResolvedSchemaResult;
+/**
+ * Clear the schema resolution cache
+ */
+declare function clearSchemaCache(): void;
+
+/**
+ * One pattern within a slot's accumulated render-ui set, plus any
+ * caller-supplied props that should be merged on top.
+ */
+interface SlotPatternEntry {
+    /** `PatternConfig` normally; a bare `@trait.X` string is the
+     *  G-RUNTIME-025 whole-slot payload (`(render-ui main "@trait.X")`),
+     *  which `useSlotFlush`'s unwrap routes as a TraitFrame child reference. */
+    pattern: PatternConfig | string;
+    props: ResolvedPatternProps;
+}
+/**
+ * The originating trait + state for a slot write. Embedded in the
+ * `useUISlots` SlotContent's metadata so observers (verifier, debugger,
+ * cross-orbital tracer) can attribute every render to the trait that
+ * caused it.
+ */
+interface SlotSource extends EventSource {
+    trait: string;
+    state: string;
+    transition: string;
+    effects: SExpr[];
+    traitDefinition: ResolvedTrait;
+}
+
+/**
+ * OrbPreview Component
+ *
+ * Renders a live preview of an Orbital schema (.orb program).
+ * Uses static imports (no lazy loading) to ensure all providers,
+ * hooks, and components share the same module instances.
+ *
+ * Usage:
+ *   <OrbPreview schema={orbJsonStringOrObject} />
+ *   <OrbPreview schema={schema} serverUrl="/api/orbitals" />
+ *
+ * @packageDocumentation
+ */
+
+interface OrbPreviewProps {
+    /**
+     * The orbital schema. Accepts a JSON string or an `OrbitalSchema` object
+     * from `@almadar/core` (the validated `.orb` program type).
+     */
+    schema: string | OrbitalSchema;
+    /**
+     * Mock entity rows keyed by entity name. The `EntityData` type from
+     * `@almadar/core` is `Record<string, EntityRow[]>` where each row is a
+     * `{ id?: string } & Record<string, FieldValue>`. Ignored if `autoMock`
+     * is set.
+     */
+    mockData?: EntityData;
+    /**
+     * When true, run the schema through `prepareSchemaForPreview` before
+     * rendering: auto-generate mock entity rows and flip two-state INIT
+     * machines so the data state is initial. This is the same pipeline the
+     * playground uses, so consumers (docs MDX, playground) all share one path.
+     *
+     * Ignored when `serverUrl` is set — server-driven previews provide their
+     * own data.
+     */
+    autoMock?: boolean;
+    /** Preview container height. Default: '400px'. */
+    height?: string;
+    /** CSS class for the outer container. */
+    className?: string;
+    /** Server URL for dual execution (e.g. "/api/orbitals"). When set, events are forwarded to the server. */
+    serverUrl?: string;
+    /**
+     * Custom transport for in-process execution. Mutually exclusive with
+     * `serverUrl`. Used by an in-process host to invoke
+     * `OrbitalServerRuntime.processOrbitalEvent` directly without HTTP.
+     */
+    transport?: ServerBridgeTransport;
+    /** Bearer token for `serverUrl` requests (see `ServerBridgeProviderProps.getAccessToken`). */
+    getAccessToken?: AccessTokenProvider;
+    /**
+     * Loads the initialised `@almadar/kernel`. Given, the preview runs its circuits on the kernel engine and installs the
+     * render evaluator from it (`KernelEngineProvider`); keep the function's identity stable across renders. Absent, the
+     * preview runs under whatever engine the host's own `KernelEngineProvider` selects.
+     */
+    kernelLoader?: KernelLoader;
+    /** Resolves the language bundle a kernel opened over browser-stored rows needs (forwarded to `KernelEngineProvider`); keep its identity stable. */
+    languageLoader?: LanguageLoader;
+    /** Resolves the std mock-seed program that seeds a browser store. */
+    seedProgramLoader?: SeedProgramLoader;
+    /**
+     * How long (ms) to wait for the server bridge to connect before assuming
+     * it's unreachable and falling back to local-only execution. Default
+     * 5000 (unchanged unless you pass this). Widen it for a caller whose
+     * schema is large enough that the server's first `register()` genuinely
+     * takes longer than 5s (e.g. a 53-orbital organism measured ~14.5s in
+     * production) — see `TraitInitializer`'s `localFallbackTimeoutMs` doc.
+     */
+    localFallbackTimeoutMs?: number;
+    /**
+     * Initial page path to render (e.g. `/deals`). Resolves against the
+     * schema's `pages[]` to seed `currentPage` so the right orbital's traits
+     * mount on first render. Without this the playground falls back to the
+     * schema's first page binding (gap #13 Phase 5). runtime-verify uses this
+     * to walk DealCreate, NoteCompose, etc. on their owning pages.
+     */
+    initialPagePath?: string;
+    /**
+     * The signed-in viewer — forwarded to `OrbitalProvider`'s `UserProvider` so
+     * `@user.x` resolves in client-side guard and effect evaluation exactly as
+     * it does on the server. Omitted → anonymous.
+     */
+    user?: UserData | null;
+    /**
+     * What the host's auth provider has resolved the viewer to be. An
+     * `access: authenticated` page mounts only on `authenticated`; any other
+     * resolved value sends the viewer to the app's `signIn` route. Omitted → the
+     * host offers no sign-in (`unavailable`).
+     */
+    authority?: ViewerAuthority;
+    /**
+     * Sandbox mode, for previews embedded in a host app (e.g. the studio
+     * canvas): the event bus stays context-local, navigation stays in memory
+     * (the host URL/history are never touched), in-app links are always
+     * intercepted, and external links open a new tab. Default false
+     * (standalone previews own the global bridge and sync `?page=`).
+     */
+    isolated?: boolean;
+    /**
+     * Scale the rendered content down (never up) so it fits the container
+     * without scrollbars. For fixed-intrinsic-size content (game canvases);
+     * leave off for flow layouts, which should keep their internal scroll.
+     * `'content'`: fit the rendered component itself (not the page around it)
+     * and center it — a thumbnail of one behavior.
+     */
+    fit?: boolean | 'content';
+    /**
+     * Called with the page path on every in-preview page switch (link click,
+     * navigate effect, `UI:NAVIGATE`), for a host that tracks the page in its
+     * own router. When set, it replaces the built-in `?page=` URL sync.
+     */
+    onPageChange?: (path: string) => void;
+    /**
+     * A registry theme key (`"<base>-<light|dark>"`) that replaces every
+     * orbital's declared theme — a host's explicit theme pick (the playground
+     * picker). Omitted → each page renders in its own orbital's theme.
+     */
+    themeOverride?: string;
+    /** Hold the preview's client ticks stopped (a canvas card the person has not played); clearing it resumes them. */
+    paused?: boolean;
+    /**
+     * Loads the behavior behind a `lazyPages` entry (`uses lazy`) when its page
+     * is opened. Without it, opening a lazy page shows a load error.
+     */
+    lazyLoader?: SchemaLoader;
+    /** Where `schema` was loaded from — a lazy page's `orbRef` resolves against it. */
+    schemaPath?: string;
+    /**
+     * Called with a path that matches none of this schema's pages — a lazily
+     * loaded behavior hands links back to the schema that imported it.
+     */
+    onUnmatchedNavigate?: (path: string) => void;
+    /**
+     * The host's own sign-in (`HOST_SIGN_IN_ROUTE`, `/login`): navigating there —
+     * including an `access: authenticated` page sending its viewer to
+     * `signIn: "/login"` — calls this with the return path instead of routing to a
+     * page. Omitted → the host offers no sign-in and nothing happens.
+     */
+    onSignIn?: (returnTo?: string) => void;
+    /**
+     * The host's session sign-out, called on the system event `UI:SIGN_OUT` (a
+     * Sign out inside the circuit). Omitted → the host offers no sign-out.
+     */
+    onSignOut?: () => void;
+}
+declare function OrbPreview({ schema, mockData, autoMock, height, className, serverUrl, transport, getAccessToken, kernelLoader, languageLoader, seedProgramLoader, initialPagePath, isolated, fit, onPageChange, user, authority, localFallbackTimeoutMs, themeOverride, paused, lazyLoader, schemaPath, onUnmatchedNavigate, onSignIn, onSignOut, }: OrbPreviewProps): React__default.ReactElement;
+declare namespace OrbPreview {
+    var displayName: string;
+}
+
+/**
+ * OrbitalPluginHost — runs an ordinary behavior headless against the
+ * AMBIENT event bus + slot provider (Almadar Studio V4 §14 plan, Part F1).
+ *
+ * A "plugin" is not a new kind of artifact: it is a `.lolo` behavior a host
+ * chooses to run on a kernel of its own, wired to the SAME bus and slots every
+ * other UI component uses. `mode: 'mock'` runs each plugin as an offline
+ * `OrbPreview` circuit does: a client-role kernel (which also runs the plugin's
+ * `ticks {}` on the one browser tick driver) over a local kernel whose mock
+ * store is seeded by `seedMockStore` (persona roster, owner columns stamped for
+ * the dev viewer, the `@create` owner gate); `mode: 'server'` dispatches
+ * through the host's transport. Default policy denies nothing — a plugin has the full
+ * behavior power a preview has (in-memory persist, default services); `deny`
+ * is an opt-in host policy, never a default sandbox.
+ *
+ * OUTBOUND = the dispatch response. The kernel runs a dispatch's whole
+ * `listens {}` cascade before it answers (EXEC semantics), so
+ * `response.emittedEvents` carries every emit of the run, direct or cascaded,
+ * on both modes, and every trait's state is read back from the kernel after it.
+ *
+ * RELAY RULE: the plugin's `inbound[]` is its host→plugin vocabulary — one
+ * `UI:<busEvent>` bus event per row, dispatching `trigger` at
+ * `orbital`/`trait`. Anything a plugin emits under one of those SAME
+ * busEvent names (or under an inbound `trigger` name) is a relay for its
+ * own siblings' `listens {}` (the runtime's internal event bus already
+ * carries that fan-out), never a fresh request back to the host, and must
+ * NEVER be re-broadcast — doing so re-fires the very `UI:<busEvent>`
+ * listener that produced it, a synchronous self-feeding loop (verified
+ * 2026-09-04, see `docs/Almadar_UI_Gaps.md`).
+ *
+ * @packageDocumentation
+ */
+
+/** Verbs a host may deny. Never includes `emit` — it drives the kernel's `listens` cascade. */
+type PluginHostDenyVerb = 'persist' | 'call-service' | 'navigate';
+/** One bus-event → orbital-event wiring: `UI:<busEvent>` dispatches `trigger` at `orbital`/`trait`. */
+interface PluginHostInbound {
+    busEvent: string;
+    orbital: string;
+    trait: string;
+    trigger: string;
+}
+interface PluginHostPlugin {
+    id: string;
+    schema: OrbitalSchema;
+    inbound: PluginHostInbound[];
+    /** When set, only these events reach the host bus; every other emit stays inside the plugin. */
+    outbound?: readonly string[];
+}
+interface OrbitalPluginHostProps {
+    plugins: PluginHostPlugin[];
+    /** 'mock' (default): a local kernel over in-memory mock rows — full behavior power, as any preview.
+     *  'server': dispatch through `transport` instead of a local kernel, as `AlmadarApp`. */
+    mode?: 'mock' | 'server';
+    /** Required when `mode === 'server'`. */
+    transport?: EventTransport;
+    /** OPTIONAL policy: verbs listed here are denied with a logged warning, never a throw. Default: none denied. */
+    deny?: PluginHostDenyVerb[];
+    navigate?: (path: string) => void;
+    onTransition?: (pluginId: string, orbital: string, trait: string, state: string) => void;
+    children?: ReactNode;
+}
+/**
+ * Reads the declared `keymap` config knob off the plugin's own trait and the
+ * live `currentState`, so `useKeyboardRouter`'s capture table always follows
+ * the trait's actual mode. Re-derives whenever the host records a new
+ * transition (the context's `tick`).
+ *
+ * `target` accepts either one target string (default `'shell'`) or a list of
+ * targets — the SAME derived entry (mode + keys) is repeated under every
+ * target, for a caller keying its table by several editor ids at once (e.g.
+ * one plugin's mode capturing keys for both `'schema'` and `'file:a.md'`).
+ */
+declare function useDeclaredCaptureTable(opts: {
+    pluginId: string;
+    orbital: string;
+    trait: string;
+    keymapKnob?: string;
+    target?: string | readonly string[];
+}): KeyCaptureTable;
+declare function useOrbitalPluginHost(): {
+    getState: (pluginId: string, orbital: string, trait: string) => TraitState | undefined;
+    lastEvent: (pluginId: string) => string | undefined;
+    errors: Readonly<Record<string, string>>;
+};
+/**
+ * Mounts one headless kernel per plugin against the ambient
+ * event bus + slot provider. Renders nothing of its own besides an optional
+ * `children` passthrough — MUST be mounted inside `EventBusProvider` +
+ * `UISlotProvider`.
+ */
+declare function OrbitalPluginHost({ plugins, mode, transport, deny, navigate, onTransition, children, }: OrbitalPluginHostProps): React__default.ReactElement;
+
+/**
+ * TraitValueFrame — renders a trait VALUE (a trait of an installed behavior held
+ * as data, language trio) where a render tree embeds it, the data-bound sibling
+ * of `TraitFrame`'s `@trait.X` lens.
+ *
+ * The host turns the value into a runnable program (`TraitValueMountProvider`'s
+ * `mount`: a validated, resolved one-orbital wrapper — the binding's admission
+ * check), and the frame runs it through the plugin host's own runtime, bridged
+ * to the ambient event bus, inside a scoped slot provider so the trait's UI
+ * paints HERE rather than into the app's shared slots. `INIT` reaches the
+ * mounted trait through the plugin host's declared inbound table.
+ *
+ * @packageDocumentation
+ */
+
+/** How the host mounts trait values: the resolver plus the plugin-host execution mode. */
+interface TraitValueMountHost {
+    mount: (value: TraitValue) => Promise<TraitValueMountResult>;
+    /** 'mock' (default): in-memory, as a preview. 'server': through `transport`. */
+    mode?: 'mock' | 'server';
+    transport?: EventTransport;
+    /** Mounts a whole behavior value (`BehaviorValueFrame`); a host without it cannot run behavior values. */
+    mountBehavior?: (value: BehaviorRef) => Promise<BehaviorValueMountResult>;
+    /** Where a mounted behavior value's events run; in-memory when omitted. */
+    behaviorTransport?: ServerBridgeTransport;
+}
+declare function TraitValueMountProvider({ host, children }: {
+    host: TraitValueMountHost;
+    children: ReactNode;
+}): React__default.ReactElement;
+declare function TraitValueFrame({ value }: {
+    value: TraitValue;
+}): React__default.ReactElement;
+
+/**
+ * BehaviorValueFrame — renders a whole behavior VALUE (`.lolo` type `behavior`,
+ * `behavior/ref`) where a render tree embeds it: the host mounts the program
+ * (validated at 0/0 and resolved), and the frame runs it in place through an
+ * isolated `OrbPreview` — its own event bus, in-memory navigation starting at the
+ * program's default page, the host URL untouched. A value carrying a `bridge` runs on
+ * the host's bus instead (`OrbitalPluginHost`): the bridge's `listens` reach the traits
+ * that handle them, its `emits` come back out, nothing else crosses.
+ *
+ * @packageDocumentation
+ */
+
+declare function BehaviorValueFrame({ value }: {
+    value: BehaviorRef;
+}): React__default.ReactElement;
+
+export { BehaviorValueFrame, OrbPreview, OrbitalPluginHost, ServerBridgeTransport, TraitValueFrame, TraitValueMountProvider, clearSchemaCache, useDeclaredCaptureTable, useOrbitalPluginHost, useResolvedSchema, useTraitStateMachine };
+export type { OrbPreviewProps, OrbitalPluginHostProps, PluginHostDenyVerb, PluginHostInbound, PluginHostPlugin, ResolvedSchemaResult, SlotPatternEntry, SlotSource, TraitStateMachineResult, TraitValueMountHost, UseTraitStateMachineOptions };

package/dist/runtime/index.js

@@ -0,0 +1,31 @@
+export { BehaviorValueFrame } from '../chunk-2QOH2HWM.js';
+export { OrbitalPluginHost, TraitValueFrame, TraitValueMountProvider, useDeclaredCaptureTable, useOrbitalPluginHost } from '../chunk-FIW6WN23.js';
+export { assertUniqueSlotsPerHost } from '../chunk-5QTYQTPS.js';
+export { TraitContext, TraitProvider, useTrait, useTraitContext } from '../chunk-ZO6MXAS3.js';
+export { EntitySchemaProvider, OrbPreview, ServerBridgeProvider, clearSchemaCache, useEntitySchema, useEntitySchemaOptional, useResolvedSchema, useServerBridge, useTraitStateMachine } from '../chunk-GYTPOFVC.js';
+import '../chunk-YDNJLLG6.js';
+import '../chunk-KVQS4GXU.js';
+import '../chunk-L677XGY3.js';
+import '../chunk-FP3WIKTC.js';
+import '../chunk-42FY4RYA.js';
+import '../chunk-FAJDTHWC.js';
+import '../chunk-GAR5TQ5B.js';
+import '../chunk-SJGJJKBY.js';
+import '../chunk-DZ42OJQC.js';
+export { profilerOnRender, usePerfBuffer } from '../chunk-P4LNHAFI.js';
+import '../chunk-TZZBINQY.js';
+import '../chunk-PC7K4SK7.js';
+import '../chunk-VFF5OO47.js';
+import '../chunk-DFNZUYX4.js';
+import '../chunk-B4BU77LT.js';
+import '../chunk-6P3MWXYE.js';
+export { PERF_NAMESPACE, clearPerf, perfEnd, perfStart, perfTime, wrapCallbackForEvent } from '../chunk-DYEKAA4L.js';
+import '../chunk-R5O5AUPI.js';
+import '../chunk-L2DEKY4J.js';
+import '../chunk-AILY3XPS.js';
+import '../chunk-3BBUBJFF.js';
+import '../chunk-YHMRX6YA.js';
+import '../chunk-MBQAMMSE.js';
+import '../chunk-A2LR6VQQ.js';
+import '../chunk-P4ZFUQFF.js';
+import '../chunk-G7DCAZ22.js';

package/dist/slot-host-CPzrxLo9.d.ts

@@ -0,0 +1,48 @@
+import { UISlot } from '@almadar/core';
+
+/**
+ * Slot-host manifest types (Studio V4 §14, Part I1/I2).
+ *
+ * A "slot-host" is any shell that lays out named regions and mounts each
+ * one through `UISlotComponent` — e.g. a persona workspace declaring
+ * `sidebar`/`main`/`drawer`/... A manifest is the declarative region → slot
+ * binding for such a host: which compiler `UISlot` each region mounts, and
+ * whether the host's own stock content is replaced by slot content or the
+ * two are shown together (`UISlotComponent`'s `mode` prop). Substrate
+ * (lives in `@almadar/ui`, re-exported by `@almadar/sdk`) so any host — the
+ * studio's three persona shells or an embedding app — describes its
+ * regions the same way.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * One host region's binding to a compiler slot. Mirrors `UISlotComponent`'s
+ * `mode` prop exactly — a manifest is just that prop's value, keyed by
+ * region, declared as data instead of scattered across JSX call sites.
+ */
+interface SlotHostRegion {
+    slot: UISlot;
+    mode: "replace" | "append";
+}
+/**
+ * A host's full region map, keyed by the host's own region ids (e.g. a
+ * persona shell's `activityBar`/`sidebar`/`main`/...). `RegionId` is left
+ * generic so each host supplies its own literal union.
+ */
+interface SlotHostManifest<RegionId extends string = string> {
+    regions: Record<RegionId, SlotHostRegion>;
+}
+/**
+ * Guards the invariant a slot-host manifest depends on: each `UISlot` may
+ * be mounted by at most one region. Two regions sharing a slot would mount
+ * `UISlotComponent` twice for the same slot — the second mount clears/reads
+ * the same context entry the first one owns, so one of the two regions
+ * silently loses its content (or, for a portal slot, double-portals it).
+ * Throws naming the two offending regions so the host can find the
+ * conflict without re-deriving it from the manifest.
+ */
+declare function assertUniqueSlotsPerHost<RegionId extends string>(manifest: SlotHostManifest<RegionId>): void;
+
+export { assertUniqueSlotsPerHost as b };
+export type { SlotHostManifest as S, SlotHostRegion as a };