@almadar/shell-web 0.0.0-stage → 0.1.0

package/dist/storage/browser/index.d.ts

@@ -0,0 +1 @@
+export * from '@almadar/shell-browser/storage';

package/dist/storage/browser/index.js

@@ -0,0 +1 @@
+export * from '@almadar/shell-browser/storage';

package/dist/test-support.d.ts

@@ -0,0 +1,35 @@
+import { KernelServerClass, KernelModule } from '@almadar/shell-runtime/kernel/wire';
+import { OrbitalSchema, UserContext } from '@almadar/core';
+import { KernelEngineValue } from './providers/index.js';
+import { KernelModule as KernelModule$1 } from './providers/index.js';
+import { EventTransport } from '@almadar/shell-runtime/client/EventTransport';
+import './verification-C5pTeMJv.js';
+import 'react';
+
+/**
+ * A whole `KernelModule` around a scripted `Server`, for tests that drive the engine without the wasm. Every member a
+ * test does not name throws when called, so a double never falls behind the module's surface.
+ */
+declare function stubKernelModule(Server: KernelServerClass, overrides?: Partial<Omit<KernelModule, 'Server'>>): KernelModule;
+
+declare const KERNEL_AVAILABLE: boolean;
+/** The installed language as the bundle a browser host hands a kernel it opens over a local store. */
+declare const TEST_LANGUAGE: string;
+/** The shared kernel module, loaded once, with the render evaluator installed from it. */
+declare function loadTestKernel(): Promise<KernelModule$1>;
+/** The std mock-seed program as `orb` resolves it from the installed packages, the way a Node host does. */
+declare function loadTestSeedProgram(): Promise<OrbitalSchema>;
+declare const KERNEL_ENGINE: KernelEngineValue;
+declare const ENGINES: ReadonlyArray<readonly [string, KernelEngineValue]>;
+/** A client-build kernel instance of its own, as a browser loads it: nothing has installed language data into it. */
+declare function loadFreshClientKernel(): Promise<KernelModule$1>;
+/** Load the WebAssembly and the adapter chunk before a timing-sensitive test: the first dispatch otherwise waits on both. */
+declare function warmKernel(): Promise<void>;
+
+/**
+ * The hosted playground's stateless topology: the program is registered once, and every request runs on a fresh
+ * session of it (`KernelEngine.fork`) over the kernel's own memory store, the client carrying the circuit state on the leg.
+ */
+declare function statelessKernelTransport(schema: OrbitalSchema, user?: () => Promise<UserContext | undefined>): EventTransport;
+
+export { ENGINES, KERNEL_AVAILABLE, KERNEL_ENGINE, TEST_LANGUAGE, loadFreshClientKernel, loadTestKernel, loadTestSeedProgram, statelessKernelTransport, stubKernelModule, warmKernel };

package/dist/test-support.js

