@almadar/shell-runtime 0.0.0-stage → 0.1.0

package/dist/kernel/program-effects.d.ts

@@ -0,0 +1,65 @@
+import { ProgramInspection, CatalogEntry, TraitDescription, BehaviorDescription, OrbitalSchema, EvaluatedProgram, ProgramValidationIssue, DependencyGraph, EventPayload, CircuitStepResult } from '@almadar/core';
+
+/** The effects the language trio routes to this host. */
+declare const PROGRAM_EFFECTS: readonly ["behavior/catalog", "behavior/describe", "behavior/source", "behavior/resolve", "behavior/dependencies", "program/read", "program/print", "program/eval", "program/validate", "program/compose", "program/step"];
+type ProgramEffectName = (typeof PROGRAM_EFFECTS)[number];
+/** Narrow an effect head to one this host runs. */
+declare function isProgramEffect(name: string): name is ProgramEffectName;
+/** What `program/validate` returns. */
+interface ProgramValidationReport {
+    readonly valid: boolean;
+    readonly errors: readonly ProgramValidationIssue[];
+    readonly warnings: readonly ProgramValidationIssue[];
+}
+/** One transition a host asks to play: the trait, the state it plays from, and the event with its payload. */
+interface StepRequest {
+    orbital: string;
+    trait: string;
+    from: string;
+    event: string;
+    payload: EventPayload;
+    /** Fields merged into the trait's entity row before the event. */
+    entity?: EventPayload;
+    /** Knob values over the trait's declared config defaults, for this request's trait only. */
+    config?: EventPayload;
+    /** The ms-epoch `@now` the step's dispatch reads, in place of the wall clock. */
+    now?: number;
+    /** A live call's cutoff: an open call still running after this many ms is cancelled. */
+    settleMs?: number;
+    /** The user the request dispatches as (`@user`); null or absent is nobody. */
+    viewer?: EventPayload | null;
+}
+/** One trait the step's dispatch cascade moved, in dispatch order. */
+interface CascadeOutcome {
+    orbital: string;
+    trait: string;
+    /** The event this trait handled (a listener's own triggered event). */
+    event: string;
+    from: string;
+    to: string;
+    /** The arm that fired; null when none did. */
+    arm: number | null;
+    fired: boolean;
+    /** The effects of the arm this trait fired, as the top-level `effects` report them. */
+    effects: CircuitStepResult['effects'];
+    emitted: CircuitStepResult['emitted'];
+}
+/** A played request: the request as asked, and the circuit it ran, with every trait its cascade moved. */
+type PlayedStep = StepRequest & {
+    result: CircuitStepResult & {
+        outcomes: CascadeOutcome[];
+        entityAfter: EventPayload | null;
+    };
+};
+/** The outcome of one program effect: the value for `{ result }`, or the failure (`errors` for eval's validator issues). */
+type ProgramEffectOutcome = {
+    readonly ok: true;
+    readonly result: ProgramInspection | CatalogEntry[] | TraitDescription | BehaviorDescription | OrbitalSchema | string | EvaluatedProgram | ProgramValidationReport | DependencyGraph | PlayedStep[];
+} | {
+    readonly ok: false;
+    readonly error: string;
+    readonly errors?: readonly ProgramValidationIssue[];
+};
+
+export { PROGRAM_EFFECTS, isProgramEffect };
+export type { CascadeOutcome, PlayedStep, ProgramEffectName, ProgramEffectOutcome, ProgramValidationReport, StepRequest };

package/dist/kernel/program-effects.js

@@ -0,0 +1,2 @@
+export { PROGRAM_EFFECTS, isProgramEffect } from '../chunk-HNOAZWFH.js';
+import '../chunk-MLKGABMK.js';

package/dist/kernel/wire.d.ts

