@almadar/shell-runtime 0.0.0-stage → 1.0.0

package/dist/runtime/evaluation/routed-persistence.js

@@ -0,0 +1 @@
+export { routeByEntity } from '../../chunk-O57GKTYU.js';

package/dist/runtime/events/identity/routing.d.ts

@@ -0,0 +1,33 @@
+import { EventId } from '@almadar/core';
+
+/**
+ * Identity-keyed routing (Almadar Rabit V4, Phase 4 — interpreter path).
+ *
+ * The runtime routes cross-trait events by NAME today: the bus key is the
+ * event name and source filtering compares orbital/trait name strings. A
+ * mid-session rename (a ledger `curName` edit that updates a node's own
+ * display name but deliberately does NOT rewrite the name strings held by
+ * every reference) therefore breaks name routing — the emitter now stamps
+ * the new name while the listener still holds the old one.
+ *
+ * These helpers make routing resolve by ID when the schema carries ids
+ * (ledger-backed, V4), and fall back to name while dual-carry. Ids are the
+ * stable edge keys: a rename never touches a node's id or any `*Id`
+ * reference, so id-routed bindings survive it. Legacy id-free schemas take
+ * the name path unchanged — byte-for-byte the previous behavior.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * The bus subscription/delivery key for an event. When an `eventId` is
+ * present the key is the id (namespaced so it can never collide with a
+ * bare event name); otherwise it is the event name (legacy path).
+ *
+ * The event ENVELOPE keeps the human name as its `type` — only the routing
+ * key changes — so observability, the client re-broadcast wire shape, and
+ * wildcard listeners are untouched.
+ */
+declare function eventRouteKey(eventName: string, eventId?: EventId | string): string;
+
+export { eventRouteKey };

package/dist/runtime/events/identity/routing.js

@@ -0,0 +1 @@
+export { eventRouteKey } from '../../../chunk-BY5G4225.js';

package/dist/runtime/types.d.ts

