@almadar/shell-node 0.1.0 → 1.1.0

package/dist/OrbitalServerRuntime.d.ts

@@ -1,10 +1,10 @@
-import { EventPayload, EffectHandlers, EvaluationContextExtensions, KernelModule, HttpPortsOptions, OsGrantPort, OsHostPort, EntityRow, EventBus, TransitionObserver, TraitState } from '@almadar/shell-runtime';
-import { OrbitalEventRequest, OrbitalEventResponse, BusEventSource, Entity, OrbitalDefinition, Trait, TraitConfig, PersistenceAdapter, UserContext, OrbitalSchema, MessageCatalogs, RowSetRef, RowQueryPage, ExternalInput, ServiceHostPorts, DispatchRequestOutcome, ExternalInputRequest, ClientEffectTuple, InboundDelivery, InboundAnswer, TraitTick } from '@almadar/core';
-export { ClientEffectTuple, ClientNavigateBackTuple, ClientNavigateTuple, ClientRenderUITuple, OrbitalEventRequest, OrbitalEventResponse, TransitionRejection } from '@almadar/core';
+import { EventPayload, EffectHandlers, EvaluationContextExtensions, KernelModule, SecretPortsOptions, OsGrantPort, OsHostPort, EventBus, TraitState } from '@almadar/shell-runtime';
+import { EventRequest, EventResponse, BusEventSource, OrbitalDefinition, PersistenceAdapter, OrbitalSchema, RowSetRef, RowQueryPage, ExternalInput, UserContext, ServiceHostPorts, DispatchRequestOutcome, ExternalInputRequest, ClientEffectTuple, InboundDelivery, InboundAnswer } from '@almadar/core';
+export { ClientEffectTuple, ClientNavigateBackTuple, ClientNavigateTuple, ClientRenderUITuple, EventRequest, EventResponse, TransitionRejection } from '@almadar/core';
 
 /**
  * OrbitalServerRuntime: the Node host that runs a registered program on the kernel. It answers the kernel's asks
- * (rows, services, `http`, `os` through the given os host, live streams), drives its ticks and mounts; it serves no
+ * (rows, services, secrets, `os` through the given os host, live streams), drives its ticks and mounts; it serves no
  * HTTP routes (a served program composes std-http-server for that).
  *
  * @packageDocumentation
@@ -14,10 +14,6 @@ export { ClientEffectTuple, ClientNavigateBackTuple, ClientNavigateTuple, Client
 type RuntimeOrbitalSchema = OrbitalSchema;
 /** @deprecated Use OrbitalDefinition from @almadar/core */
 type RuntimeOrbital = OrbitalDefinition;
-/** @deprecated Use Trait from @almadar/core */
-type RuntimeTrait = Trait;
-/** @deprecated Use TraitTick from @almadar/core */
-type RuntimeTraitTick = TraitTick;
 /**
  * Incremental-push item streamed to an SSE client mid-dispatch (an emitted
  * event or a client effect), before the response resolves.
@@ -38,37 +34,8 @@ type PushItem = {
 /**
  * Registered orbital with runtime state
  */
-/** One registered orbital as the API lists it. */
-interface OrbitalSummary {
-    name: string;
-    entity: string | undefined;
-    traits: string[];
-}
-/** One registered orbital as the API describes it: its entity and each trait's current state, states and events. */
-interface OrbitalInfo {
-    name: string;
-    entity: Entity;
-    traits: {
-        name: string;
-        currentState: string | undefined;
-        states: string[];
-        events: string[];
-    }[];
-}
 interface RegisteredOrbital {
     schema: OrbitalDefinition;
-    /** Resolved entity (never a string ref at runtime) */
-    entity: Entity;
-    /** Resolved inline traits (string refs filtered out) */
-    traits: Trait[];
-    /**
-     * Call-site `config: { ... }` attached to each trait ref, keyed by trait
-     * name. Used to populate the `@config.X` binding when running that trait's
-     * effects. Preserved from the preprocessed schema's trait-ref wrapper
-     * (`{ ref, config, linkedEntity, _resolved }`) before the wrapper is
-     * unwrapped to its inline form.
-     */
-    configByTrait: Map<string, TraitConfig>;
 }
 /**
  * One persist-envelope success emit, handed to the live-broadcast sink
@@ -97,8 +64,8 @@ interface LiveBroadcastItem {
  */
 interface HostDispatchItem {
     orbitalName: string;
-    request: OrbitalEventRequest;
-    response: OrbitalEventResponse;
+    request: EventRequest;
+    response: EventResponse;
     originClientId?: string;
 }
 /**
@@ -124,13 +91,6 @@ interface OrbitalServerRuntimeConfig {
     effectHandlers?: Partial<EffectHandlers>;
     /** Persistence adapter for entity data */
     persistence?: PersistenceAdapter;