@@ -0,0 +1,66 @@
+import { KernelEvaluatorExports } from '@almadar/core';
+export { CallRoutesWire, CallSiteWire, CallerWire, HttpBody, HttpFailureWire, HttpRequestWire, HttpResponseWire, IoAnswerWire, IoReplyWire, IoRequestWire, PendingRequestWire, ResolveProgressWire, ServerProgressWire, Settled, SubstrateFailureWire } from '@almadar/core/kernel-wire';
+
+/** The `Server` class of `@almadar/kernel` (wasm-bindgen), as the runtime uses it. */
+interface KernelServerHandle {
+    start(orbital: string, requestJson: string): string;
+    resume(flight: number, repliesJson: string): string;
+    dispatchStream(): string;
+    liveItemDelivered(itemJson: string, viewerJson: string, clientId?: string): boolean;
+    /** A row-set reference resolved for a viewer through the host-answered store; a `ResolveProgressWire` as JSON. */
+    resolveRows(refJson: string, viewerJson: string): string;
+    resumeResolve(flight: number, repliesJson: string): string;
+    abandon(flight: number): boolean;
+    /** `OsGrants::allows` over the grants the registered program declares; `requirementJson` is an `OsRequirement`. */
+    osAllows(requirementJson: string): boolean;
+    /** Place the program's anchored grants and arguments under the host's anchors; answers `[{ path, message }]` for what grants nothing. */
+    setOsAnchors(anchorsJson: string): string;
+    /** An `os/` call's arguments with its anchored parts resolved; a `Settled<args, OsError>` as JSON. */
+    osResolveArgs(op: string, argsJson: string): string;
+    inFlight(): number;
+    getState(traitName: string, entityId?: string): string;
+    setDefaultUser(userJson: string): void;
+    /** The kernel's mounts for a host start on `side` (`client|server|process|start`): `MountSeed[]` as JSON. */
+    bootMounts(side: string): string;
+    /** The kernel's mounts for a client opening `routePath`: `MountSeed[]` as JSON. */
+    routeMounts(routePath: string): string;
+    mount(traitsJson: string): void;
+    remount(traitsJson: string): void;
+    setTickMount(traitsJson: string): void;
+    /** Mock-seed the `[runtime]` entities the kernel holds itself, owner columns stamped with `viewerId` (a preview host). */
+    seedRuntimeMock(viewerId?: string): void;
+    setCapabilities(entityType: string, queryJson: string, writeJson: string): void;
+    setMessages(localesJson: string, catalogsJson: string): void;
+    /** The program (as JSON) whose declared credentials this server's credential effects manage beside its own. */
+    setManagedProgram(programJson: string): void;
+    lastError(): string;
+    /** A server holding this one's registered program and none of its session (a stateless request's kernel). */
+    fork(): KernelServerHandle;
+    forkProgram(programJson: string): KernelServerHandle;
+    free(): void;
+}
+/** The `Server` constructor of a kernel module. */
+interface KernelServerClass {
+    new (resolvedSchemaJson: string): KernelServerHandle;
+}
+/** An initialised `@almadar/kernel` module: what `OrbitalServerRuntime({ engine: 'kernel' })` is handed. */
+interface KernelModule extends KernelEvaluatorExports {
+    Server: KernelServerClass;
+    /** Whether the absolute `glob` matches `path`, as the one-grant matcher `os/glob` filters with. */
+    osGlobMatches(glob: string, path: string): boolean;
+    /** `is_public_address`: the rule an outbound host name must pass. */
+    isPublicAddress(ip: string): boolean;
+    /** The `os/` operations whose keyed call may defer its completion (`OsOp::defers_completion`), as a JSON array of names. */
+    osDeferringOps(): string;
+    /** The `os/` operations whose keyed call is a stream (`OsOp::is_stream`), as a JSON array of names. */
+    osStreamOps(): string;
+    /** The `{ event, payload }` JSON a deferred keyed `os/` call's outcome fires on its call site, or `null` when it declares no route. */
+    osCompletionEvent(siteJson: string, key: string, outcomeJson: string): string;
+    substrateCompletionEvent(siteJson: string, key: string, op: string, argsJson: string, outcomeJson: string): string;
+    /** Whether the Chrome match pattern matches the URL: the one rule a browser-tab host filters tabs with. */
+    tabUrlMatches(pattern: string, url: string): boolean;
+    /** Installs the language data (`@almadar/core/language-data` `LanguageBundle` as JSON) for a host with no `node_modules`; the first install wins. */
+    installLanguage(bundleJson: string): void;
+}
+
+export type { KernelModule, KernelServerClass, KernelServerHandle };