@@ -0,0 +1,114 @@
+import { createInProcessTransport, src_exports } from './chunk-6P3MWXYE.js';
+import { openLocalKernel, nativeMemoryPersistence } from './chunk-DYEKAA4L.js';
+import './chunk-G7DCAZ22.js';
+import { execFileSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { createRequire } from 'module';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+import { OrbitalSchemaSchema, installKernelEvaluator } from '@almadar/core';
+import { readLanguageBundle } from '@almadar/core/language-data';
+
+// src/test-support/stub-kernel-module.ts
+function stubKernelModule(Server, overrides = {}) {
+  const unexpected = (name) => () => {
+    throw new Error(`stub kernel module: ${name} was not expected`);
+  };
+  return {
+    Server,
+    osGlobMatches: () => false,
+    isPublicAddress: () => false,
+    osDeferringOps: () => "[]",
+    osStreamOps: () => "[]",
+    osCompletionEvent: () => "null",
+    substrateCompletionEvent: () => "null",
+    tabUrlMatches: () => false,
+    installLanguage: unexpected("installLanguage"),
+    evaluateMany: unexpected("evaluateMany"),
+    resolveValues: unexpected("resolveValues"),
+    evaluateGuards: unexpected("evaluateGuards"),
+    evaluateTraced: unexpected("evaluateTraced"),
+    traceEffects: unexpected("traceEffects"),
+    mapListenPayload: unexpected("mapListenPayload"),
+    scopeRows: unexpected("scopeRows"),
+    checkMutationAccess: unexpected("checkMutationAccess"),
+    resolveRowBinding: unexpected("resolveRowBinding"),
+    ...overrides
+  };
+}
+var resolveInstalled = createRequire(import.meta.url).resolve;
+function kernelFiles() {
+  const dir = process.env.ALMADAR_KERNEL_DIR;
+  if (dir !== void 0 && dir !== "") {
+    return { glue: join(dir, "pkg/orbital_wasm.js"), wasm: join(dir, "pkg/orbital_wasm_bg.wasm") };
+  }
+  return { glue: resolveInstalled("@almadar/kernel"), wasm: resolveInstalled("@almadar/kernel/kernel.wasm") };
+}
+function kernelAvailable() {
+  try {
+    return existsSync(kernelFiles().glue);
+  } catch {
+    return false;
+  }
+}
+var KERNEL_AVAILABLE = kernelAvailable();
+async function load() {
+  const files = kernelFiles();
+  const glue = await import(
+    /* @vite-ignore */
+    pathToFileURL(files.glue).href
+  );
+  glue.initSync({ module: readFileSync(files.wasm) });
+  glue.installLanguage(TEST_LANGUAGE);
+  installKernelEvaluator(glue);
+  return glue;
+}
+var TEST_LANGUAGE = JSON.stringify(readLanguageBundle(process.cwd()));
+var shared;
+function loadTestKernel() {
+  return shared ??= load();
+}
+var WHICH_LINE = /^(\/\S+\.(?:orb|lolo)) \((.+)\)$/;
+function loadTestSeedProgram() {
+  const run = (args) => execFileSync("orb", [...args], { cwd: process.cwd(), encoding: "utf8", maxBuffer: 512 * 1024 * 1024 });
+  const which = run(["behaviors", "which", "std/behaviors/std-mock-seed"]).trim().split("\n").pop() ?? "";
+  const match = WHICH_LINE.exec(which);
+  if (match === null) return Promise.reject(new Error(`std/behaviors/std-mock-seed is not installed: ${which}`));
+  return Promise.resolve(OrbitalSchemaSchema.parse(JSON.parse(run(["resolve", match[1]]))));
+}
+var KERNEL_ENGINE = { loadModule: () => loadTestKernel(), loadLanguage: () => Promise.resolve(TEST_LANGUAGE), loadSeedProgram: loadTestSeedProgram };
+var ENGINES = KERNEL_AVAILABLE ? [["kernel", KERNEL_ENGINE]] : [];
+async function loadFreshClientKernel() {
+  const dir = process.env.ALMADAR_KERNEL_DIR;
+  const files = dir !== void 0 && dir !== "" ? { glue: join(dir, "pkg-client/orbital_wasm.js"), wasm: join(dir, "pkg-client/orbital_wasm_bg.wasm") } : { glue: resolveInstalled("@almadar/kernel/client"), wasm: resolveInstalled("@almadar/kernel/client.wasm") };
+  const glue = await import(
+    /* @vite-ignore */
+    `${pathToFileURL(files.glue).href}?fresh=${Math.random()}`
+  );
+  glue.initSync({ module: readFileSync(files.wasm) });
+  installKernelEvaluator(glue);
+  return glue;
+}
+async function warmKernel() {
+  if (!KERNEL_AVAILABLE) return;
+  await KERNEL_ENGINE.loadModule();
+  await import('./kernel-client-ZH4PSMCN.js');
+}
+
+// src/test-support/stateless-kernel.ts
+function statelessKernelTransport(schema, user = async () => void 0) {
+  let template;
+  return createInProcessTransport(async (orbital, request) => {
+    const viewer = await user();
+    template ??= loadTestKernel().then((kernel) => openLocalKernel({ kernel, language: TEST_LANGUAGE, schema, persistence: nativeMemoryPersistence(kernel) }));
+    const engine = (await template).fork();
+    try {
+      engine.seedRuntimeMock(viewer?.id);
+      return await (0, src_exports.evaluateOnKernel)({ engine, orbital }, request, viewer, request.locale);
+    } finally {
+      engine.dispose();
+    }
+  }, { carriesCircuitState: true });
+}
+
+export { ENGINES, KERNEL_AVAILABLE, KERNEL_ENGINE, TEST_LANGUAGE, loadFreshClientKernel, loadTestKernel, loadTestSeedProgram, statelessKernelTransport, stubKernelModule, warmKernel };

package/dist/themeTokens-CRd8AEDF.d.ts

@@ -0,0 +1,125 @@
+import { ThemeRef, ThemeDefinition, ThemeTokens, ThemeVariant, DensityTokens, DiagramTokens, ElevationTokens, GeometryTokens, IconographyTokens, MotionDurationKey, MotionEasingKey, MotionIntentMap, MotionShapeTokens, SceneTokens, SurfaceTokens, TypeScaleTokens, TypeIntentMap, TypeSizeKey, EnterAnimation } from '@almadar/core';
+
+/**
+ * themeTokens — runtime mirror of the orbital compiler's theme codegen.
+ *
+ * The compile path (orbital-rust/crates/orbital-shell-typescript/src/codegen/theme.rs)
+ * reads `OrbitalDefinition.theme.tokens` and emits CSS custom-property
+ * declarations into a `[data-theme="<name>-<mode>"]` block. The runtime
+ * does not parse compiled CSS — it reads the same `tokens` object directly
+ * and produces the same `{ '--color-primary': '…', '--radius-md': '…' }` map
+ * that the compiler emits.
+ *
+ * Keeping the two paths byte-identical at the variable level is the contract:
+ * editing tokens via the Studio Design System tab must produce the exact
+ * same rendered result as editing them in source and running `orbital
+ * compile`. The mapping rules here mirror `generate_tokens_css` /
+ * `generate_tokens_css_dark` (theme.rs:122–351).
+ *
+ * Compile vs runtime difference (intentional):
+ * - Compile emits the FULL set: schema overrides on top of defaults. This is
+ *   needed because the compiled CSS replaces the theme entirely.
+ * - Runtime emits ONLY the keys present in `tokens` (and `variants.dark`).
+ *   Missing keys cascade from the parent `[data-theme]` rule on the document
+ *   element. The provider scopes overrides to an orbital subtree without
+ *   shadowing inherited defaults.
+ *
+ * The per-axis var tables below (`DENSITY_SPACING_VARS`, `TYPE_INTENT_VARS`, …)
+ * are the ONE mapping between a typed-axis field and its CSS variable name.
+ * `themeTokensToCssVars` reads them forward (token → CSS); `almadar-core`'s
+ * one-time `scripts/migrate-css-themes.ts` reads them in reverse (CSS →
+ * token) to build `packages/almadar-core/themes/*.json` from the checked-in
+ * preset CSS — see that script for the inverse direction.
+ *
+ * @packageDocumentation
+ */
+
+/** Resolved color mode. Mirrors `ThemeContext.resolvedMode`. */
+type ThemeMode = 'light' | 'dark';
+/** The keys of `T` whose value is a plain (optional) string — excludes
+ * nested-object fields like `DensityTokens['spacing']` or
+ * `TypeScaleTokens['scale']`, which are never single CSS values. */
+type StringValueKey<T> = {
+    [K in keyof T]-?: T[K] extends string | undefined ? K : never;
+}[keyof T] & string;
+/** One flat scalar field on an axis object and the CSS var name it maps to. */
+interface FlatVarEntry<T> {
+    readonly cssVar: string;
+    readonly key: StringValueKey<T>;
+}
+/** Density axis — spacing scale steps (`density.spacing.space<N>` → `--space-<N>`). */
+declare const DENSITY_SPACING_VARS: ReadonlyArray<FlatVarEntry<NonNullable<DensityTokens['spacing']>>>;
+/** Density axis — per-element heights + paddings. */
+declare const DENSITY_ELEMENT_VARS: ReadonlyArray<FlatVarEntry<DensityTokens>>;
+/** Type axis — family triplet. */
+declare const TYPE_FAMILY_VARS: ReadonlyArray<FlatVarEntry<TypeScaleTokens>>;
+/** Type axis — heading voice (weight/case/tracking/style/shadow of every heading). */
+declare const TYPE_HEADING_VARS: ReadonlyArray<FlatVarEntry<TypeScaleTokens>>;
+/** Type axis — size scale keys, ordered exactly as emitted. Each pairs `--text-<k>` / `--leading-<k>`. */
+declare const TYPE_SIZE_KEYS: ReadonlyArray<TypeSizeKey>;
+/** Type axis — intent names, ordered exactly as emitted. Each is 3 vars: `-size` / `-weight` / `-leading`. */
+declare const TYPE_INTENT_VARS: ReadonlyArray<{
+    key: keyof TypeIntentMap & string;
+    cssName: string;
+}>;
+/** Motion axis — duration palette keys, ordered exactly as emitted. */
+declare const MOTION_DURATION_KEYS: ReadonlyArray<MotionDurationKey>;
+/** Motion axis — easing palette keys, ordered exactly as emitted. */
+declare const MOTION_EASING_KEYS: ReadonlyArray<MotionEasingKey>;
+/** Motion axis — intent names, ordered exactly as emitted. Each is 2 vars: `-duration` / `-easing`. */
+declare const MOTION_INTENT_VARS: ReadonlyArray<{
+    key: keyof MotionIntentMap & string;
+    cssName: string;
+}>;
+/** Motion axis — per-surface shapes (the enter-from / exit-to transform endpoints). */
+declare const MOTION_SHAPE_VARS: ReadonlyArray<FlatVarEntry<MotionShapeTokens>>;
+/** Iconography axis — flat fields. */
+declare const ICONOGRAPHY_VARS: ReadonlyArray<FlatVarEntry<IconographyTokens>>;
+/** Elevation axis — flat fields. */
+declare const ELEVATION_VARS: ReadonlyArray<FlatVarEntry<ElevationTokens>>;
+/** Geometry axis — flat fields. */
+declare const GEOMETRY_VARS: ReadonlyArray<FlatVarEntry<GeometryTokens>>;
+/** Surface axis — panel/page material. */
+declare const SURFACE_VARS: ReadonlyArray<FlatVarEntry<SurfaceTokens>>;
+/** Diagram axis — how marks are drawn on every drawing surface. */
+declare const DIAGRAM_VARS: ReadonlyArray<FlatVarEntry<DiagramTokens>>;
+/** Scene axis — 3D material and lighting. */
+declare const SCENE_VARS: ReadonlyArray<FlatVarEntry<SceneTokens>>;
+/** Legacy free-form map prefixes (`ThemeTokens.colors`/`radii`/`spacing`/`shadows`). `typography` has no prefix — see below. */
+declare const LEGACY_PREFIXES: {
+    readonly colors: "--color-";
+    readonly radii: "--radius-";
+    readonly spacing: "--space-";
+    readonly shadows: "--shadow-";
+};
+/**
+ * Convert `ThemeTokens` (+ optional dark variant) into a CSS custom-property
+ * map keyed by variable name (e.g. `--color-primary`).
+ *
+ * Mapping rules (mirror theme.rs):
+ * - `tokens.colors.<k>`     → `--color-<k>`
+ * - `tokens.radii.<k>`      → `--radius-<k>`
+ * - `tokens.spacing.<k>`    → `--space-<k>`
+ * - `tokens.typography.<k>` → `--<k>` (keys already include their `font-`/
+ *                                       `letter-`/`line-` prefix)
+ * - `tokens.shadows.<k>`    → `--shadow-<k>` (schema key has no prefix)
+ *
+ * In `'dark'` mode, the `darkVariant` overrides are merged on top of the
+ * base tokens per category — same precedence the Rust compiler uses
+ * (`generate_tokens_css_dark`). Categories not present in `darkVariant` fall
+ * back to the base tokens.
+ */
+declare function themeTokensToCssVars(tokens: ThemeTokens, mode?: ThemeMode, darkVariant?: ThemeVariant): Record<string, string>;
+/** The keyframe name an entry keyword plays (`none` stays `none`). */
+declare function enterKeyframe(enter: EnterAnimation): string;
+/**
+ * `ThemeRef` is `ThemeDefinition | string`. When it's a string, it's an
+ * unresolved import reference (e.g. `"Ocean.theme"`) that should have been
+ * inlined by the compiler's import phase before runtime. If we still see a
+ * string here, the upstream resolution path didn't run — return `undefined`
+ * rather than guess. `OrbitalThemeProvider` falls through to passthrough.
+ */
+declare function resolveThemeForRuntime(theme: ThemeRef | undefined): ThemeDefinition | undefined;
+
+export { DENSITY_ELEMENT_VARS as D, ELEVATION_VARS as E, GEOMETRY_VARS as G, ICONOGRAPHY_VARS as I, LEGACY_PREFIXES as L, MOTION_DURATION_KEYS as M, SCENE_VARS as S, DENSITY_SPACING_VARS as a, DIAGRAM_VARS as b, MOTION_EASING_KEYS as c, MOTION_INTENT_VARS as d, MOTION_SHAPE_VARS as e, SURFACE_VARS as f, TYPE_FAMILY_VARS as h, TYPE_HEADING_VARS as i, TYPE_INTENT_VARS as j, TYPE_SIZE_KEYS as k, enterKeyframe as l, resolveThemeForRuntime as r, themeTokensToCssVars as t };
+export type { FlatVarEntry as F, ThemeMode as T, StringValueKey as g };