-    /**
-     * Data mode:
-     * - 'mock': mock service answers and the std mock-seed dataset
-     * - 'real': the actual persistence layer and services
-     * Required: whoever starts the runtime states it; there is no default (EXEC-BOUND-2).
-     */
-    mode: 'mock' | 'real';
     /** Where a registered program with imports is resolved from (`orb resolve`). */
     loaderConfig?: LoaderConfig;
     /**
@@ -148,19 +108,6 @@ interface OrbitalServerRuntimeConfig {
         cwd: string;
         orbBin?: string;
     };
-    /**
-     * The persona a preview or verification run is looking at the app AS.
-     *
-     * `@user.id` / `@user.role` are what an app's ownership scoping and role
-     * gates resolve against, so with no user every predicate takes its negative
-     * branch and every owner filter matches nothing. A dev host (playground,
-     * runtime-verify) sets it to make both branches reachable.
-     *
-     * Never an HTTP request's identity: `router()` resolves every request from
-     * its verified token (or anonymous). It is the viewer for in-process calls,
-     * ticks and the mock seeder's owner stamps.
-     */
-    defaultUser?: UserContext;
     /**
      * The initialised `@almadar/kernel` module that decides execution and whose I/O this runtime answers with its
      * persistence, service and program-host adapters. Absent, the runtime loads the installed `@almadar/kernel` itself
@@ -168,11 +115,10 @@ interface OrbitalServerRuntimeConfig {
      */
     kernel?: KernelModule;
     /**
-     * What the `http` effect runs on: the kernel's request driver (`loadHttpKernel`), and optionally the secret store,
-     * pinned fetch and resolver. The program's `egress` is read from the registered schema. Absent, an `http` effect
-     * fails with `HTTP_KERNEL_UNAVAILABLE`.
+     * What the kernel's secret, random and credential asks run on: optionally the secret store, the CSPRNG and the
+     * credential administration port. Absent, those asks fail as unavailable.
      */