package/dist/kernel/wire.js

@@ -0,0 +1 @@
+import '../chunk-EZZYLTWY.js';

package/dist/loader/http-loader.d.ts

@@ -0,0 +1,111 @@
+import { ImportChainLike, SchemaLoader, HttpLoaderOptions, LoadResult, LoadedSchema, LoadedOrbital } from './schema-loader.js';
+import '@almadar/core';
+
+/**
+ * HTTP Schema Loader
+ *
+ * Loads OrbitalSchema files via HTTP/fetch for browser environments.
+ * Also works in Node.js with the fetch API.
+ *
+ * @packageDocumentation
+ */
+
+declare class HttpImportChain implements ImportChainLike {
+    private chain;
+    /**
+     * Try to add a path to the chain.
+     * @returns Error message if circular, null if OK
+     */
+    push(absolutePath: string): string | null;
+    /**
+     * Remove the last path from the chain.
+     */
+    pop(): void;
+    /**
+     * Clone the chain for nested loading.
+     */
+    clone(): HttpImportChain;
+}
+/**
+ * HttpLoader - Loads OrbitalSchema files via HTTP/fetch.
+ *
+ * Designed for browser environments where file system access is not available.
+ * Uses the fetch API for loading schemas.
+ *
+ * Path Resolution:
+ * - Relative paths: `./health.orb` -> base URL + path
+ * - Standard library: `std/behaviors/game-core` -> std lib URL + path
+ * - Scoped packages: `@scope/pkg.orb` -> scoped URL + path
+ * - Absolute URLs: `https://...` -> used directly
+ *
+ * @example
+ * ```typescript
+ * const loader = new HttpLoader({
+ *   basePath: "/api/schemas",
+ *   stdLibPath: "https://cdn.example.com/orbital-std",
+ * });
+ *
+ * // Load from relative path
+ * const result = await loader.load("./my-schema.orb");
+ *
+ * // Load from std library
+ * const stdResult = await loader.load("std/behaviors/game-core");
+ * ```
+ */
+declare class HttpLoader implements SchemaLoader {
+    private options;
+    private cache;
+    constructor(options: HttpLoaderOptions);
+    /**
+     * Load a schema from an import path.
+     */
+    load(importPath: string, fromPath?: string, chain?: ImportChainLike): Promise<LoadResult<LoadedSchema>>;
+    /**
+     * Load a specific orbital from a schema by name.
+     */
+    loadOrbital(importPath: string, orbitalName?: string, fromPath?: string, chain?: ImportChainLike): Promise<LoadResult<LoadedOrbital>>;
+    /**
+     * Resolve an import path to an absolute URL.
+     */
+    resolvePath(importPath: string, fromPath?: string): LoadResult<string>;
+    /**
+     * Resolve a standard library path.
+     */
+    private resolveStdPath;
+    /**
+     * Resolve a scoped package path.
+     */
+    private resolveScopedPath;
+    /**
+     * Resolve a relative path.
+     */
+    private resolveRelativePath;
+    /**
+     * Fetch and parse an OrbitalSchema from a URL.
+     */
+    private fetchSchema;
+    /**
+     * Join URL parts, handling relative paths and trailing slashes.
+     */
+    private joinUrl;
+    /**
+     * Get parent URL (directory) from a URL.
+     */
+    private getParentUrl;
+    /**
+     * Clear the cache.
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics.
+     */
+    getCacheStats(): {
+        size: number;
+    };
+}
+/**
+ * Create an HTTP loader with sensible defaults.
+ */
+declare function createHttpLoader(basePath: string, options?: Partial<HttpLoaderOptions>): HttpLoader;
+
+export { HttpImportChain, HttpLoader, createHttpLoader };

package/dist/loader/http-loader.js

