@almadar/shell-web 0.0.0-stage → 1.0.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,2 @@
+"use client";
+export * from '@almadar/shell-browser/storage';

package/dist/test-support.d.ts

@@ -0,0 +1,42 @@
+import { KernelServerClass, KernelModule } from '@almadar/shell-runtime/kernel/wire';
+import { OrbitalSchema } from '@almadar/core';
+import { KernelEngineValue } from './providers/index.js';
+import { KernelModule as KernelModule$1 } from './providers/index.js';
+import { EventTransport } from '@almadar/shell-runtime';
+import 'react';
+import '@almadar/shell-runtime/kernel/os-port';
+import '@almadar/shell-browser/kv';
+import './verification-C5pTeMJv.js';
+
+/**
+ * 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 type-contract stamp every test program carries, typed from core's `OrbitalSchema` so a version bump there fails here. */
+declare const TEST_TYPE_CONTRACT_VERSION: NonNullable<OrbitalSchema['typeContractVersion']>;
+/** The stamp option a hook under test hands the kernel: the same version, as a program's stamp. */
+declare const TEST_STAMP: Pick<OrbitalSchema, 'typeContractVersion'>;
+/** 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>;
+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: initialised, with the language installed once, as the browser kernel loader does. */
+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): EventTransport;
+
+/** A `.lolo` program (with any files beside it, such as `locales/en/<app>.json`) as the installed `orb` compiles it for a browser kernel: the stamp, `_metadata.protocols` and dispatch facts included. */
+declare function clientProgram(source: string, files?: Readonly<Record<string, string>>): OrbitalSchema;
+
+export { ENGINES, KERNEL_AVAILABLE, KERNEL_ENGINE, TEST_LANGUAGE, TEST_STAMP, TEST_TYPE_CONTRACT_VERSION, clientProgram, loadFreshClientKernel, loadTestKernel, statelessKernelTransport, stubKernelModule, warmKernel };

package/dist/test-support.js

@@ -0,0 +1,181 @@
+"use client";
+import { openLocalKernel, nativeMemoryPersistence } from './chunk-3VZ36ZKO.js';
+import './chunk-G7DCAZ22.js';
+import { existsSync, readFileSync, mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'fs';
+import { createRequire } from 'module';
+import { join, dirname } from 'path';
+import { pathToFileURL } from 'url';
+import { installKernelEvaluator, parseOrbitalSchema } from '@almadar/core';
+import { installNativeLanguages } from '@almadar/syntax';
+import { readLanguageBundle } from '@almadar/core/language-data';
+import { createInProcessTransport, evaluateOnKernel } from '@almadar/shell-runtime';
+import { execFileSync } from 'child_process';
+import { tmpdir } from 'os';
+
+// 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: () => "[]",
+    contractQueryWithoutProgram: () => "null",
+    osStreamOps: () => "[]",
+    osCompletionEvent: () => "null",
+    substrateCompletionEvent: () => "null",
+    tabUrlMatches: () => false,
+    parseEventRequest: unexpected("parseEventRequest"),
+    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"),
+    eventWires: unexpected("eventWires"),
+    validatePacks: unexpected("validatePacks"),
+    expandFxLayer: unexpected("expandFxLayer"),
+    resolveFxView: unexpected("resolveFxView"),
+    fxLifecycle: unexpected("fxLifecycle"),
+    fxHash01: unexpected("fxHash01"),
+    skinWorldMatrices: unexpected("skinWorldMatrices"),
+    skinVertices: unexpected("skinVertices"),
+    skinComposeAffine: unexpected("skinComposeAffine"),
+    skinInvertAffine: unexpected("skinInvertAffine"),
+    skinApplyAffine: unexpected("skinApplyAffine"),
+    skinTriangleAffine: unexpected("skinTriangleAffine"),
+    skinVertexBounds: unexpected("skinVertexBounds"),
+    ...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);
+  installNativeLanguages();
+  return glue;
+}
+var TEST_TYPE_CONTRACT_VERSION = 1;
+var TEST_STAMP = { typeContractVersion: TEST_TYPE_CONTRACT_VERSION };
+var TEST_LANGUAGE = JSON.stringify(readLanguageBundle(process.cwd()));
+var shared;
+function loadTestKernel() {
+  return shared ??= load();
+}
+var KERNEL_ENGINE = { loadModule: () => loadTestKernel() };
+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) });
+  glue.installLanguage(TEST_LANGUAGE);
+  installKernelEvaluator(glue);
+  installNativeLanguages();
+  return glue;
+}
+async function warmKernel() {
+  if (!KERNEL_AVAILABLE) return;
+  await KERNEL_ENGINE.loadModule();
+  await import('./kernel-client-TZKGHJRY.js');
+}
+function statelessKernelTransport(schema) {
+  let template;
+  return createInProcessTransport(async (orbital, request) => {
+    template ??= loadTestKernel().then((kernel) => openLocalKernel({ kernel, schema, persistence: nativeMemoryPersistence(kernel) }));
+    const engine = (await template).fork();
+    try {
+      return await evaluateOnKernel({ engine, orbital }, request, request.locale);
+    } finally {
+      engine.dispose();
+    }
+  }, { carriesCircuitState: true });
+}
+var lowered = /* @__PURE__ */ new Map();
+var lockDir = join(tmpdir(), "almadar-client-program.lock");
+function holderAlive() {
+  try {
+    process.kill(Number(readFileSync(join(lockDir, "pid"), "utf8")), 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function compileExclusively(compile) {
+  const wait = new Int32Array(new SharedArrayBuffer(4));
+  for (; ; ) {
+    try {
+      mkdirSync(lockDir);
+      writeFileSync(join(lockDir, "pid"), String(process.pid));
+      break;
+    } catch (error) {
+      if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") throw error;
+      if (!holderAlive()) rmSync(lockDir, { recursive: true, force: true });
+      Atomics.wait(wait, 0, 0, 25);
+    }
+  }
+  try {
+    return compile();
+  } finally {
+    rmSync(lockDir, { recursive: true, force: true });
+  }
+}
+function clientProgram(source, files = {}) {
+  const bin = process.env.ORB_BIN;
+  if (bin === void 0 || bin === "") throw new Error("clientProgram: set ORB_BIN to the installed orb binary that lowers the test programs");
+  const key = JSON.stringify([source, files]);
+  const known = lowered.get(key);
+  if (known !== void 0) return structuredClone(known);
+  const dir = mkdtempSync(join(tmpdir(), "client-program-"));
+  try {
+    const file = join(dir, "program.lolo");
+    writeFileSync(file, source);
+    const served = join(dir, "out/packages/client/public");
+    for (const [path, text] of Object.entries(files)) {
+      for (const target of [join(dir, path), join(served, path)]) {
+        mkdirSync(dirname(target), { recursive: true });
+        writeFileSync(target, text);
+      }
+    }
+    const schema = compileExclusively(() => {
+      execFileSync(bin, ["compile", file, "-o", join(dir, "out"), "--mode", "client"], { cwd: dir, stdio: "pipe" });
+      return parseOrbitalSchema(JSON.parse(readFileSync(join(served, "program.client.orb"), "utf8")));
+    });
+    lowered.set(key, schema);
+    return structuredClone(schema);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+export { ENGINES, KERNEL_AVAILABLE, KERNEL_ENGINE, TEST_LANGUAGE, TEST_STAMP, TEST_TYPE_CONTRACT_VERSION, clientProgram, loadFreshClientKernel, loadTestKernel, 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 };