@almadar/shell-runtime 0.0.0-stage → 1.0.0

package/dist/chunk-4SEK5ER2.js

@@ -0,0 +1,8 @@
+import { callRegisteredService } from './chunk-UBN5JJKZ.js';
+
+// src/service/default-call-service.ts
+function defaultCallService(service, action, params, context) {
+  return callRegisteredService(service, action, params, context);
+}
+
+export { defaultCallService };

package/dist/chunk-57SBCUSM.js

@@ -0,0 +1,62 @@
+// src/loader/fetch-loader.ts
+var FetchSchemaLoader = class {
+  /** `base`: the URL relative imports resolve against when no importer is named (the page's own URL by default). */
+  constructor(base) {
+    this.base = base;
+  }
+  base;
+  cache = /* @__PURE__ */ new Map();
+  resolvePath(importPath, fromPath) {
+    try {
+      return { success: true, data: new URL(importPath, new URL(fromPath ?? this.base, this.base)).href };
+    } catch (error) {
+      return { success: false, error: `Cannot resolve ${importPath}${fromPath !== void 0 ? ` from ${fromPath}` : ""}: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }
+  load(importPath, fromPath) {
+    const resolved = this.resolvePath(importPath, fromPath);
+    if (!resolved.success) return Promise.resolve(resolved);
+    const url = resolved.data;
+    const held = this.cache.get(url);
+    if (held !== void 0) return held;
+    const loading = fetchSchema(url, importPath);
+    loading.then((result) => {
+      if (!result.success) this.cache.delete(url);
+    }, () => this.cache.delete(url));
+    this.cache.set(url, loading);
+    return loading;
+  }
+  async loadOrbital(importPath, orbitalName, fromPath) {
+    const loaded = await this.load(importPath, fromPath);
+    if (!loaded.success) return loaded;
+    const { schema, sourcePath } = loaded.data;
+    const orbital = orbitalName === void 0 ? schema.orbitals[0] : schema.orbitals.find((o) => o.name === orbitalName);
+    if (orbital === void 0) {
+      return { success: false, error: `${sourcePath} has no orbital ${orbitalName ?? "(none)"}; found: ${schema.orbitals.map((o) => o.name).join(", ")}` };
+    }
+    return { success: true, data: { orbital, orbitals: schema.orbitals, sourcePath, importPath } };
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  getCacheStats() {
+    return { size: this.cache.size };
+  }
+};
+async function fetchSchema(url, importPath) {
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    return { success: false, error: `${url}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  if (!response.ok) return { success: false, error: `${url}: ${response.status} ${response.statusText}` };
+  try {
+    const schema = await response.json();
+    return { success: true, data: { schema, sourcePath: url, importPath } };
+  } catch (error) {
+    return { success: false, error: `${url} is not a program: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+
+export { FetchSchemaLoader };

package/dist/chunk-625EP7W2.js

@@ -0,0 +1,108 @@
+import { base64Standard } from './chunk-ZUSM4VW4.js';
+
+// src/kernel/os-fetch-port.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var fail = (kind, message) => ({ error: { kind, message: `os/fetch: ${message}` } });
+function bytesOf(base64) {
+  const text = atob(base64);
+  const bytes = new Uint8Array(text.length);
+  for (let i = 0; i < text.length; i += 1) bytes[i] = text.charCodeAt(i);
+  return bytes;
+}
+function headersOf(value) {
+  const headers = new Headers();
+  if (value === void 0) return headers;
+  if (!Array.isArray(value)) return "headers must be a list of { name, value }";
+  for (const header of value) {
+    if (!isRecord(header) || typeof header.name !== "string" || typeof header.value !== "string") return "headers must be a list of { name, value }";
+    headers.append(header.name, header.value);
+  }
+  return headers;
+}
+var failed = (kind, op, message) => ({ error: { kind, message: `${op}: ${message}` } });
+function createFetchOsHost(performFetch) {
+  const pending = /* @__PURE__ */ new Set();
+  const bodies = /* @__PURE__ */ new Map();
+  let nextHandle = 1;
+  const openOf = (op, handle) => {
+    const open = typeof handle === "number" ? bodies.get(handle) : void 0;
+    return open ?? failed("closed", op, "the handle is not an open streamed response");
+  };
+  async function receive(args) {
+    const open = openOf("os/recv", args[0]);
+    if (!("reader" in open)) return open;
+    const count = args[1];
+    if (typeof count !== "number" || !Number.isInteger(count) || count < 1) return failed("invalid", "os/recv", "the count must be a positive integer");
+    try {
+      if (open.held.length === 0) {
+        const next = await open.reader.read();
+        if (next.done) return { ok: { data: base64Standard(new Uint8Array(0)), eof: true } };
+        open.held = next.value;
+      }
+      const data = open.held.subarray(0, count);
+      open.held = open.held.subarray(count);
+      return { ok: { data: base64Standard(data), eof: false } };
+    } catch (raised) {
+      return failed("io", "os/recv", raised instanceof Error ? raised.message : "the response body failed");
+    }
+  }
+  async function release(args) {
+    const open = openOf("os/close", args[0]);
+    if (!("reader" in open)) return open;
+    if (typeof args[0] === "number") bodies.delete(args[0]);
+    pending.delete(open.control);
+    open.control.abort();
+    await open.reader.cancel().catch(() => void 0);
+    return { ok: {} };
+  }
+  return {
+    async answer(op, args) {
+      if (op === "os/recv") return receive(args);
+      if (op === "os/close") return release(args);
+      if (op !== "os/fetch") return { error: { kind: "unsupported", message: `${op}: a browser host answers only os/fetch, and os/recv and os/close on the handle of a streamed one` } };
+      const [method, url, request] = args;
+      if (typeof method !== "string" || typeof url !== "string") return fail("invalid", "the method and the url must be text");
+      if (request !== void 0 && !isRecord(request)) return fail("invalid", "the request must be { headers?, body?, timeoutMs?, stream? }");
+      const headers = headersOf(request?.headers);
+      if (typeof headers === "string") return fail("invalid", headers);
+      const body = request?.body;
+      if (body !== void 0 && typeof body !== "string") return fail("invalid", "the body must be bytes");
+      const timeoutMs = request?.timeoutMs;
+      if (timeoutMs !== void 0 && (typeof timeoutMs !== "number" || !(timeoutMs > 0))) return fail("invalid", "timeoutMs must be a positive number");
+      const stream = request?.stream;
+      if (stream !== void 0 && typeof stream !== "boolean") return fail("invalid", "stream must be a boolean");
+      const control = new AbortController();
+      pending.add(control);
+      const timer = typeof timeoutMs === "number" ? setTimeout(() => control.abort(), timeoutMs) : void 0;
+      let kept = false;
+      try {
+        const response = await performFetch(url, { method, headers, signal: control.signal, ...body !== void 0 ? { body: bytesOf(body) } : {} });
+        const received = [];
+        response.headers.forEach((value, name) => received.push({ name, value }));
+        if (stream === true) {
+          const handle = nextHandle;
+          nextHandle += 1;
+          const reader = (response.body ?? new ReadableStream({ start: (sink) => sink.close() })).getReader();
+          bodies.set(handle, { reader, control, held: new Uint8Array(0) });
+          kept = true;
+          return { ok: { status: response.status, headers: received, body: base64Standard(new Uint8Array(0)), handle } };
+        }
+        return { ok: { status: response.status, headers: received, body: base64Standard(new Uint8Array(await response.arrayBuffer())) } };
+      } catch (raised) {
+        if (control.signal.aborted) return fail("timeout", `no answer within ${String(timeoutMs)} ms`);
+        return fail("io", raised instanceof Error ? raised.message : "the fetch failed");
+      } finally {
+        if (timer !== void 0) clearTimeout(timer);
+        if (!kept) pending.delete(control);
+      }
+    },
+    close() {
+      for (const control of pending) control.abort();
+      pending.clear();
+      for (const open of bodies.values()) void open.reader.cancel().catch(() => void 0);
+      bodies.clear();
+    }
+  };
+}
+
+export { createFetchOsHost };

package/dist/chunk-64IH2SMY.js

@@ -0,0 +1,22 @@
+// src/events/emit-stamp.ts
+function stampEmitSource(source, identity) {
+  const stamp = source ?? {
+    orbital: identity.orbitalName,
+    trait: identity.traitName
+  };
+  if (stamp.orbitalId === void 0 && identity.orbitalId !== void 0) {
+    stamp.orbitalId = identity.orbitalId;
+  }
+  if (stamp.traitId === void 0 && identity.traitId !== void 0) {
+    stamp.traitId = identity.traitId;
+  }
+  if (stamp.eventId === void 0 && identity.emitContractEventId !== void 0) {
+    stamp.eventId = identity.emitContractEventId;
+  }
+  if (identity.originClientId !== void 0 && stamp.originClientId === void 0) {
+    stamp.originClientId = identity.originClientId;
+  }
+  return stamp;
+}
+
+export { stampEmitSource };

package/dist/chunk-7SDV3QWR.js

@@ -0,0 +1,67 @@
+import { EntityRowSchema, RowWriteOutcomeSchema, RowQueryPageSchema, RowIdPageSchema, QueryCapabilitiesSchema, WriteCapabilitiesSchema, JsonValueSchema, isJsonObject } from '@almadar/core';
+
+// src/persistence/native-memory.ts
+var NativeMemoryWriteError = class extends Error {
+  constructor(outcome) {
+    super(`native memory update failed: ${outcome.kind}`);
+    this.outcome = outcome;
+    this.name = "NativeMemoryWriteError";
+  }
+  outcome;
+};
+var NativeMemoryPersistenceAdapter = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async getById(entityType, id) {
+    return EntityRowSchema.nullable().parse(JSON.parse(this.store.getById(entityType, id)));
+  }
+  async list(entityType) {
+    return EntityRowSchema.array().parse(JSON.parse(this.store.list(entityType)));
+  }
+  // The kernel's plain create merges a supplied existing id; writeWhere exposes strict create and replacement upsert.
+  async create(entityType, data) {
+    const row = EntityRowSchema.parse(JSON.parse(this.store.create(entityType, JSON.stringify(data))));
+    if (typeof row.id !== "string") throw new Error("native memory create returned a row without an id");
+    return { id: row.id };
+  }
+  async update(entityType, id, data) {
+    const outcome = RowWriteOutcomeSchema.parse(JSON.parse(this.store.update(entityType, id, JSON.stringify(data))));
+    if (outcome.kind !== "updated") throw new NativeMemoryWriteError(outcome);
+  }
+  async delete(entityType, id) {
+    this.store.delete(entityType, id);
+  }
+  async queryPage(entityType, query) {
+    return RowQueryPageSchema.parse(JSON.parse(this.store.queryPage(entityType, JSON.stringify(query))));
+  }
+  async queryIds(entityType, query) {
+    return RowIdPageSchema.parse(JSON.parse(this.store.queryIds(entityType, JSON.stringify(query))));
+  }
+  queryCapabilities(_entityType) {
+    return QueryCapabilitiesSchema.parse(JSON.parse(this.store.queryCapabilities()));
+  }
+  async writeWhere(op) {
+    return RowWriteOutcomeSchema.parse(JSON.parse(this.store.writeWhere(JSON.stringify(op))));
+  }
+  async writeBatch(batch) {
+    return RowWriteOutcomeSchema.array().parse(JSON.parse(this.store.writeBatch(JSON.stringify(batch))));
+  }
+  writeCapabilities(_entityType) {
+    return WriteCapabilitiesSchema.parse(JSON.parse(this.store.writeCapabilities()));
+  }
+  bindCollection(entityType, collection) {
+    this.store.bindCollection(entityType, collection);
+  }
+  clear() {
+    this.store.clear();
+  }
+  snapshot() {
+    const value = JsonValueSchema.parse(JSON.parse(this.store.snapshot()));
+    if (!isJsonObject(value)) throw new Error("native memory snapshot returned a non-object");
+    return Object.fromEntries(Object.entries(value).map(([key, rows]) => [key, EntityRowSchema.array().parse(rows)]));
+  }
+};
+
+export { NativeMemoryPersistenceAdapter, NativeMemoryWriteError };