@@ -0,0 +1,2 @@
+export { HttpImportChain, HttpLoader, createHttpLoader } from '../chunk-YL2SO5TP.js';
+import '../chunk-MLKGABMK.js';

package/dist/loader/lazy-page.d.ts

@@ -0,0 +1,12 @@
+import { LazyPage, OrbitalSchema } from '@almadar/core';
+import { SchemaLoader, LoadResult } from './schema-loader.js';
+
+/**
+ * `uses lazy`: the behavior behind a lazy page lives in its own `.orb`, at the
+ * page's `orbRef` relative to the importer's `.orb`, and is loaded when the
+ * page is opened.
+ */
+
+declare function loadLazyPage(loader: SchemaLoader, page: LazyPage, importerPath?: string): Promise<LoadResult<OrbitalSchema>>;
+
+export { loadLazyPage };

package/dist/loader/lazy-page.js

@@ -0,0 +1,2 @@
+export { loadLazyPage } from '../chunk-XXWNMJI6.js';
+import '../chunk-MLKGABMK.js';

package/dist/loader/schema-loader.d.ts

@@ -0,0 +1,160 @@
+import { OrbitalSchema, Orbital, DeclaredTraitConfig } from '@almadar/core';
+
+/**
+ * SchemaLoader Interface
+ *
+ * Abstract interface for loading OrbitalSchema files from various sources.
+ * Implementations exist for:
+ * - FileSystemLoader (Node.js) - uses fs module
+ * - HttpLoader (Browser) - uses fetch API
+ * - UnifiedLoader (Auto-detect) - routes to appropriate loader
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Result of loading a schema.
+ */
+interface LoadedSchema {
+    /** The loaded schema */
+    schema: OrbitalSchema;
+    /** Source path/URL (resolved) */
+    sourcePath: string;
+    /** Original import path */
+    importPath: string;
+}
+/**
+ * Result of loading a single orbital from a schema.
+ */
+interface LoadedOrbital {
+    /** The loaded orbital — the named one when requested, else the first. */
+    orbital: Orbital;
+    /**
+     * EVERY orbital in the loaded schema. `Alias.traits.X` carries no orbital
+     * segment, so a multi-orbital behavior's traits and pages must all stay
+     * reachable; resolving against `orbital` alone silently loses everything
+     * outside it. Mirrors the compiled path's `AliasEntry.orbitals`.
+     */
+    orbitals?: Orbital[];
+    /**
+     * The loaded schema's own app-level `config`, when it declares one.
+     * Traits from this orbital must resolve against THIS config, not the
+     * consumer's — omitted (never `undefined`) when the schema declares none.
+     */
+    schemaConfig?: DeclaredTraitConfig;
+    /** Source path/URL (resolved) */
+    sourcePath: string;
+    /** Original import path */
+    importPath: string;
+}
+/**
+ * Loader result with error handling.
+ */
+type LoadResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+};
+/**
+ * Base options for all loaders.
+ */
+interface BaseLoaderOptions {
+    /** Base path/URL for resolving relative imports */
+    basePath: string;
+    /** Standard library root path/URL */
+    stdLibPath?: string;
+    /** Scoped package roots (e.g., { "@game-lib": "/path/to/lib" }) */
+    scopedPaths?: Record<string, string>;
+}
+/**
+ * Options for HTTP loading.
+ */
+interface HttpLoaderOptions extends BaseLoaderOptions {
+    /** Default fetch options */
+    fetchOptions?: RequestInit;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Whether to use credentials (cookies, auth headers) */
+    credentials?: RequestCredentials;
+}
+/**
+ * Abstract interface for schema loaders.
+ *
+ * All loaders must implement:
+ * - load() - Load a schema from an import path
+ * - resolvePath() - Resolve an import path to absolute path/URL
+ *
+ * @example
+ * ```typescript
+ * // Using FileSystemLoader (Node.js)
+ * const loader: SchemaLoader = new FileSystemLoader({ basePath: "/schemas" });
+ * const result = await loader.load("./my-schema.orb");
+ *
+ * // Using HttpLoader (Browser)
+ * const loader: SchemaLoader = new HttpLoader({ basePath: "/api/schemas" });
+ * const result = await loader.load("./my-schema.orb");
+ *
+ * // Using UnifiedLoader (auto-detect)
+ * const loader: SchemaLoader = createUnifiedLoader({ basePath: "/schemas" });
+ * const result = await loader.load("./my-schema.orb");
+ * ```
+ */
+interface SchemaLoader {
+    /**
+     * Load a schema from an import path.
+     *
+     * @param importPath - The import path (e.g., "./health.orb", "std/behaviors/game-core")
+     * @param fromPath - The path of the file doing the import (for relative resolution)
+     * @param chain - Import chain for circular detection (optional)
+     */
+    load(importPath: string, fromPath?: string, chain?: ImportChainLike): Promise<LoadResult<LoadedSchema>>;
+    /**
+     * Load a specific orbital from a schema by name.
+     *
+     * @param importPath - The import path
+     * @param orbitalName - The orbital name (optional, defaults to first orbital)
+     * @param fromPath - The path of the file doing the import
+     * @param chain - Import chain for circular detection (optional)
+     */
+    loadOrbital(importPath: string, orbitalName?: string, fromPath?: string, chain?: ImportChainLike): Promise<LoadResult<LoadedOrbital>>;
+    /**
+     * Resolve an import path to an absolute path/URL.
+     *
+     * @param importPath - The import path
+     * @param fromPath - The path of the file doing the import (optional)
+     */
+    resolvePath(importPath: string, fromPath?: string): LoadResult<string>;
+    /**
+     * Clear the loader's cache.
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics.
+     */
+    getCacheStats(): {
+        size: number;
+    };
+}
+/**
+ * Interface for import chain (circular detection).
+ * This allows different implementations to interoperate.
+ */
+interface ImportChainLike {
+    /**
+     * Try to add a path to the chain.
+     * @returns Error message if circular, null if OK
+     */
+    push(absolutePath: string): string | null;
+    /**
+     * Remove the last path from the chain.
+     */
+    pop(): void;
+    /**
+     * Clone the chain for nested loading.
+     */
+    clone(): ImportChainLike;
+}
+
+export type { BaseLoaderOptions, HttpLoaderOptions, ImportChainLike, LoadResult, LoadedOrbital, LoadedSchema, SchemaLoader };

