@almadar/shell-node 0.0.0-stage → 0.1.0

package/dist/chunk-UBZT5LDW.js

@@ -0,0 +1,63 @@
+import { createRequire } from 'module';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+import { installKernelEvaluator } from '@almadar/core';
+import { readLanguageBundle } from '@almadar/core/language-data';
+import * as installedModule from '@almadar/kernel';
+import { NativeMemoryPersistenceAdapter } from '@almadar/shell-runtime';
+
+// src/kernel-loader.ts
+function hasMemoryStore(kernel) {
+  return "MemoryStore" in kernel;
+}
+function nativeMemoryOf(kernel) {
+  if (!hasMemoryStore(kernel)) throw new Error("this kernel module exports no MemoryStore; install a kernel build that carries it");
+  return new NativeMemoryPersistenceAdapter(new kernel.MemoryStore());
+}
+async function loadKernelModule(kernelDir, options) {
+  return loadKernel(kernelDir, options);
+}
+var initialised = /* @__PURE__ */ new WeakSet();
+function initOnce(loaded, wasm, languageFrom) {
+  if (initialised.has(loaded)) return loaded;
+  if (wasm !== void 0) loaded.initSync({ module: wasm });
+  loaded.installLanguage(JSON.stringify(readLanguageBundle(languageFrom)));
+  installKernelEvaluator(loaded);
+  initialised.add(loaded);
+  return loaded;
+}
+function initKernelSync(languageFrom) {
+  initOnce(installedModule, readFileSync(createRequire(import.meta.url).resolve("@almadar/kernel/kernel.wasm")), languageFrom);
+  return installedModule;
+}
+async function loadInstalledKernel(languageFrom) {
+  return initKernelSync(languageFrom);
+}
+async function loadHttpKernel(kernelDir, options) {
+  return loadKernel(kernelDir, options);
+}
+async function loadKernel(kernelDir, options) {
+  const loaded = await import(pathToFileURL(join(kernelDir, "pkg/orbital_wasm.js")).href);
+  return initOnce(loaded, initialised.has(loaded) ? void 0 : readFileSync(join(kernelDir, "pkg/orbital_wasm_bg.wasm")), options.languageFrom);
+}
+var NATIVE_PLATFORMS = {
+  "darwin-x64": "darwin-x64",
+  "darwin-arm64": "darwin-arm64",
+  "linux-x64": "linux-x64",
+  "linux-arm64": "linux-arm64",
+  "win32-x64": "windows-x64"
+};
+function resolveNativeAddon(from) {
+  const named = process.env.ALMADAR_KERNEL_NODE;
+  if (named !== void 0 && named !== "") return named;
+  const platform = NATIVE_PLATFORMS[`${process.platform}-${process.arch}`];
+  if (platform === void 0) throw new Error(`no native kernel add-on is shipped for ${process.platform}-${process.arch}`);
+  return createRequire(join(from, "resolve.js")).resolve(`@almadar/orb-${platform}/kernel.node`);
+}
+async function loadNativeKernelModule(addonPath, options) {
+  const loaded = createRequire(import.meta.url)(addonPath);
+  return initOnce(loaded, void 0, options.languageFrom);
+}
+
+export { initKernelSync, loadHttpKernel, loadInstalledKernel, loadKernelModule, loadNativeKernelModule, nativeMemoryOf, resolveNativeAddon };

package/dist/chunk-WZFQ7T7V.js

@@ -0,0 +1,18 @@
+import { workspacesRoot, kernelWorkspaceHost, workspaceBucketFromEnv } from './chunk-BJA6GYC5.js';
+import { runProgramEffect } from './chunk-QYAPNUBH.js';
+import { installedWorkspaceHost, installWorkspaceHost } from './chunk-BWMLDDCL.js';
+
+// src/program/createProgramHandlers.ts
+var bucketOf = () => {
+  const bucket = workspaceBucketFromEnv(process.env);
+  return bucket === void 0 ? {} : { bucket };
+};
+function createProgramHandlers(host) {
+  const opts = host.orbBin === void 0 ? { cwd: host.cwd } : { cwd: host.cwd, orbBin: host.orbBin };
+  if (installedWorkspaceHost()?.root !== workspacesRoot(host.cwd)) {
+    installWorkspaceHost(kernelWorkspaceHost({ projectRoot: host.cwd, ...bucketOf(), ...host.orbBin !== void 0 ? { orb: host.orbBin } : {} }));
+  }
+  return { programEffect: (op, args, context) => runProgramEffect(op, args, opts, context) };
+}
+
+export { createProgramHandlers };