@@ -0,0 +1,374 @@
+import { CallServiceHandler } from '../service/default-call-service.js';
+import { ServiceCallContext } from '../service/service-provider.js';
+import { EventPayload, BusEventSource, BusEventListener, Unsubscribe as Unsubscribe$1, BusEvent, EntityRow, TraitConfig, UserContext, NavItem, RuntimeValue, FieldValue, SExpr, FetchResult, RowSetRef, PatternConfig, PageFactField, BrowserPageFacts, JsonValue, ServiceHostPorts, AgentContext, LlmContext, WorkspaceContext, SessionContext, MemoryContext, TraceContext, ResolvedPatternProps } from '@almadar/core';
+export { EntityRow, EventPayload, FetchResult, ServiceParams } from '@almadar/core';
+import { ProgramEffectName, ProgramEffectOutcome } from '../kernel/program-effects.js';
+import '@almadar/core/kernel-wire';
+
+/**
+ * Unified Runtime Types
+ *
+ * Platform-agnostic interfaces for trait execution on client or server.
+ *
+ * @packageDocumentation
+ */
+
+/** Alias for ResolvedPatternProps to avoid breaking internal consumers */
+type PatternProps = ResolvedPatternProps;
+
+type ConfigContext = TraitConfig;
+/**
+ * Event structure for cross-trait communication.
+ * Re-export of `BusEvent` from `@almadar/core` so runtime + ui + codegen
+ * all agree on the bus envelope shape. `RuntimeEvent` is kept as a type
+ * alias for anyone importing by the old name.
+ */
+type RuntimeEvent = BusEvent;
+type EventListener = BusEventListener;
+type Unsubscribe = Unsubscribe$1;
+/**
+ * Event bus interface for pub/sub communication
+ */
+interface IEventBus {
+    /** Emit an event. `routingKey` (V4) keys delivery by event-id when the
+     *  schema carries ids; absent → keyed by `type` (name, legacy). */
+    emit(type: string, payload?: EventPayload, source?: BusEventSource, routingKey?: string): void;
+    /** Subscribe to an event */
+    on(type: string, listener: EventListener): Unsubscribe;
+    /** Subscribe to ALL events (wildcard listener) */
+    onAny(listener: EventListener): Unsubscribe;
+    /** Check if there are listeners for an event */
+    hasListeners(type: string): boolean;
+    /** Get all registered event types */
+    getRegisteredEvents(): string[];
+    /** Clear all listeners */
+    clear(): void;
+}
+/**
+ * Effect handlers interface - platform-specific implementations
+ *
+ * Client: React hooks, DOM, router
+ * Server: Express, database, integrators
+ */
+interface EffectHandlers {
+    /**
+     * Emit an event to the event bus.
+     *
+     * `source` carries the emitter's identity (orbital + trait) so that
+     * source-scoped listeners (`TraitName EVENT -> TRIGGER` and
+     * `Orbital.TraitName EVENT -> TRIGGER` in .lolo) can filter incoming
+     * events by their originating trait. Omitted when the emit is
+     * synthesized by a non-trait context (e.g. test harness).
+     *
+     * `fromPersistSuccess` is set only by `EffectExecutor`'s `persist` case
+     * (batch and single-op), never inferred from the event name — the
+     * positional signal a server-side implementation uses to also fan this
+     * emit out to other connected clients (live-broadcast). Absent/false
+     * for every other emit source (plain `emit` effect, `set`/`call-service`/
+     * `fetch` success envelopes, cascade re-emits).
+     */
+    emit: (event: string, payload?: EventPayload, source?: RuntimeEvent['source'], fromPersistSuccess?: boolean) => void;
+    /**
+     * Persist data (create/update/delete/batch).
+     *
+     * Returns the persisted ROW — for a create that is the submitted data
+     * plus the store-minted `id`, which the caller's `emit:{success}`
+     * envelope carries. Without it a `*_CREATED` listener sees no id (the
+     * compiled path emits the created row), so anything routing on the new
+     * row's identity — navigating to the page just created — worked in one
+     * execution path only.
+     *
+     * `create`/`update`/`delete` (batch is separate — see `PersistBatchSummary`)
+     * return `undefined` ONLY to signal the write was DENIED or otherwise
+     * failed (a policy rejection, a missing row key, a no-op stub) — never
+     * a genuine success with nothing to report, since every real success
+     * branch sets a row. The caller (`EffectExecutor`'s `persist` case)
+     * treats `undefined` as a failure: it skips the declared `success`
+     * emit entirely rather than falling back to the submitted data, which
+     * previously made a denied delete indistinguishable from a completed
+     * one.
+     */
+    persist: (action: 'create' | 'upsert' | 'update' | 'delete' | 'batch', entityType: string, data?: EntityRow) => Promise<EntityRow | undefined>;
+    /**
+     * Runs a run of consecutive plain persists as stop-mode requests (one when nothing is refused) when the store declares it. Answers the
+     * per-op results in order (`undefined` = that persist failed, a handled outcome, and the ones after it still run).
+     * Answers `null` when the run cannot be pushed, and the executor then runs the effects one by one.
+     */
+    persistRun?: (ops: Array<{
+        action: 'create' | 'upsert' | 'update' | 'delete';
+        entityType: string;
+        data: EntityRow | string | undefined;
+    }>) => Promise<Array<EntityRow | undefined> | null>;
+    /**
+     * Bridge mode: the SERVER executes every persist of this dispatch and
+     * returns the real outcome in its response (`effectResults`), so the
+     * client's `persist` member is a placeholder that must never be read as
+     * a denial. When `true`, `EffectExecutor` skips the persist locally —
+     * no `persist:denied` error, no client-side `failure` emit (which fired
+     * the declared failure event in the browser while the server had
+     * succeeded), no `success` emit either (the server's cascade carries it).
+     * Set by `@almadar/ui`'s `createClientEffectHandlers` when no live
+     * client entity is supplied; absent everywhere a handler really writes.
+     */
+    persistDelegated?: true;
+    /**
+     * Bridge mode: the SERVER runs every `call-service` of this dispatch and
+     * its cascade carries the success/failure emits, so the client's mock
+     * `callService` must not also run one. Set by `@almadar/ui`'s
+     * `createClientEffectHandlers` when no consumer `callService` is wired.
+     */
+    callServiceDelegated?: true;
+    /**
+     * Set a field value on an entity. `void` for a client-side/in-memory
+     * handler (synchronous mutation); `Promise<void>` for a server-side
+     * handler backed by real persistence (e.g. `createServerEffectHandlers`,
+     * Firestore) — callers MUST `await` this, not just call it, or the
+     * write (and any telemetry it records) can still be in flight when the
+     * caller moves on. Verified 2026-09-15: `EffectExecutor.dispatch`'s
+     * 'set' case called this without `await`, invisible against every
+     * existing (synchronous, in-memory) test but a real dropped-write race
+     * the instant a real async persistence backend (Firestore) was wired in.
+     */
+    set: (entityId: string, field: string, value: FieldValue) => void | Promise<void>;
+    /** Call an external service. `context` carries the caller's identity
+     * (the same viewer entity ACL enforces against) so role-gated services
+     * can enforce server-side; hosts forward it to the integration factory. */
+    callService: CallServiceHandler;
+    /** Fetch entity data (server only) - returns data for client-side rendering.
+     *
+     * Always returns a `FetchResult` (`{rows, total}`) on success. `total`
+     * is the count of rows matching the `filter` BEFORE `offset`/`limit`
+     * are applied so a paginating caller can compute totalPages without
+     * a second round-trip. Single-id fetches return `total: 1`. `null`
+     * means "not found / failed".
+     */
+    fetch?: (entityType: string, options?: {
+        id?: string;
+        filter?: SExpr | Record<string, RuntimeValue>;
+        limit?: number;
+        offset?: number;
+        /** `"field"` or `"field:asc|desc"` — ordered before offset/limit */
+        orderBy?: string;
+        /** `none`: the store need not count every match; the success payload carries no `totalCount`. */
+        total?: 'exact' | 'none';
+        /** Relation fields to include (populate) in the response */
+        include?: string[];
+    }) => Promise<FetchResult | null>;
+    /** A collection fetch delivered by reference (`fetch … { deliver: ids }`, server only): the window's ids, the
+     * count of every match and the query that re-counts it at resolve time. Rejects when the fetch cannot be
+     * expressed as a row query, which the executor routes to `emit.failure`. */
+    fetchRowSet?: (entityType: string, options?: {
+        filter?: SExpr | Record<string, RuntimeValue>;
+        limit?: number;
+        offset?: number;
+        /** `"field"` or `"field:asc|desc"` — ordered before offset/limit */
+        orderBy?: string;
+        /** `none`: the store need not count every match; the success payload carries no `totalCount`. */
+        total?: 'exact' | 'none';
+    }) => Promise<RowSetRef>;
+    /** Stream an LLM or HTTP response (server only).
+     *
+     * Calls `onChunk` per incoming chunk; resolves with the final aggregated
+     * result on completion. The executor fires `emit.on_message` per chunk and
+     * `emit.success` on resolution. `null` means stream failed before any chunk.
+     */
+    fetchStream?: (entityType: string, options: {
+        id?: string;
+        filter?: SExpr | Record<string, RuntimeValue>;
+    } | undefined, onChunk: (chunk: RuntimeValue) => void) => Promise<RuntimeValue>;
+    /** Spawn a new entity instance */
+    spawn?: (entityType: string, props?: EntityRow) => void;
+    /** Despawn (delete) an entity instance */
+    despawn?: (entityId: string) => void;
+    /** Send an orbital event to the server over WebSocket (client-only).
+     *
+     * Produces the wire message `{ type: 'ORBITAL_EVENT', payload: { orbital, event, payload, entityId? } }`
+     * which `setupEventBroadcast` decodes → server bus → `processOrbitalEvent`.
+     */
+    sendServer?: (event: string, payload?: EventPayload) => void;
+    /** Render UI to a slot (client only). `pattern` is the post-interpolation
+     * `PatternConfig` from the trait's `(render-ui slot pattern)` SExpr, or
+     * `null` when the trait clears the slot (`render-ui slot null`).
+     * May be async: the server runtime injects relation option data
+     * (relationsData) read from the persistence adapter before pushing —
+     * the interpreter's mirror of codegen's build-time relationsData. */
+    renderUI?: (slot: string, pattern: PatternConfig | null) => void | Promise<void>;
+    /** Navigate to a route (client only). `crumb` labels the navigation-stack
+     * entry the client pushes for the target page (from the effect's
+     * `{ crumb: … }` options). */
+    navigate?: (path: string, params?: {
+        [key: string]: string;
+    }, crumb?: string) => void;
+    /** Pop the orbital-scoped navigation stack and return to the previous
+     * entry (client only). */
+    navigateBack?: () => void;
+    /** Log a message */
+    log?: (message: string, level?: 'log' | 'warn' | 'error', data?: RuntimeValue) => void;
+    /** browser/open-file-picker — resolves with `{ files }` inside `result` */
+    browserOpenFilePicker?: (options?: BrowserFilePickerOptions) => Promise<{
+        files: BrowserFileMeta[];
+    }>;
+    /** browser/clipboard-read — resolves with `{ text }` inside `result` */
+    browserClipboardRead?: () => Promise<{
+        text: string;
+    }>;
+    /** browser/clipboard-write — resolves with `{ text }` (echo) inside `result` */
+    browserClipboardWrite?: (text: string) => Promise<{
+        text: string;
+    }>;
+    /** browser/geolocation-current — resolves with the position inside `result` */
+    browserGeolocationCurrent?: (options?: BrowserGeolocationOptions) => Promise<BrowserGeolocationPosition>;
+    /**
+     * browser/page-facts — reads the requested facts in the order given and resolves with the flat facts
+     * (`PAGE_FACTS_SHAPE`). No page resolves `available: false`; a getter that throws rejects, which is not no-page.
+     */
+    browserPageFacts?: (fields: readonly PageFactField[]) => Promise<BrowserPageFacts>;
+    /**
+     * browser/prompt — the on-device model's raw reply text for `text` under the JSON Schema text; rejects with an
+     * `OnDeviceModelFailure` (`unconfigured`, `unavailable` or `failed`), and stops on an aborted `signal`.
+     */
+    browserPrompt?: (text: string, schemaText: string, key: string | null, signal?: AbortSignal) => Promise<string>;
+    /** browser/embed — one vector per text, in input order; rejects as `browserPrompt` does. */
+    browserEmbed?: (texts: readonly string[], key: string | null, signal?: AbortSignal) => Promise<number[][]>;
+    /** browser/push-subscribe — resolves with the flat Web Push subscription credentials inside `result` */
+    browserPushSubscribe?: () => Promise<{
+        endpoint: string;
+        p256dh: string;
+        auth: string;
+    }>;
+    programEffect?: (op: ProgramEffectName, args: readonly JsonValue[], context?: Pick<ServiceCallContext, 'principal' | 'role'>) => Promise<ProgramEffectOutcome>;
+    agentPorts?: () => ServiceHostPorts | undefined;
+}
+/** Options for `browser/open-file-picker`. */
+interface BrowserFilePickerOptions {
+    /** Allow selecting multiple files. */
+    multiple?: boolean;
+    /** MIME type filter (e.g. "image/*"). Best-effort; host may ignore. */
+    accept?: string;
+}
+/** Metadata for a file chosen via `browser/open-file-picker`. */
+interface BrowserFileMeta {
+    name: string;
+    size: number;
+    type: string;
+    lastModified: number;
+}
+/** Options for `browser/geolocation-current` (subset of PositionOptions). */
+interface BrowserGeolocationOptions {
+    enableHighAccuracy?: boolean;
+    timeout?: number;
+    maximumAge?: number;
+}
+/** Position returned by `browser/geolocation-current`. */
+interface BrowserGeolocationPosition {
+    latitude: number;
+    longitude: number;
+    accuracy: number;
+}
+/**
+ * Context for resolving bindings like @entity.field, @payload.value
+ */
+interface BindingContext {
+    /** Current entity data */
+    entity?: EntityRow;
+    /** Event payload data */
+    payload?: EventPayload;
+    /** Current state name */
+    state?: string;
+    /** Trait-level state/config */
+    config?: ConfigContext;
+    /** Authenticated viewer behind `@user.x` — ownership (`@user.id`) and role gates. */
+    user?: UserContext;
+    /** The dispatch's one `now` stamp (ms epoch) — every guard, effect and time operator in it reads this. */
+    now?: number;
+    /** `@locale`: the viewer's locale (`EventRequest.locale`, else the program's first declared locale). */
+    locale?: string;
+    /** That locale's catalog — `i18n/t` reads it. */
+    messages?: Readonly<Record<string, string>>;
+    /** `@event`: the delivery being processed (Runtime Spec Clause 5.5). */
+    event?: EventPayload;
+    /** `@prevEvents`: deliveries this trait already received this dispatch. */
+    prevEvents?: EventPayload[];
+    /** `@prevStates`: states this trait left this dispatch. */
+    prevStates?: string[];
+    /** `@fromState` / `@toState`: the transition's ends. */
+    fromState?: string;
+    toState?: string;
+    /**
+     * The host orbital's pages for the `@pages` render sigil (`href`/`label`
+     * per inline page). Seeded onto the render binding context only — never
+     * present on a guard/tick context. Mirrors the compiler's
+     * `OirBindingRoot::Pages`.
+     */
+    pages?: NavItem[];
+    /**
+     * The `data-theme` key string for the `@currentTheme` render sigil,
+     * derived from the host orbital's `Orbital.theme`. Render-context only.
+     */
+    currentTheme?: string;
+    /**
+     * Local variables introduced by a `let` form, keyed by bare name and
+     * referenced via `@<name>` (the canonical evaluator convention — same as
+     * `createChildContext` in `@almadar/evaluator`). Carried on the context so
+     * a `let` body's effects resolve their value expressions against the
+     * `let`-bound locals.
+     */
+    locals?: Map<string, RuntimeValue>;
+    /**
+     * The composing effect's triggering payload, for a trait embedded via
+     * `@trait.X` inline into a parent's render-ui. Set when re-running an
+     * embedded child's lifecycle transition under its embedder's payload
+     * (see `OrbitalServerRuntime.executeEffects` / the client's
+     * `useTraitStateMachine`), so `@callsitePayload.<field>` resolves on the
+     * child's evaluation context — mirrors the compiled path's
+     * `CALLSITE_PAYLOAD_PREFIX` capture.
+     */
+    callsitePayload?: EventPayload;
+    /** Additional custom bindings */
+    [key: string]: RuntimeValue | undefined;
+}
+/**
+ * Executable effect tuple: operator name plus already-resolved arguments.
+ *
+ * Runtime-local on purpose — NOT `@almadar/core`'s `Effect` (`TypedEffect`),
+ * which is a CLOSED union of authoring-time tuples. The runtime's operator
+ * set is extensible (custom handlers, `os/*`, substrate ops), so the executor
+ * input is this open tuple. The wire-level type for effect lists stays
+ * `SExpr[]` (`TransitionResult.effects`, `TraitDefinition.transitions[].effects`);
+ * narrow it to `Effect[]` at the executor boundary with {@link isEffectTuple}.
+ */
+type Effect = [string, ...RuntimeValue[]];
+/**
+ * Result of executing a single effect, with status tracking.
+ */
+interface EffectResult {
+    /** Effect operator (e.g., "persist", "render-ui") */
+    type: string;
+    /** Effect arguments */
+    args: RuntimeValue[];
+    /** Whether the effect executed successfully */
+    status: "executed" | "failed" | "skipped";
+    /** Error message if failed */
+    error?: string;
+    /** Execution duration in milliseconds */
+    durationMs?: number;
+    /** Refused before the effect's handler ran (e.g. a `persist create` missing a
+     *  required field), so no handler recorded it — the host reports it. */
+    refusedBeforeHandler?: boolean;
+}
+/**
+ * Typed extensions that get spread onto every EvaluationContext.
+ * Each field here corresponds to an optional field on EvaluationContext.
+ */
+interface EvaluationContextExtensions {
+    /** Agent context for agent/* operators (memory, LLM, tools, session) */
+    agent?: AgentContext;
+    /** Substrate contexts for the new operator namespaces */
+    llm?: LlmContext;
+    workspace?: WorkspaceContext;
+    session?: SessionContext;
+    memory?: MemoryContext;
+    trace?: TraceContext;
+}
+
+export type { BindingContext, Effect, EffectHandlers, EffectResult, EvaluationContextExtensions, EventListener, IEventBus, PatternProps, RuntimeEvent, Unsubscribe };