package/dist/loader/schema-loader.js

@@ -0,0 +1 @@
+import '../chunk-ELBLT2HZ.js';

package/dist/persistence/native-memory.d.ts

@@ -0,0 +1,28 @@
+import { PersistenceAdapter, KernelMemoryStoreWire, EntityRow, RowQuery, RowQueryPage, RowIdPage, QueryCapabilities, RowWriteOp, RowWriteOutcome, RowWriteBatch, WriteCapabilities } from '@almadar/core';
+
+declare class NativeMemoryWriteError extends Error {
+    readonly outcome: RowWriteOutcome;
+    constructor(outcome: RowWriteOutcome);
+}
+declare class NativeMemoryPersistenceAdapter implements PersistenceAdapter {
+    readonly store: KernelMemoryStoreWire;
+    constructor(store: KernelMemoryStoreWire);
+    getById(entityType: string, id: string): Promise<EntityRow | null>;
+    list(entityType: string): Promise<EntityRow[]>;
+    create(entityType: string, data: EntityRow): Promise<{
+        id: string;
+    }>;
+    update(entityType: string, id: string, data: EntityRow): Promise<void>;
+    delete(entityType: string, id: string): Promise<void>;
+    queryPage(entityType: string, query: RowQuery): Promise<RowQueryPage>;
+    queryIds(entityType: string, query: RowQuery): Promise<RowIdPage>;
+    queryCapabilities(_entityType: string): QueryCapabilities;
+    writeWhere(op: RowWriteOp): Promise<RowWriteOutcome>;
+    writeBatch(batch: RowWriteBatch): Promise<RowWriteOutcome[]>;
+    writeCapabilities(_entityType: string): WriteCapabilities;
+    bindCollection(entityType: string, collection: string): void;
+    clear(): void;
+    snapshot(): Record<string, EntityRow[]>;
+}
+
+export { NativeMemoryPersistenceAdapter, NativeMemoryWriteError };