package/dist/createProgramHandlers.d.ts

@@ -0,0 +1,28 @@
+import { EffectHandlers } from '@almadar/shell-runtime';
+
+/**
+ * Program host handlers — server-side only.
+ *
+ * Backs the language trio's effects (behavior/catalog|describe|source,
+ * program/read|print|eval) with the one host implementation in
+ * `host/program`, which runs the installed `orb` from the
+ * project directory. Its workspaces are `std-workspace` run by the kernel
+ * (`kernelWorkspaceHost`). Wired by OrbitalServerRuntime
+ * (lazy import, merged under user handlers).
+ *
+ * NOT exported from the main index.ts because it spawns processes.
+ *
+ * @packageDocumentation
+ */
+
+interface ProgramHostConfig {
+    /** Project root `orb` resolves behavior packages from. */
+    cwd: string;
+    /** Explicit `orb` binary; defaults to the host's resolution order. */
+    orbBin?: string;
+}
+type ProgramHandlers = Pick<EffectHandlers, 'programEffect'>;
+declare function createProgramHandlers(host: ProgramHostConfig): ProgramHandlers;
+
+export { createProgramHandlers };
+export type { ProgramHandlers, ProgramHostConfig };

package/dist/createProgramHandlers.js

@@ -0,0 +1,6 @@
+export { createProgramHandlers } from './chunk-WZFQ7T7V.js';
+import './chunk-BJA6GYC5.js';
+import './chunk-23YAOI6P.js';
+import './chunk-UBZT5LDW.js';
+import './chunk-QYAPNUBH.js';
+import './chunk-BWMLDDCL.js';

package/dist/index.d.ts