package/dist/runtime/types.js

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

package/dist/service/default-call-service.d.ts

@@ -0,0 +1,23 @@
+import { ServiceParams, BusEventSource, EventPayload } from '@almadar/core';
+import { ServiceCallContext } from './service-provider.js';
+
+/**
+ * The runtime's own `call-service` answerer when the host injects none: the services a host plugged in with
+ * `registerServiceProvider`. A call to a service nobody plugged in fails by name, so the trait's declared failure event fires.
+ */
+
+/**
+ * Where a running `call-service`'s live messages go: the call site's
+ * `emit.onMessage` event, stamped as the calling trait. Absent when the call
+ * site declares no `onMessage`.
+ */
+interface ServiceMessageRoute {
+    event: string;
+    source?: BusEventSource;
+}
+/** Call an external service. `context` carries the caller's identity (the same viewer entity ACL enforces against) so role-gated services can enforce server-side; hosts forward it to the integration factory. */
+type CallServiceHandler = (service: string, action: string, params?: ServiceParams, context?: ServiceCallContext, message?: ServiceMessageRoute) => Promise<EventPayload | null>;
+declare function defaultCallService(service: string, action: string, params: ServiceParams | undefined, context?: ServiceCallContext): Promise<EventPayload | null>;
+
+export { defaultCallService };
+export type { CallServiceHandler, ServiceMessageRoute };