package/dist/persistence/native-memory.js

@@ -0,0 +1,2 @@
+export { NativeMemoryPersistenceAdapter, NativeMemoryWriteError } from '../chunk-7SDV3QWR.js';
+import '../chunk-MLKGABMK.js';

package/dist/runtime/effects/composition/compose-behaviors.d.ts

@@ -0,0 +1,58 @@
+import { OrbitalDefinition, OrbitalSchema } from '@almadar/core';
+import { EventWiringEntry } from './event-wiring.js';
+import { LayoutStrategy } from './layout-strategy.js';
+
+/**
+ * Compose Behaviors
+ *
+ * Main entry point for composing multiple orbital definitions into
+ * a single OrbitalSchema application. Handles event wiring, layout
+ * strategy detection, and page generation.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Input for composing behaviors into an application.
+ */
+interface ComposeBehaviorsInput {
+    /** Application name */
+    appName: string;
+    /** Orbital definitions (or schemas) to compose */
+    orbitals: (OrbitalDefinition | OrbitalSchema)[];
+    /** Layout strategy override, or 'auto' to detect */
+    layoutStrategy?: LayoutStrategy | 'auto';
+    /** Cross-orbital event wiring */
+    eventWiring?: EventWiringEntry[];
+    /** Optional entity name mappings (original -> renamed) */
+    entityMappings?: Record<string, string>;
+}
+/**
+ * Result of composing behaviors.
+ */
+interface ComposeBehaviorsResult {
+    /** The composed OrbitalSchema */
+    schema: OrbitalSchema;
+    /** Layout metadata */
+    layout: {
+        strategy: LayoutStrategy;
+        pageCount: number;
+    };
+    /** Wiring metadata */
+    wiring: {
+        connections: number;
+    };
+}
+/**
+ * Compose multiple orbital definitions into a single application schema.
+ *
+ * Steps:
+ * 1. Apply event wiring (adds emits/listens to traits)
+ * 2. Detect or use provided layout strategy
+ * 3. Generate pages based on the strategy
+ * 4. Build the final OrbitalSchema
+ */
+declare function composeBehaviors(input: ComposeBehaviorsInput): ComposeBehaviorsResult;
+
+export { composeBehaviors };
+export type { ComposeBehaviorsInput, ComposeBehaviorsResult };

package/dist/runtime/effects/composition/compose-behaviors.js

@@ -0,0 +1,4 @@
+export { composeBehaviors } from '../../../chunk-ZCQUUJIF.js';
+import '../../../chunk-EV56K4GB.js';
+import '../../../chunk-MHYSHSRG.js';
+import '../../../chunk-MLKGABMK.js';

package/dist/runtime/effects/composition/event-wiring.d.ts

@@ -0,0 +1,38 @@
+import { OrbitalDefinition } from '@almadar/core';
+
+/**
+ * Event Wiring
+ *
+ * Applies cross-orbital event wiring to orbital definitions.
+ * Adds emits/listens declarations to traits so they can communicate
+ * across orbital boundaries.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * A single event wiring entry connecting two traits across orbitals.
+ */
+interface EventWiringEntry {
+    /** Source trait name or orbital name */
+    from: string;
+    /** Event name (UPPER_SNAKE_CASE) */
+    event: string;
+    /** Target trait name or orbital name */
+    to: string;
+    /** Event to trigger on the listener side */
+    triggers: string;
+}
+/**
+ * Apply event wiring to orbital definitions.
+ *
+ * For each wiring entry:
+ * 1. Find the source trait and add an external emit (if not already present)
+ * 2. Find the target trait and add an external listen (if not already present)
+ *
+ * Returns a new array of orbitals with wiring applied (deep-cloned).
+ */
+declare function applyEventWiring(orbitals: OrbitalDefinition[], wiring: EventWiringEntry[]): OrbitalDefinition[];
+
+export { applyEventWiring };
+export type { EventWiringEntry };