@@ -0,0 +1,265 @@
+import { PinnedFetch, CredentialScopeStorage, NetPort, ResolvedHost, OsAnchors, OsGrantPort, OsHostPort, KernelModule, HttpKernel, CredentialSeedKernel, NativeMemoryPersistenceAdapter, ServiceCallContext, StepRequest, PlayedStep, ProgramValidationReport, ProgramEffectName, ProgramEffectOutcome } from '@almadar/shell-runtime';
+import { JsonValue, KernelMemoryStoreExports, OrbitalSchema, EvaluatedProgram, ProgramValidationIssue, CatalogScope, CatalogEntry, DependencyGraph, TraitValue, TraitDescription, DescribeTarget, BehaviorDescription, BehaviorRef, BehaviorValueMountResult, TraitValueMountResult } from '@almadar/core';
+export { ClientEffectTuple, ClientNavigateBackTuple, ClientNavigateTuple, ClientRenderUITuple, OrbitalEventRequest, OrbitalEventResponse, TransitionRejection } from '@almadar/core';
+import * as installedModule from '@almadar/kernel';
+import { LayoutStrategy } from '@almadar/core/builders';
+export { G as GCS_ENDPOINT, K as KernelProgram, a as KernelProgramOptions, b as KernelWorkspaceBucket, c as KernelWorkspaceHostOptions, P as ProgramRun, W as WORKSPACE_HMAC_KEY_ID, d as WORKSPACE_HMAC_SECRET, e as WorkspaceHost, f as WorkspacePort, g as emitPayload, i as installWorkspaceHost, h as installedWorkspaceHost, k as kernelWorkspaceHost, r as resolveKernelDir, j as resolveProgramFile, u as uninstallWorkspaceHost, w as workspaceBucketFromEnv, l as workspaceOwnerSegment, m as workspacesRoot } from './kernel-workspace-host-CU56iOlt.js';
+export { HostDispatchItem, LiveBroadcastItem, LoaderConfig, OrbitalInfo, OrbitalServerRuntime, OrbitalServerRuntimeConfig, OrbitalSummary, PushItem, RegisterOptions, RegisteredOrbital, RuntimeOrbital, RuntimeOrbitalSchema, RuntimeTrait, RuntimeTraitTick, UnresolvedProgramError, createOrbitalServerRuntime } from './OrbitalServerRuntime.js';
+export { ProgramHandlers, ProgramHostConfig, createProgramHandlers } from './createProgramHandlers.js';
+
+declare const pinnedFetchNode: PinnedFetch;
+
+declare function resolveHostNode(host: string): Promise<ResolvedHost>;
+declare const nodeNetPort: NetPort;
+declare function nodeCredentialScope(): CredentialScopeStorage;
+/** Install the Node ports `@almadar/shell-runtime` leaves open: the pinned `http` fetch + resolver and per-tenant credential scopes. Idempotent. */
+declare function installNodeHostPorts(): void;
+
+/**
+ * A development host's credential-store master key: read from `<dir>/dev-credential-master-key`,
+ * generated there (owner-only) on first use. Production must hold its key in the platform secret
+ * store, so this refuses under NODE_ENV=production.
+ */
+declare function loadOrCreateDevMasterKey(dir: string): string;
+
+/** One program instance's `os` host: its own handle tables, closed by `close`. */
+interface NodeOsHostOptions {
+    /** Where `~/` and `./` and the declared grant anchors are placed; absent, the process's own (`OsAnchors::of_process`). */
+    anchors?: OsAnchors;
+}
+/** The process's home, working directory, executable directory and environment, read once (`OsAnchors::of_process`). */
+declare function processAnchors(): OsAnchors;
+declare function createNodeOsHost(grants: OsGrantPort, options?: NodeOsHostOptions): OsHostPort;
+
+type KvErrorKind = 'denied' | 'invalid' | 'io' | 'timeout' | 'unsupported' | 'closed';
+type KvResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+    kind: KvErrorKind;
+};
+interface KvNamespace {
+    app: string;
+    locale: string;
+    store: string;
+}
+interface KvScanEntry {
+    key: string;
+    value: JsonValue;
+}
+type KvBatchOp = {
+    kind: 'put';
+    key: string;
+    value: JsonValue;
+} | {
+    kind: 'delete';
+    key: string;
+};
+declare class KvFailure extends Error {
+    readonly kind: KvErrorKind;
+    constructor(kind: KvErrorKind, message: string);
+}
+/** A namespace's whole content, key order = UTF-8 byte order. Backends load and commit it whole. */
+type KvTable = Map<string, JsonValue>;
+interface KvBackend {
+    load(ns: KvNamespace): Promise<KvTable>;
+    /** Replace the namespace content atomically: a failure leaves the previous content. */
+    commit(ns: KvNamespace, table: KvTable): Promise<void>;
+}
+declare function namespaceId(ns: KvNamespace): string;
+declare function memoryKvBackend(): KvBackend;
+declare function directoryKvBackend(stateDir: string): KvBackend;
+interface KvHost {
+    get(ns: KvNamespace, key: string): Promise<KvResult<{
+        found: boolean;
+        value?: JsonValue;
+    }>>;
+    put(ns: KvNamespace, key: string, value: JsonValue): Promise<KvResult<{
+        storedKey: string;
+    }>>;
+    delete(ns: KvNamespace, key: string): Promise<KvResult<{
+        existed: boolean;
+    }>>;
+    scan(ns: KvNamespace, prefix: string, limit?: number): Promise<KvResult<{
+        entries: KvScanEntry[];
+    }>>;
+    batch(ns: KvNamespace, ops: readonly KvBatchOp[]): Promise<KvResult<{
+        applied: number;
+    }>>;
+}
+declare function createKvHost(backend: KvBackend): KvHost;
+
+/** The whole server kernel as Node loads it: the shared module plus the server-only exports the client build omits. */
+interface LoadedKernel extends KernelModule, HttpKernel, CredentialSeedKernel, KernelMemoryStoreExports {
+    initSync(input: {
+        module: Uint8Array;
+    }): object;
+}
+/** A row store the kernel itself holds (its `MemoryStore`), as a host keeps rows with no database. */
+declare function nativeMemoryOf(kernel: KernelModule): NativeMemoryPersistenceAdapter;
+interface LoadKernelOptions {
+    /** Where the installed `@almadar/core` and `@almadar/std` are found, node-style. Required: the caller names its own root. */
+    languageFrom: string;
+}
+/**
+ * Loads the kernel and installs the language data the installed packages declare (the operator table that
+ * routes `program/*` and the other host effects), as `orb` reads it. The first install in a process wins.
+ */
+declare function loadKernelModule(kernelDir: string, options: LoadKernelOptions): Promise<LoadedKernel>;
+/**
+ * The kernel of the `@almadar/kernel` package this host installs, initialised synchronously with the language data
+ * the packages under `languageFrom` declare. `languageFrom` is required; the first call in a process wins.
+ */
+declare function initKernelSync(languageFrom: string): typeof installedModule;
+/**
+ * The kernel of the `@almadar/kernel` package this host installs, loaded once per process with the language data
+ * the packages under `languageFrom` declare. A host with no package installed rejects, never falls back.
+ */
+declare function loadInstalledKernel(languageFrom: string): Promise<LoadedKernel>;
+/**
+ * The `http` effect's builder exports of the same package (`buildHttpRequest`, `isPublicAddress`, …): the
+ * interpreter's only way to build a request. A directory that does not hold a built kernel rejects, never falls back.
+ */
+declare function loadHttpKernel(kernelDir: string, options: LoadKernelOptions): Promise<HttpKernel>;
+/**
+ * Where the native kernel add-on is: `ALMADAR_KERNEL_NODE`, else `kernel.node` in the `@almadar/orb-<platform>-<arch>`
+ * package this platform installs. Rejects when neither exists, so a host can fall back to the wasm kernel by choice.
+ */
+declare function resolveNativeAddon(from: string): string;
+/**
+ * Loads the native kernel add-on (the same API as the wasm module, run as machine code) and installs the language data
+ * the installed packages declare. The first install in a process wins.
+ */
+declare function loadNativeKernelModule(addonPath: string, options: LoadKernelOptions): Promise<LoadedKernel>;
+
+/**
+ * The host side of the language trio's server effects (`behavior/catalog`,
+ * `behavior/describe`, `behavior/source`, `behavior/resolve`, `behavior/dependencies`, `program/read|print|eval`): a thin
+ * caller that runs the installed `orb` from the project directory and parses its
+ * JSON. All behavior resolution, reflection, printing and validation is `orb`'s;
+ * nothing here re-implements it. Both execution paths (the interpreter's effect
+ * executor and the compiled server host) call this module.
+ *
+ * @packageDocumentation
+ */
+
+/** Where the host runs `orb`: the project (workspace) root, so installed behavior packages resolve. */
+interface ProgramHostOptions {
+    readonly cwd: string;
+    /** Explicit `orb` binary; defaults to {@link resolveOrbBinary}. */
+    readonly orbBin?: string;
+}
+/** `behavior/catalog`: installed behaviors under registry folders; `vectors: false` omits the vectors (`--no-vectors`). */
+declare function behaviorCatalog(scope: CatalogScope, opts: ProgramHostOptions, options?: {
+    readonly vectors?: boolean;
+}): Promise<CatalogEntry[]>;
+/** {@link behaviorCatalog} for a caller that cannot await. */
+declare function behaviorCatalogSync(scope: CatalogScope, opts: ProgramHostOptions): CatalogEntry[];
+/** `behavior/describe`: a trait value's knobs and events; an orbital value's or a whole behavior's orbitals.
+ * `knobVectors: true` attaches a trait's knob vectors (`--knob-vectors`). */
+declare function behaviorDescribe(value: TraitValue, opts: ProgramHostOptions, options?: {
+    readonly knobVectors?: boolean;
+}): Promise<TraitDescription>;
+declare function behaviorDescribe(value: DescribeTarget, opts: ProgramHostOptions, options?: {
+    readonly knobVectors?: boolean;
+}): Promise<TraitDescription | BehaviorDescription>;
+/** `behavior/source`: the behavior a value belongs to, as a program (`.orb` IR). */
+declare function behaviorSource(value: Pick<TraitValue, 'behavior'>, opts: ProgramHostOptions): Promise<OrbitalSchema>;
+/** `program/read`: `.lolo` text → a program (`.orb` IR). */
+declare function programRead(text: string, opts: ProgramHostOptions): Promise<OrbitalSchema>;
+/** `program/print`: a program (`.orb` IR) → `.lolo` text. */
+declare function programPrint(program: OrbitalSchema, opts: ProgramHostOptions): Promise<string>;
+/** Who runs a program effect: the signed-in caller, as `call-service` receives it. */
+type ProgramCallContext = Pick<ServiceCallContext, 'principal' | 'role'>;
+/**
+ * A workspace-backed specifier (`./<workspaces root>/<owner>/…`) is readable
+ * only by its owner; every other specifier is unaffected. Returns the refusal,
+ * or undefined when the caller may read it.
+ */
+declare function workspaceAccessError(behavior: string, opts: ProgramHostOptions, context: ProgramCallContext | undefined): string | undefined;
+/** Options for {@link programEval}. */
+interface ProgramEvalOptions extends ProgramHostOptions {
+    /** Write into this workspace (opened as `context`'s caller) and snapshot it; without one, into `<cwd>/orbitals`. */
+    readonly workspace?: {
+        readonly id: string;
+        readonly context: ProgramCallContext;
+    };
+    /** A prior version of the program whose ids the re-evaluation keeps. */
+    readonly prior?: OrbitalSchema;
+    /** The program is a finished app (a generation concludes here): `orb validate --final`. */
+    readonly final?: boolean;
+}
+type ProgramEvalResult = {
+    readonly ok: true;
+    readonly result: EvaluatedProgram;
+} | {
+    readonly ok: false;
+    readonly errors: readonly ProgramValidationIssue[];
+};
+/**
+ * `program/validate`: the same stamp-and-validate call as `program/eval`, at the same
+ * 0-error / 0-warning bar, in a temp directory that is removed after. Nothing is written
+ * to the workspace or the project.
+ */
+declare function programValidate(program: OrbitalSchema, opts: Pick<ProgramEvalOptions, 'cwd' | 'prior' | 'final'> & ProgramHostOptions): Promise<ProgramValidationReport>;
+/**
+ * `program/eval`: validate through {@link stampAndValidate}, and on success write the program to `orbitals/<name>.orb` in its workspace (or `cwd`)
+ * and return its traits as values. Failures come back as data.
+ */
+declare function programEval(program: OrbitalSchema, opts: ProgramEvalOptions): Promise<ProgramEvalResult>;
+/** Options for {@link programCompose}. */
+interface ProgramComposeOptions {
+    readonly appName: string;
+    readonly layout?: LayoutStrategy;
+    /** The app's theme (a built-in theme name), set on the composed program. */
+    readonly theme?: string;
+}
+/**
+ * `program/compose`: assemble programs, in the order given, into one app
+ * program — core `composeAppFromFiles` (pages, layout, wiring, the app nav).
+ * The composer's registry lookups (an import's source orbital, an atom's trait,
+ * an organism's orbital order) are served from `orb behaviors source` for every
+ * behavior the programs import, loaded once up front.
+ */
+declare function programCompose(programs: readonly OrbitalSchema[], options: ProgramComposeOptions, opts: ProgramHostOptions): Promise<OrbitalSchema>;
+/**
+ * Turn a trait value into a program a host can run: a one-orbital wrapper that
+ * imports the value's owning orbital with `only { T }` and the value's overrides
+ * as `traits { T { … } }` (LOLO §8b), validated at the 0/0 bar (the binding's
+ * admission check) and resolved by `orb`. A project-relative behavior
+ * (`./orbitals/X`) is imported relatively from a wrapper written at `cwd`, since
+ * `orb`'s loader refuses an absolute import.
+ */
+declare function mountTraitValue(value: TraitValue, opts: ProgramHostOptions, context?: ProgramCallContext): Promise<TraitValueMountResult>;
+/**
+ * Make a behavior value runnable: the program as written is validated at the
+ * 0/0 bar (the embed's admission check) and resolved by `orb`; the frame opens
+ * it on its default page (the one marked `initial`, else the first).
+ */
+declare function mountBehaviorValue(value: BehaviorRef, opts: ProgramHostOptions, context?: ProgramCallContext): Promise<BehaviorValueMountResult>;
+/** A program file resolved by `orb` (every import flattened, every composed trait inlined): what a host registers. */
+declare function programResolve(path: string, opts: ProgramHostOptions): Promise<OrbitalSchema>;
+/** An unresolved program resolved by `orb` from the project root `opts.cwd`, so its relative imports resolve there. */
+declare function programResolveSchema(program: OrbitalSchema, opts: ProgramHostOptions): Promise<OrbitalSchema>;
+/** `behavior/resolve`: the behavior a value belongs to, resolved by `orb` — every import and composed trait inlined, as the runtime runs it. */
+declare function behaviorResolve(value: Pick<TraitValue, 'behavior'>, opts: ProgramHostOptions): Promise<OrbitalSchema | {
+    error: string;
+}>;
+/** `behavior/dependencies`: a program's dependency graph — each orbital's imports, then every installed behavior they reach, with its layer and its own imports. */
+declare function behaviorDependencies(program: OrbitalSchema, opts: ProgramHostOptions): Promise<DependencyGraph>;
+declare function programStep(program: OrbitalSchema, requests: readonly StepRequest[], opts: ProgramHostOptions, live?: boolean): Promise<PlayedStep[] | {
+    error: string;
+}>;
+type EffectArg = JsonValue;
+/**
+ * Parse one program effect's positional arguments (the trailing emit config
+ * already removed) and run it. Both execution paths call this — the
+ * interpreter's effect executor and the compiled server handlers — so argument
+ * validation has one owner. Failures come back as data, never thrown.
+ */
+declare function runProgramEffect(op: ProgramEffectName, args: readonly EffectArg[], opts: ProgramHostOptions, context?: ProgramCallContext): Promise<ProgramEffectOutcome>;
+
+export { KvFailure, behaviorCatalog, behaviorCatalogSync, behaviorDependencies, behaviorDescribe, behaviorResolve, behaviorSource, createKvHost, createNodeOsHost, directoryKvBackend, initKernelSync, installNodeHostPorts, loadHttpKernel, loadInstalledKernel, loadKernelModule, loadNativeKernelModule, loadOrCreateDevMasterKey, memoryKvBackend, mountBehaviorValue, mountTraitValue, namespaceId, nativeMemoryOf, nodeCredentialScope, nodeNetPort, pinnedFetchNode, processAnchors, programCompose, programEval, programPrint, programRead, programResolve, programResolveSchema, programStep, programValidate, resolveHostNode, resolveNativeAddon, runProgramEffect, workspaceAccessError };
+export type { KvBackend, KvBatchOp, KvErrorKind, KvHost, KvNamespace, KvResult, KvScanEntry, KvTable, LoadKernelOptions, LoadedKernel, NodeOsHostOptions, ProgramCallContext, ProgramComposeOptions, ProgramEvalOptions, ProgramEvalResult, ProgramHostOptions };