-    http?: Omit<HttpPortsOptions, 'egress'>;
+    secretPorts?: SecretPortsOptions;
     /**
      * Builds the `os` host of the kernel engine from the grant port backed by the kernel (`createNodeOsHost` from
      * `@almadar/shell-node`). Absent, every `os` ask is denied, as the native host does with none.
@@ -226,10 +172,9 @@ interface OrbitalServerRuntimeConfig {
 declare class UnresolvedProgramError extends Error {
     constructor(schemaName: string);
 }
-/** What `register` takes beside the schema: the program's catalogs and the `uses lazy` behaviors the server runs alongside it. */
+/** What `register` takes beside the schema: the folder its `uses lazy` behaviors sit beside (EXEC-LOAD-1). The program carries its own messages. */
 interface RegisterOptions {
-    messages?: MessageCatalogs;
-    lazy?: readonly OrbitalSchema[];
+    lazyDir?: string;
 }
 declare class OrbitalServerRuntime {
     protected orbitals: Map<string, RegisteredOrbital>;
@@ -237,46 +182,28 @@ declare class OrbitalServerRuntime {
     private config;
     /** The row store a host-supplied `persistence` replaces: the kernel's own `MemoryStore`, opened by the first `register()`. */
     private ownedStore;
-    /** The owner cells the mock seed stamped, kept for a persona restamp. */
-    private mockJournal;
-    /** The std seed program resolved from the installed packages, once per runtime. */
-    private seedProgram;
-    /** Store writes (seed, reseed, restamp) run one after another. */
-    private storeOps;
     /**
      * The bound persistence adapter (host-supplied, else the kernel's own memory store). Public so a test can
      * inspect committed rows honestly. A runtime that owns its store has one from the first `register()`.
      */
     get persistence(): PersistenceAdapter;
-    /** Whether this runtime seeds generated mock rows: mock mode over the store it owns. */
-    private seedsMock;
-    private tickBindings;
     /** The kernel running the registered program; null before a program is registered. */
     private kernelEngine;
+    /** What the kernel holds of every trait of the registered program, read once when the kernel opens. */
+    private programSurface;
     /** The `os` handles of the program the kernel runs; closed when that program is replaced, reset or dropped. */
     private kernelOs;
-    /** `orbital::trait` → the clients that have it mounted (Runtime Spec Clause 8.3). */
-    private readonly mountedBy;
-    private readonly tickScheduler;
-    private readonly transitionObservers;
-    private readonly transitionFanout;
+    /** Drives the kernel's one tick clock: every pass asks `KernelEngine.tickPass` which ticks are due. */
+    private tickTimer;
     private programHandlersPromise;
     private resolvedSchema;
-    /** The program's declared `locales`, in declared order; the first is the default. */
-    private appLocales;
-    /** Merged message catalogs of every registered program (keys are behavior-qualified). */
-    private messages;
+    /** The folder the program's lazy files sit beside; the pages that name them are on `resolvedSchema.lazyPages`. */
+    private lazyDir;
     /** Wired by the hosting server (e.g. the playground SSE endpoint) via `setLiveBroadcastSink`. */
     private readonly liveSubscribers;
     private liveBroadcastSink;
     private hostDispatchSink;
-    /**
-     * Tick-broadcast relay (T6): newest pending item per
-     * (originClientId, orbital, event), flushed to the live-broadcast sink on
-     * the `tickRelayIntervalMs` cadence — other tabs get the latest position
-     * at snapshot rate, never 1:1 with emissions.
-     */
-    private readonly tickRelayPending;
+    /** The one-shot timer that flushes the kernel's coalesced tick relay window. */
     private tickRelayTimer;
     constructor(config: OrbitalServerRuntimeConfig);
     /**
@@ -326,20 +253,6 @@ declare class OrbitalServerRuntime {
     private doRegister;
     /** The kernel's own row store, opened once in the register phase when the host supplied none. */
     private openOwnedStore;
-    /**
-     * Returns the schema that this runtime is currently executing, post-
-     * preprocessing. Safe to expose from an HTTP `/api/schema` endpoint — every
-     * cross-orbital trait ref will have an inline `stateMachine` already, which
-     * is what the browser's `schema-to-ir` resolver needs to wire button clicks
-     * back to state transitions.
-     *
-     * Returns `null` if `register()` hasn't run yet.
-     */
-    /** The registered program's name, or null when nothing is registered (none yet, or after `unregisterAll`). */
-    registeredSchemaName(): string | null;
-    getResolvedSchema(): OrbitalSchema | null;
-    /** The registered program's message catalogs (locale → qualified key → message), for a host's client. */
-    getMessages(): MessageCatalogs;
     /**
      * One-call entry point: read an `.orb` file from disk, parse it, preprocess
      * cross-orbital imports, and register the result. Callers never touch raw
@@ -356,10 +269,12 @@ declare class OrbitalServerRuntime {
      */
     private registerOrbitalAsync;
     /** The adapters the kernel's I/O is answered with: this runtime's persistence, services and program host. */
-    private httpPorts;
+    private secretPorts;
     private kernelPorts;
     /** One live message of a running `call-service`, stamped as its calling trait, to the requesting tab only. */
     private deliverLiveMessage;
+    /** The traits of one orbital as the kernel holds them. */
+    private traitsOf;
     /** The project root this runtime hands `orb` and the kernel's language data: the program host's cwd, else the loader base path. */
     private programRoot;
     /** The kernel module this runtime runs on: the one the host handed in, else the installed `@almadar/kernel`. */
@@ -368,53 +283,22 @@ declare class OrbitalServerRuntime {
     private openKernel;
     /** Run the kernel's boot mounts for the server side (EXEC-ENDPOINT-3): the host sends what the kernel lists and chooses nothing. */
     private mountBootEndpoints;
-    /** The program whose rows the store holds, once seeded; absent before the first seed and after `unregisterAll`. */
-    private seededProgram;
-    /** The std mock-seed program, resolved by `orb` from the installed packages. */
-    private resolveSeedProgram;
-    /** Run `use` with the seed program forked off the kernel just opened; the fork is released after. */
-    private withSeeder;
-    /** Store writes (seed, reseed, restamp) run one after another, so a persona switch never interleaves a reseed. */
-    private enqueueStoreOp;
-    /**
-     * Fill the store from the program, in the register phase: a mock runtime seeds every entity for the viewer, any
-     * other runtime seeds the rows the program writes out and its browser-stored entities.
-     */
-    private seedStores;
-    private managedProgram;
-    /**
-     * Name the program whose declared credentials this runtime's credential effects manage beside its own: an
-     * integrations console serving the app a host shows saves and tests that app's keys. Naming another replaces it.
-     */
-    manageCredentialsOf(program: OrbitalSchema): void;
-    /** A mock store seeds every entity; the `[runtime]` rows the kernel holds itself are seeded in the kernel. */
-    private seedKernelRuntimeMock;
+    /** What answers the declared contract: the registered program's kernel, else the kernel's own program-less answers, which refuse every input and hook. */
+    private contractEngine;
     private requireKernelEngine;
-    /**
-     * Set up scheduled ticks for all traits
-     */
-    private setupTicks;
-    /**
-     * Register a single tick
-     */
-    private registerTick;
+    /** Ask the kernel's clock which ticks are due and start each as a `runTick` request to the orbital it names. */
+    private tickPass;
+    /** Run the kernel's clock on this host's timer when the program declares a tick. */
+    private restartTickClock;
     /** A tick: the host owns the timer, the kernel decides whether and over which rows it fires. */
     private executeTick;
-    /** Tell the kernel which traits some client has mounted, so it can pause the other traits' ticks. */
-    private syncTickMount;
     /**
-     * Clean up all active ticks
+     * Stop the host's timers
      */
     private cleanupTicks;
     /**
      * Unregister all orbitals and clean up
      */
-    /** A client mounts a trait by dispatching its lifecycle event and releases it with `$UNMOUNT`. */
-    private recordMount;
-    /** Drop every mount a disconnected client held, so its traits' mount-scoped ticks pause. */
-    releaseClient(clientId: string): void;
-    /** True while at least one client has `traitName` mounted. */
-    isTraitMounted(orbitalName: string, traitName: string): boolean;
     unregisterAll(): void;
     /**
      * Bracket a multi-step app mutation (the classic swap is
@@ -451,20 +335,10 @@ declare class OrbitalServerRuntime {
     private bracketAls;
     private ensureBracketAls;
     withRegistrationMutation<T>(fn: () => Promise<T>): Promise<T>;
-    /**
-     * Reset the mock persistence store to a clean-slate re-seed without
-     * unregistering orbitals. Exposed for verifier tools that want to
-     * start each test with deterministic seeded rows, not the residue of
-     * the previous walk's persist-creates. No-op when the runtime does not
-     * seed a mock store of its own.
-     */
-    resetMockPersistence(): Promise<void>;
     /**
      * Return every registered orbital's circuit to boot: trait states to their
      * initial states, frames and row cache emptied, and a fresh mount (no trait
-     * awaiting INIT, nothing held). The hermetic-reset twin of
-     * `resetMockPersistence`: a reset walk must not inherit the previous walk's
-     * circuit any more than its rows.
+     * awaiting INIT, nothing held).
      */
     resetCircuitState(): void;
     /**
@@ -481,58 +355,18 @@ declare class OrbitalServerRuntime {
     /** Run a follow-on step's call outcome as its own dispatch, and hand its result to the host-dispatch sink. */
     private runDeferredOutcome;
     /**
-     * Switch the viewer a dev host presents the app as — see
-     * `OrbitalServerRuntimeConfig.defaultUser`. Pass `undefined` for an
-     * unauthenticated viewer. Takes effect on the next event; an authenticated
-     * request still overrides it.
-     *
-     * Mock mode stamps the seeded owner columns for whichever id was `defaultUser`
-     * at register time. Switching to a different id re-points those cells with
-     * `restampMockOwner` instead of re-seeding, so an ownership-scoped view for
-     * the new viewer has rows. The returned promise settles when the restamp has
-     * landed (immediately when there is nothing seeded yet; register flushes it).
-     */
-    setDefaultUser(user: UserContext | undefined): Promise<void>;
-    /** Whether the host named the viewer (constructor or `setDefaultUser`). If not, the viewer is
-     *  the app's first declared persona, resolved as soon as its roster is seeded. */
-    private viewerNamedByHost;
-    /** setDefaultUser can land before register() finishes resolving the schema
-     *  (a dev host pins a persona right after boot). An ungated restamp there
-     *  would hand a read-only persona authorship of drafts, so the restamp is
-     *  DEFERRED until the schema exists — register()/registerSync() flush it. */
-    private pendingOwnerRestamp;
-    /**
-     * Re-point the seeded owner cells at `user` (a persona switch never reseeds). The seed program's policy gates decide
-     * per row whether the persona could have created it. Deferred when the program is not seeded yet.
-     */
-    private restampOwnerGated;
-    /** Flush a persona switch that arrived before the schema was resolved. */
-    private flushPendingOwnerRestamp;
-    /** The viewer a dev host is currently presenting the app as. */
-    getDefaultUser(): UserContext | undefined;
-    /**
-     * Queue a tick-stamped dispatch for coalesced snapshot relay (T6). Newest
-     * per (originClientId, orbital, event) wins between flushes — the standard
-     * netcode position-broadcast discipline.
+     * A tick-stamped dispatch is a latest-state broadcast (T6): the kernel coalesces it with the others of the window
+     * (newest per origin client, orbital and event) and says how long the window stays open; this host only runs
+     * the timer.
      */
     private queueTickRelay;
     private flushTickRelay;
     /**
-     * The registered app's declared persona roster: the live rows of its
-     * `[identity]` entity, mapped onto viewers (`Almadar_LOLO_Identity.md` §4.3).
-     * Live-store rows rather than a re-derivation, so the roster carries the ids
-     * ownership scoping actually compares `@user.id` against. Empty when no
-     * schema is registered or the app declares no `[identity]` entity — there is
-     * no global fallback roster by design.
-     */
-    /**
-     * `reference` resolved for `user` against the store as it is now: the rows that still match its query and the
-     * viewer's `@read`, in the reference's order, `total` re-counted. The kernel resolves through its server
+     * `reference` resolved for the identity bound to `clientId`'s session (none: the anonymous viewer) against the store as it is now: the rows that still match its query and that identity's `@read`, in the reference's order, `total` re-counted. The kernel resolves through its server
      * resolve flight. A client reaches it with
-     * `POST /:orbital/../resolve-rows` as the signed-in viewer.
+     * `POST /:orbital/../resolve-rows`.
      */
-    resolveRows(reference: RowSetRef, user: UserContext): Promise<RowQueryPage>;
-    getIdentityRoster(): Promise<UserContext[]>;
+    resolveRows(reference: RowSetRef, clientId: string | undefined): Promise<RowQueryPage>;
     /**
      * Process an event for an orbital — the stateful host's thin shell over
      * the unified `evaluateOrbitalEvent` composition (design:
@@ -567,12 +401,8 @@ declare class OrbitalServerRuntime {
      * milliseconds from landing. A failed mutation falls through to the miss.
      */
     private resolveRegisteredOrbital;
-    /** The registered orbitals as `GET /` lists them. */
-    listOrbitalSummaries(): OrbitalSummary[];
-    /** One orbital as `GET /:orbital` describes it, awaiting an in-flight swap first (G-RUNTIME-038); `undefined` when it is not registered. */
-    describeOrbital(orbitalName: string): Promise<OrbitalInfo | undefined>;
-    /** An entity's full row set as `GET /:orbital/entities/:entityType` answers it (verification and tooling only); `undefined` when the orbital is not registered. */
-    entityRows(orbitalName: string, entityType: string): Promise<EntityRow[] | undefined>;
+    /** The first request that names a `uses lazy` orbital registers it here; the kernel loads the same file on that request's dispatch (EXEC-LOAD-2). */
+    private loadLazyOrbital;
     /** The program's declared external inputs: what an outside client may send which trait. */
     listExternalInputs(): ExternalInput[];
     /**
@@ -593,11 +423,11 @@ declare class OrbitalServerRuntime {
     }, user: UserContext | undefined, message?: (payload: EventPayload) => void, assertReentry?: () => void): ServiceHostPorts;
     /**
      * A `program/dispatch` event request, as the events route (or with `input`, the inputs route) runs it: the
-     * request's own `user` is its viewer, else the caller's. An unknown orbital is `ORBITAL_NOT_FOUND`, an undeclared
+     * runs as the session's identity, never a viewer the request names. An unknown orbital is `ORBITAL_NOT_FOUND`, an undeclared
      * locale `LOCALE_NOT_DECLARED`; an inbound-only event and an undeclared input are the routes' refusals.
      */
-    dispatchEventRequest(orbital: string, request: OrbitalEventRequest, input: boolean, caller: UserContext | undefined, stream?: boolean): Promise<DispatchRequestOutcome>;
-    dispatchExternalInput(orbitalName: string, request: ExternalInputRequest, onPush?: (item: PushItem) => void): Promise<OrbitalEventResponse>;
+    dispatchEventRequest(orbital: string, parsed: EventRequest, input: boolean, stream?: boolean): Promise<DispatchRequestOutcome>;
+    dispatchExternalInput(orbitalName: string, request: ExternalInputRequest, onPush?: (item: PushItem) => void): Promise<EventResponse>;
     /**
      * An inbound delivery (`/api/hooks/<name>`): the runtime decides whether the name is served, runs
      * the handler through `processOrbitalEvent` and answers; the host only carries the bytes.
@@ -606,13 +436,12 @@ declare class OrbitalServerRuntime {
      * An event that is an inbound hook's is delivered only by `deliverInbound`: the app's own event
      * route refuses it, as the input channel refuses an event that is no declared input.
      */
-    refuseInboundOnly(orbitalName: string, request: Pick<OrbitalEventRequest, 'event' | 'targetTrait'>): OrbitalEventResponse | undefined;
+    refuseInboundOnly(orbitalName: string, request: Pick<EventRequest, 'event' | 'targetTrait'>): EventResponse | undefined;
     deliverInbound(name: string, delivery: InboundDelivery, onPush?: (item: PushItem) => void): Promise<InboundAnswer>;
-    processOrbitalEvent(orbitalName: string, request: OrbitalEventRequest, onPush?: (item: PushItem) => void): Promise<OrbitalEventResponse>;
+    processOrbitalEvent(orbitalName: string, request: EventRequest, onPush?: (item: PushItem) => void): Promise<EventResponse>;
     /**
-     * The enqueued critical section behind `processOrbitalEvent`: evaluate
-     * one request through the composition, then relay its emits to
-     * cross-orbital listeners. MUST only run holding the event queue.
+     * One request evaluated on the kernel, which orders it among every other (EXEC-CONC-2), then its emits relayed
+     * to the host sinks.
      */
     private evaluateForOrbital;
     /**
@@ -620,42 +449,12 @@ declare class OrbitalServerRuntime {
      * event bus (the public firehose) and `onPush` once the dispatch is done, in the order the response carries them.
      */
     private publishKernelResponse;
-    /**
-     * The runtime-wide event queue — ONE async serialization point for every
-     * composition run (requests, cross-orbital relays, external emits, tick
-     * relays). The composition commits manager state directly rather than
-     * through the manager's per-(trait, entityId) actor queues, so without
-     * this, two concurrent requests against the session manager could both
-     * evaluate from the same held state and lose a transition. `run` sees
-     * the caller's result (or throw); the queue itself never wedges on a
-     * failure.
-     */
-    private eventQueue;
     /** This app's in-flight keyed `call-service`s, shared by every transition it runs (`cancel-call`). */
     private readonly inFlightCalls;
-    /** Wait for the queue, then hold it until the returned release is called. FIFO. */
-    private acquireEventQueue;
-    /**
-     * Hold the queue for `run`, handing it the hold so the work it reaches can
-     * release it (`outsideEventQueue`). The hold is passed explicitly rather than
-     * carried in async context: this runtime also runs in the browser (the orb
-     * website), which has no AsyncLocalStorage.
-     */
-    private enqueueEvent;
-    /**
-     * Run `work` with this context's queue hold released, then re-acquire it (in
-     * FIFO order behind whatever queued meanwhile). Dispatches that land while
-     * released run as their own dispatches; their commits and the held run's
-     * later commit follow server-arrival last-write-wins. Outside a hold, `work`
-     * just runs.
-     */
-    private outsideEventQueue;
     /**
      * Get the event bus for manual event emission
      */
     getEventBus(): EventBus;
-    /** Observe every executed hop (listener deliveries included) on every orbital; returns the unsubscribe. */
-    observeTransitions(observer: TransitionObserver): () => void;
     /**
      * Get state for a specific orbital/trait
      */
@@ -668,27 +467,7 @@ declare class OrbitalServerRuntime {
      * Check if an orbital is registered
      */
     hasOrbital(name: string): boolean;
-    /**
-     * Get information about active ticks
-     */
-    getActiveTicks(): Array<{
-        orbital: string;
-        trait: string;
-        tick: string;
-        interval: number | string;
-        hasGuard: boolean;
-    }>;
-    /** Halt every registered tick's shared clock. Delegates to `TickScheduler.pause`. */
-    pauseTicks(): void;
-    /** Resume ticks halted by `pauseTicks()`. Delegates to `TickScheduler.resume`. */
-    resumeTicks(): void;
-    /** True while ticks are paused. Delegates to `TickScheduler.isPaused`. */
-    areTicksPaused(): boolean;
 }
-/**
- * Factory function to create a runtime instance
- */
-declare function createOrbitalServerRuntime(config: OrbitalServerRuntimeConfig): OrbitalServerRuntime;
 
-export { OrbitalServerRuntime, UnresolvedProgramError, createOrbitalServerRuntime };
-export type { HostDispatchItem, LiveBroadcastItem, LoaderConfig, OrbitalInfo, OrbitalServerRuntimeConfig, OrbitalSummary, PushItem, RegisterOptions, RegisteredOrbital, RuntimeOrbital, RuntimeOrbitalSchema, RuntimeTrait, RuntimeTraitTick };
+export { OrbitalServerRuntime, UnresolvedProgramError };
+export type { HostDispatchItem, LiveBroadcastItem, LoaderConfig, OrbitalServerRuntimeConfig, PushItem, RegisterOptions, RegisteredOrbital, RuntimeOrbital, RuntimeOrbitalSchema };

package/dist/OrbitalServerRuntime.js

@@ -1,3 +1,3 @@
-export { OrbitalServerRuntime, UnresolvedProgramError, createOrbitalServerRuntime } from './chunk-A2TIXOLJ.js';
-import './chunk-23YAOI6P.js';
-import './chunk-UBZT5LDW.js';
+export { OrbitalServerRuntime, UnresolvedProgramError } from './chunk-34JOE763.js';
+import './chunk-VQVAHUAX.js';
+import './chunk-EEYGL7AB.js';