package/dist/runtime/effects/composition/event-wiring.js

@@ -0,0 +1,2 @@
+export { applyEventWiring } from '../../../chunk-MHYSHSRG.js';
+import '../../../chunk-MLKGABMK.js';

package/dist/runtime/effects/composition/index.d.ts

@@ -0,0 +1,5 @@
+export { ComposeBehaviorsInput, ComposeBehaviorsResult, composeBehaviors } from './compose-behaviors.js';
+export { EventWiringEntry, applyEventWiring } from './event-wiring.js';
+export { LayoutStrategy, detectLayoutStrategy } from './layout-strategy.js';
+export { PipeStep, pipeBehaviors } from './pipe.js';
+import '@almadar/core';

package/dist/runtime/effects/composition/index.js

@@ -0,0 +1,6 @@
+import '../../../chunk-5D63EMO5.js';
+export { pipeBehaviors } from '../../../chunk-FQ6IZMIU.js';
+export { composeBehaviors } from '../../../chunk-ZCQUUJIF.js';
+export { detectLayoutStrategy } from '../../../chunk-EV56K4GB.js';
+export { applyEventWiring } from '../../../chunk-MHYSHSRG.js';
+import '../../../chunk-MLKGABMK.js';

package/dist/runtime/effects/composition/layout-strategy.d.ts

@@ -0,0 +1,35 @@
+import { OrbitalDefinition } from '@almadar/core';
+import { EventWiringEntry } from './event-wiring.js';
+
+/**
+ * Layout Strategy Detection
+ *
+ * Auto-detects the best layout strategy for a composed application
+ * based on the number of orbitals and their event wiring topology.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Layout strategy for the composed application.
+ *
+ * - 'single': One orbital, one page
+ * - 'tabs': 2-4 orbitals with no sequential chain
+ * - 'sidebar': 5+ orbitals (navigation-heavy)
+ * - 'dashboard': Single page with all orbitals visible
+ * - 'wizard-flow': Sequential event chain detected (A -> B -> C)
+ */
+type LayoutStrategy = 'sidebar' | 'tabs' | 'dashboard' | 'wizard-flow' | 'single';
+/**
+ * Detect the best layout strategy based on orbital count and event wiring.
+ *
+ * Heuristic:
+ * 1. Sequential event chain detected -> 'wizard-flow'
+ * 2. 1 orbital -> 'single'
+ * 3. 2-4 orbitals -> 'tabs'
+ * 4. 5+ orbitals -> 'sidebar'
+ */
+declare function detectLayoutStrategy(orbitals: OrbitalDefinition[], eventWiring?: EventWiringEntry[]): LayoutStrategy;
+
+export { detectLayoutStrategy };
+export type { LayoutStrategy };

package/dist/runtime/effects/composition/layout-strategy.js

@@ -0,0 +1,2 @@
+export { detectLayoutStrategy } from '../../../chunk-EV56K4GB.js';
+import '../../../chunk-MLKGABMK.js';

package/dist/runtime/effects/composition/pipe.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Pipe Behaviors
+ *
+ * Left-to-right composition. Each step receives the previous result as its
+ * first argument and returns the value handed to the next step.
+ *
+ * @packageDocumentation
+ */
+/**
+ * A single step in a behavior pipeline.
+ */
+type PipeStep<I, O> = (input: I) => O;
+/**
+ * Apply a series of transformation steps to a seed value, left to right.
+ * Each step receives the previous step's output as its first argument.
+ *
+ * @example
+ * ```ts
+ * pipeBehaviors(1, (n) => n + 1, (n) => n * 10); // -> 20
+ * ```
+ */
+declare function pipeBehaviors<T>(seed: T, ...steps: Array<PipeStep<T, T>>): T;
+
+export { pipeBehaviors };
+export type { PipeStep };

package/dist/runtime/effects/composition/pipe.js

@@ -0,0 +1,2 @@
+export { pipeBehaviors } from '../../../chunk-FQ6IZMIU.js';
+import '../../../chunk-MLKGABMK.js';