package/dist/index.js

@@ -0,0 +1,217 @@
+export { OrbitalServerRuntime, UnresolvedProgramError, createOrbitalServerRuntime } from './chunk-A2TIXOLJ.js';
+export { createProgramHandlers } from './chunk-WZFQ7T7V.js';
+export { GCS_ENDPOINT, KernelProgram, WORKSPACE_HMAC_KEY_ID, WORKSPACE_HMAC_SECRET, createNodeOsHost, emitPayload, kernelWorkspaceHost, processAnchors, resolveKernelDir, resolveProgramFile, workspaceBucketFromEnv, workspacesRoot } from './chunk-BJA6GYC5.js';
+export { installNodeHostPorts, nodeCredentialScope, nodeNetPort, pinnedFetchNode, resolveHostNode } from './chunk-23YAOI6P.js';
+export { initKernelSync, loadHttpKernel, loadInstalledKernel, loadKernelModule, loadNativeKernelModule, nativeMemoryOf, resolveNativeAddon } from './chunk-UBZT5LDW.js';
+export { behaviorCatalog, behaviorCatalogSync, behaviorDependencies, behaviorDescribe, behaviorResolve, behaviorSource, mountBehaviorValue, mountTraitValue, programCompose, programEval, programPrint, programRead, programResolve, programResolveSchema, programStep, programValidate, runProgramEffect, workspaceAccessError } from './chunk-QYAPNUBH.js';
+export { installWorkspaceHost, installedWorkspaceHost, uninstallWorkspaceHost, workspaceOwnerSegment } from './chunk-BWMLDDCL.js';
+import { randomBytes } from 'crypto';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { mkdir, open, rename, rm, readFile } from 'fs/promises';
+
+var KEY_FILE = "dev-credential-master-key";
+var HEX_KEY = /^[0-9a-f]{64}$/;
+function loadOrCreateDevMasterKey(dir) {
+  if (process.env.NODE_ENV === "production") {
+    throw new Error("A generated dev master key is not permitted when NODE_ENV=production \u2014 set ALMADAR_CREDENTIAL_MASTER_KEY");
+  }
+  const path = join(dir, KEY_FILE);
+  if (existsSync(path)) {
+    const key2 = readFileSync(path, "utf8").trim();
+    if (!HEX_KEY.test(key2)) throw new Error(`${path} is malformed (expected 64 hex characters)`);
+    return key2;
+  }
+  mkdirSync(dir, { recursive: true });
+  const key = randomBytes(32).toString("hex");
+  writeFileSync(path, `${key}
+`, { mode: 384, flag: "wx" });
+  return key;
+}
+var KvFailure = class extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+  }
+  kind;
+};
+var LONE_SURROGATE = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
+var SEGMENT = /^[A-Za-z0-9._-]+$/;
+function namespaceId(ns) {
+  return `kv:${ns.app}:${ns.locale}:${ns.store}`;
+}
+function checkNamespace(ns) {
+  for (const [what, seg] of [["app", ns.app], ["locale", ns.locale], ["store", ns.store]]) {
+    if (!SEGMENT.test(seg) || seg === "." || seg === "..") throw new KvFailure("invalid", `kv ${what} name ${JSON.stringify(seg)} is not [A-Za-z0-9._-]+`);
+  }
+}
+function checkString(what, s) {
+  if (typeof s !== "string") throw new KvFailure("invalid", `kv ${what} must be a string`);
+  if (LONE_SURROGATE.test(s)) throw new KvFailure("invalid", `kv ${what} is not valid UTF-8`);
+  return s;
+}
+function checkJson(value, path) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new KvFailure("invalid", `kv value at ${path} is not a finite number`);
+    return value;
+  }
+  if (Array.isArray(value)) return value.map((item, i) => checkJson(item, `${path}[${i}]`));
+  if (typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) Object.defineProperty(out, k, { value: checkJson(v, `${path}.${k}`), enumerable: true, writable: true, configurable: true });
+    return out;
+  }
+  throw new KvFailure("invalid", `kv value at ${path} is not JSON`);
+}
+function byteCompare(a, b) {
+  return Buffer.compare(Buffer.from(a, "utf8"), Buffer.from(b, "utf8"));
+}
+function serialize(table) {
+  const keys = [...table.keys()].sort(byteCompare);
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${JSON.stringify(table.get(k))}`).join(",")}}`;
+}
+function parseTable(text) {
+  const parsed = JSON.parse(text);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) throw new KvFailure("io", "kv store file is not a JSON object");
+  const table = /* @__PURE__ */ new Map();
+  for (const [k, v] of Object.entries(parsed)) table.set(k, checkJson(v, k));
+  return table;
+}
+function memoryKvBackend() {
+  const tables = /* @__PURE__ */ new Map();
+  return {
+    async load(ns) {
+      return new Map(tables.get(namespaceId(ns)) ?? []);
+    },
+    async commit(ns, table) {
+      tables.set(namespaceId(ns), new Map(table));
+    }
+  };
+}
+function isErrno(e, code) {
+  return typeof e === "object" && e !== null && "code" in e && e.code === code;
+}
+function directoryKvBackend(stateDir) {
+  const fileOf = (ns) => {
+    const dir = join(stateDir, "kv", ns.app, ns.locale);
+    return { dir, file: join(dir, `${ns.store}.json`) };
+  };
+  return {
+    async load(ns) {
+      const { file } = fileOf(ns);
+      let text;
+      try {
+        text = await readFile(file, "utf8");
+      } catch (e) {
+        if (isErrno(e, "ENOENT")) return /* @__PURE__ */ new Map();
+        throw new KvFailure("io", `kv read failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+      try {
+        return parseTable(text);
+      } catch (e) {
+        if (e instanceof KvFailure) throw e;
+        throw new KvFailure("io", `kv store file is corrupt: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    },
+    async commit(ns, table) {
+      const { dir, file } = fileOf(ns);
+      const tmp = `${file}.tmp-${randomBytes(6).toString("hex")}`;
+      try {
+        await mkdir(dir, { recursive: true });
+        const handle = await open(tmp, "w");
+        try {
+          await handle.writeFile(serialize(table), "utf8");
+          await handle.sync();
+        } finally {
+          await handle.close();
+        }
+        await rename(tmp, file);
+      } catch (e) {
+        await rm(tmp, { force: true }).catch(() => void 0);
+        throw new KvFailure("io", `kv write failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+  };
+}
+function createKvHost(backend) {
+  const tails = /* @__PURE__ */ new Map();
+  const serialized = (ns, run) => {
+    const id = namespaceId(ns);
+    const next = (tails.get(id) ?? Promise.resolve()).then(run, run);
+    tails.set(id, next.catch(() => void 0));
+    return next;
+  };
+  const guard = async (run) => {
+    try {
+      return { ok: true, value: await run() };
+    } catch (e) {
+      if (e instanceof KvFailure) return { ok: false, error: e.message, kind: e.kind };
+      return { ok: false, error: e instanceof Error ? e.message : String(e), kind: "io" };
+    }
+  };
+  return {
+    get: (ns, key) => guard(async () => {
+      checkNamespace(ns);
+      checkString("key", key);
+      const table = await backend.load(ns);
+      const value = table.get(key);
+      return value === void 0 ? { found: false } : { found: true, value };
+    }),
+    put: (ns, key, value) => guard(() => {
+      checkNamespace(ns);
+      checkString("key", key);
+      const checked = checkJson(value, "value");
+      return serialized(ns, async () => {
+        const table = await backend.load(ns);
+        table.set(key, checked);
+        await backend.commit(ns, table);
+        return { storedKey: key };
+      });
+    }),
+    delete: (ns, key) => guard(() => {
+      checkNamespace(ns);
+      checkString("key", key);
+      return serialized(ns, async () => {
+        const table = await backend.load(ns);
+        const existed = table.delete(key);
+        if (existed) await backend.commit(ns, table);
+        return { existed };
+      });
+    }),
+    scan: (ns, prefix, limit) => guard(async () => {
+      checkNamespace(ns);
+      checkString("prefix", prefix);
+      if (limit !== void 0 && (!Number.isInteger(limit) || limit < 0)) throw new KvFailure("invalid", "kv scan limit must be a non-negative integer");
+      const table = await backend.load(ns);
+      const wanted = Buffer.from(prefix, "utf8");
+      const hits = [...table.keys()].filter((k) => Buffer.from(k, "utf8").subarray(0, wanted.length).equals(wanted)).sort(byteCompare);
+      const entries = [];
+      for (const key of limit === void 0 ? hits : hits.slice(0, limit)) {
+        const value = table.get(key);
+        if (value !== void 0) entries.push({ key, value });
+      }
+      return { entries };
+    }),
+    batch: (ns, ops) => guard(() => {
+      checkNamespace(ns);
+      const checked = ops.map((op, i) => {
+        const key = checkString(`batch op ${i} key`, op.key);
+        if (op.kind === "put") return { kind: "put", key, value: checkJson(op.value, `ops[${i}].value`) };
+        if (op.kind === "delete") return { kind: "delete", key };
+        throw new KvFailure("invalid", `kv batch op ${i} has unknown kind`);
+      });
+      return serialized(ns, async () => {
+        const table = await backend.load(ns);
+        for (const op of checked) {
+          if (op.kind === "put") table.set(op.key, op.value);
+          else table.delete(op.key);
+        }
+        await backend.commit(ns, table);
+        return { applied: checked.length };
+      });
+    })
+  };
+}
+
+export { KvFailure, createKvHost, directoryKvBackend, loadOrCreateDevMasterKey, memoryKvBackend, namespaceId };

package/dist/kernel-loader-24KWM5C7.js

@@ -0,0 +1 @@
+export { initKernelSync, loadHttpKernel, loadInstalledKernel, loadKernelModule, loadNativeKernelModule, nativeMemoryOf, resolveNativeAddon } from './chunk-UBZT5LDW.js';