package/dist/service/default-call-service.js

@@ -0,0 +1,2 @@
+export { defaultCallService } from '../chunk-4SEK5ER2.js';
+import '../chunk-UBN5JJKZ.js';

package/dist/service/service-provider.d.ts

@@ -0,0 +1,37 @@
+import { ServiceHostPorts, ServiceParams, EventPayload } from '@almadar/core';
+
+/**
+ * Caller identity forwarded with a call-service dispatch (I-25) — the id and
+ * roster role of the SAME normalized viewer entity ACL enforces against.
+ * Absent when no viewer is bound (ticks, anonymous); role-gated services
+ * fail closed on absence.
+ */
+interface ServiceCallContext {
+    principal?: string;
+    role?: string;
+    /** The running app, lent for this call as the caller (`page watch`). */
+    host?: ServiceHostPorts;
+    /** Aborted when `cancel-call` cancels this call; a provider stops its work on it. */
+    signal?: AbortSignal;
+    /** No request awaits this call (a follow-on step's call): the host holds no request's event queue around it. */
+    outsideRequest?: true;
+}
+/** Why a service call failed, for a provider to name: bad params, no host installed, no signed-in caller, an action it does not have. */
+type ServiceCallErrorCode = 'VALIDATION_ERROR' | 'NOT_CONFIGURED' | 'AUTH_ERROR' | 'UNKNOWN_ACTION';
+declare class ServiceCallError extends Error {
+    readonly code: ServiceCallErrorCode;
+    constructor(message: string, code: ServiceCallErrorCode);
+}
+/** A host's answerer for the `call-service` calls of one named service: resolves the payload, throws to fail the call. */
+type ServiceProvider = (action: string, params: ServiceParams, context?: ServiceCallContext) => Promise<EventPayload | null>;
+/** Plug a service's answerer into this process's `call-service`; a later registration of the same name replaces it. */
+declare function registerServiceProvider(service: string, provider: ServiceProvider): void;
+/** Testing/reset hook. */
+declare function unregisterServiceProvider(service: string): void;
+/** The names of the services a host has plugged in. */
+declare function registeredServices(): string[];
+/** Calls `service.action` through the registered provider; a service no host plugged in is a named failure. */
+declare function callRegisteredService(service: string, action: string, params: ServiceParams | undefined, context?: ServiceCallContext): Promise<EventPayload | null>;
+
+export { ServiceCallError, callRegisteredService, registerServiceProvider, registeredServices, unregisterServiceProvider };
+export type { ServiceCallContext, ServiceCallErrorCode, ServiceProvider };

package/dist/service/service-provider.js

@@ -0,0 +1 @@
+export { ServiceCallError, callRegisteredService, registerServiceProvider, registeredServices, unregisterServiceProvider } from '../chunk-UBN5JJKZ.js';

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@almadar/shell-runtime",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "orbRelease": {
+    "severity": "normal"
+  },
+  "description": "Renderer-neutral kernel adapters and client orchestration for Almadar TypeScript hosts.",
+  "license": "BUSL-1.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@almadar/core": "^11.1.0",
+    "@almadar/kernel": "^19.0.1",
+    "@almadar/logger": "^2.1.0",
+    "@almadar/std": "^17.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^9.0.0",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "vitest": "^4.1.12"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/almadar-io/orbital-shell-typescript.git",
+    "directory": "runtime/kernel"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "scripts": {
+    "build": "NODE_OPTIONS=--max-old-space-size=8192 tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest --run"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.