@almadar/shell-runtime 0.0.0-stage → 0.1.0

package/dist/chunk-2JU7Y4KU.js

@@ -0,0 +1,21 @@
+import { findInbound, unknownHook, credentialUnset, inboundPayload, inboundAnswerOf, dispatchFailed } from '@almadar/core';
+
+// src/client/inbound-dispatch.ts
+async function dispatchInbound(schema, name, delivery, send, credential) {
+  const route = schema ? findInbound(schema, name) : void 0;
+  if (route === void 0) return unknownHook(name);
+  try {
+    const held = route.verifies !== void 0 ? await credential(route.verifies.credential) : void 0;
+    if (route.verifies !== void 0 && (held === void 0 || held === null || held === "")) return credentialUnset(route.verifies.credential);
+    const response = await send(route.orbital, {
+      event: route.event,
+      payload: inboundPayload(route, delivery, held),
+      targetTrait: route.trait
+    });
+    return inboundAnswerOf(route, response.emittedEvents, response.error);
+  } catch (error) {
+    return dispatchFailed(error instanceof Error ? error.message : String(error));
+  }
+}
+
+export { dispatchInbound };

package/dist/chunk-46RWK2B5.js

@@ -0,0 +1,28 @@
+// src/runtime/time/duration.ts
+function parseDurationString(interval) {
+  const match = interval.match(/^(\d+)(ms|s|m|h)?$/);
+  if (!match) {
+    throw new Error(
+      `Invalid duration '${interval}': expected a shape like '5ms'/'5s'/'1m'/'1h'`
+    );
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2] || "ms";
+  switch (unit) {
+    case "ms":
+      return value;
+    case "s":
+      return value * 1e3;
+    case "m":
+      return value * 60 * 1e3;
+    case "h":
+      return value * 60 * 60 * 1e3;
+    default:
+      return value;
+  }
+}
+function isValidDurationString(interval) {
+  return /^(\d+)(ms|s|m|h)?$/.test(interval);
+}
+
+export { isValidDurationString, parseDurationString };

package/dist/chunk-4J2QEIUV.js

@@ -0,0 +1,78 @@
+import { isEventResponse } from '@almadar/core/kernel-wire';
+import { createLogger } from '@almadar/logger';
+
+// src/kernel/frame-applier.ts
+var log = createLogger("almadar:shell-web:frame");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isList(value, item) {
+  return Array.isArray(value) && value.every(item);
+}
+function isSeed(value) {
+  return isRecord(value) && typeof value["trait"] === "string" && typeof value["event"] === "string";
+}
+function isRoutedLeg(value) {
+  if (!isRecord(value) || typeof value["orbital"] !== "string") return false;
+  const leg = value["leg"];
+  return isRecord(leg) && typeof leg["event"] === "string";
+}
+function isFiredTick(value) {
+  return isRecord(value) && typeof value["trait"] === "string" && typeof value["tick"] === "string";
+}
+function isFrameDispatch(value) {
+  if (!isRecord(value)) return false;
+  const response = value["response"];
+  return typeof value["trait"] === "string" && typeof value["orbital"] === "string" && isSeed(value["seed"]) && response !== void 0 && isEventResponse(response) && isList(value["serverLegs"], isRoutedLeg) && typeof value["mode"] === "string" && Array.isArray(value["awaiting"]) && Array.isArray(value["foldSeeded"]);
+}
+function isFrameWire(value) {
+  if (!isRecord(value)) return false;
+  const response = value["response"];
+  return isList(value["fired"], isFiredTick) && response !== void 0 && isEventResponse(response) && isList(value["dispatches"], isFrameDispatch) && isList(value["browserLegs"], isRoutedLeg) && typeof value["droppedServerEffects"] === "number" && isList(value["errors"], (entry) => typeof entry === "string");
+}
+function decodeFrame(json) {
+  if (json === void 0) return void 0;
+  const value = JSON.parse(json);
+  if (!isFrameWire(value)) throw new Error("kernel wire: frame is not a FrameWire");
+  return value;
+}
+var NOTHING = { fired: [], folded: 0, browserLegs: 0, droppedServerEffects: 0, outcomes: [], errors: [] };
+var settle = (posted, failure, trait) => posted.then(
+  (effects) => effects,
+  (err) => {
+    log.warn(failure, { trait, error: String(err) });
+    return void 0;
+  }
+);
+async function applyFrame(json, kernel, post) {
+  const frame = decodeFrame(json);
+  if (frame === void 0) return NOTHING;
+  for (const message of frame.errors) log.warn("frame-tick-failed", { error: message });
+  const last = frame.dispatches.length - 1;
+  await kernel.foldLocalResponse(frame.response, false, last < 0);
+  for (const [i, dispatch] of frame.dispatches.entries()) await kernel.foldLocalResponse(dispatch.response, true, i === last);
+  const outcomes = [{ response: frame.response, mode: "hybridClientOnly" }];
+  if (post !== void 0) {
+    for (const leg of frame.browserLegs) {
+      const tickSettled = settle(post.sendBrowserLeg(leg, frame.response), "tick-browser-leg-failed", leg.leg.targetTrait ?? "");
+      outcomes.push({ response: { success: true, transitioned: false, states: {}, emittedEvents: [] }, mode: "hybridClientOnly", tickSettled });
+    }
+  }
+  for (const dispatch of frame.dispatches) {
+    if (post === void 0 || dispatch.serverLegs.length === 0 && dispatch.statefulLeg === null) {
+      outcomes.push({ response: dispatch.response, mode: dispatch.mode });
+      continue;
+    }
+    outcomes.push({ response: dispatch.response, mode: dispatch.mode, tickSettled: settle(post.postDispatch(dispatch), "tick-post-failed", dispatch.trait) });
+  }
+  return {
+    fired: frame.fired,
+    folded: frame.dispatches.length + 1,
+    browserLegs: frame.browserLegs.length,
+    droppedServerEffects: frame.droppedServerEffects,
+    outcomes,
+    errors: frame.errors
+  };
+}
+
+export { applyFrame, decodeFrame, isFrameWire };

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-4ZICQ5PM.js

@@ -0,0 +1,192 @@
+import { isJsonObject } from '@almadar/core';
+
+// src/kernel/oauth-port.ts
+var PENDING_GRACE_MS = 60 * 60 * 1e3;
+var NO_CALLER = "a provider connection needs a signed-in caller";
+var NO_CONNECTIONS = "no OAuth connection store is installed on this host";
+var NO_TAKE = "this host keeps no derived secrets to take";
+var UNREADABLE = "a held OAuth credential is unreadable";
+var pendingName = (state) => `oauth:grant:${state}`;
+var connectionName = (provider) => `oauth:connection:${provider}`;
+function parseObject(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new Error(UNREADABLE);
+  }
+  if (!isJsonObject(value)) throw new Error(UNREADABLE);
+  return value;
+}
+function textOf(object, name) {
+  const value = object[name];
+  if (typeof value !== "string") throw new Error(UNREADABLE);
+  return value;
+}
+function textOrNull(object, name) {
+  const value = object[name];
+  if (value === void 0 || value === null) return null;
+  if (typeof value !== "string") throw new Error(UNREADABLE);
+  return value;
+}
+function textList(object, name) {
+  const value = object[name];
+  if (!Array.isArray(value)) throw new Error(UNREADABLE);
+  return value.map((item) => {
+    if (typeof item !== "string") throw new Error(UNREADABLE);
+    return item;
+  });
+}
+function objectOf(object, name) {
+  const value = object[name];
+  if (value === void 0 || !isJsonObject(value)) throw new Error(UNREADABLE);
+  return value;
+}
+function grantOf(object) {
+  return {
+    provider: textOf(object, "provider"),
+    redirectUri: textOf(object, "redirectUri"),
+    verifier: textOf(object, "verifier"),
+    subject: textOrNull(object, "subject"),
+    scopes: textList(object, "scopes")
+  };
+}
+function rowOf(object, provider) {
+  const connected = object.connected;
+  if (typeof connected !== "boolean") throw new Error(UNREADABLE);
+  return {
+    provider,
+    connected,
+    account: textOf(object, "account"),
+    avatarUrl: textOf(object, "avatarUrl"),
+    scope: textList(object, "scope"),
+    connectedAt: textOf(object, "connectedAt")
+  };
+}
+var disconnected = (provider) => ({ provider, connected: false, account: "", avatarUrl: "", scope: [], connectedAt: "" });
+function createOAuthPort(options) {
+  const secrets = () => typeof options.secrets === "function" ? options.secrets() : options.secrets;
+  const now = options.now ?? Date.now;
+  const subjects = /* @__PURE__ */ new Map();
+  const mockTokens = /* @__PURE__ */ new Map();
+  const mockRefresh = /* @__PURE__ */ new Map();
+  const metadata = /* @__PURE__ */ new Map();
+  const caller = (principal) => {
+    if (principal === void 0 || principal === "") throw new Error(NO_CALLER);
+    return principal;
+  };
+  const durable = async (held) => held.persist !== void 0 && held.durable !== void 0 && held.durable();
+  const take = async (held, name, principal) => {
+    if (held.take === void 0) throw new Error(NO_TAKE);
+    return held.take(name, principal);
+  };
+  return {
+    async answer(ask, principal) {
+      switch (ask.ask) {
+        case "pendingPut": {
+          const held = secrets();
+          const record = JSON.stringify({ grant: ask.grant, expiresAt: now() + ask.ttlMs });
+          if (held.hold !== void 0) await held.hold(pendingName(ask.state), record, ask.ttlMs + PENDING_GRACE_MS, void 0);
+          else await held.set(pendingName(ask.state), record, ask.ttlMs + PENDING_GRACE_MS, void 0);
+          return { reply: "done" };
+        }
+        case "pendingTake": {
+          const held = secrets();
+          const name = pendingName(ask.state);
+          const text = await take(held, name, void 0);
+          if (text === void 0) return { reply: "taken", taken: { found: "missing" } };
+          const record = parseObject(text);
+          const expiresAt = record.expiresAt;
+          if (typeof expiresAt !== "number") throw new Error(UNREADABLE);
+          if (expiresAt < now()) return { reply: "taken", taken: { found: "expired" } };
+          return { reply: "taken", taken: { found: "grant", grant: grantOf(objectOf(record, "grant")) } };
+        }
+        case "connectionAvailable":
+          return { reply: "flag", value: await durable(secrets()) };
+        case "connectionSave": {
+          const held = secrets();
+          if (held.persist === void 0 || !await durable(held)) throw new Error(NO_CONNECTIONS);
+          const who = caller(principal);
+          const row = {
+            provider: ask.provider,
+            connected: true,
+            account: ask.grant.subject ?? "",
+            avatarUrl: "",
+            scope: ask.grant.scope ?? [],
+            connectedAt: new Date(now()).toISOString()
+          };
+          await held.persist(connectionName(ask.provider), JSON.stringify({ row, grant: ask.grant }), who);
+          return { reply: "row", row };
+        }
+        case "connectionStatus": {
+          const text = await secrets().get(connectionName(ask.provider), caller(principal));
+          return { reply: "row", row: text === void 0 ? disconnected(ask.provider) : rowOf(objectOf(parseObject(text), "row"), ask.provider) };
+        }
+        case "connectionRemove":
+          await secrets().forget(connectionName(ask.provider), caller(principal));
+          return { reply: "row", row: disconnected(ask.provider) };
+        case "subjectRemember":
+          subjects.set(ask.accessToken, ask.subject);
+          return { reply: "done" };
+        case "subjectLookup":
+          return { reply: "subject", subject: subjects.get(ask.accessToken) ?? null };
+        case "subjectForget":
+          subjects.delete(ask.accessToken);
+          return { reply: "done" };
+        case "metadataGet":
+          return { reply: "metadata", metadata: metadata.get(ask.issuer) ?? null };
+        case "metadataPut":
+          metadata.set(ask.issuer, ask.metadata);
+          return { reply: "done" };
+        case "clock":
+          return { reply: "millis", value: now() };
+        case "consent":
+          return { reply: "code", code: options.consent === void 0 ? null : await options.consent({ authUrl: ask.authUrl, state: ask.state, redirectUri: ask.redirectUri }) };
+        case "mockTokenPut":
+          mockTokens.set(ask.accessToken, { refresh: ask.refreshToken, expiresAt: ask.expiresAtMs, provider: ask.provider });
+          mockRefresh.set(ask.refreshToken, { access: ask.accessToken, provider: ask.provider });
+          return { reply: "done" };
+        case "mockTokenRefresh": {
+          const old = mockRefresh.get(ask.refreshToken);
+          if (old === void 0) return { reply: "flag", value: false };
+          mockTokens.delete(old.access);
+          const sub = subjects.get(old.access);
+          subjects.delete(old.access);
+          if (sub !== void 0) subjects.set(ask.newAccessToken, sub);
+          mockTokens.set(ask.newAccessToken, { refresh: ask.refreshToken, expiresAt: ask.expiresAtMs, provider: old.provider });
+          mockRefresh.set(ask.refreshToken, { access: ask.newAccessToken, provider: old.provider });
+          return { reply: "flag", value: true };
+        }
+        case "mockTokenRevoke": {
+          const held = mockTokens.get(ask.token);
+          if (held !== void 0) {
+            mockTokens.delete(ask.token);
+            mockRefresh.delete(held.refresh);
+            subjects.delete(ask.token);
+            return { reply: "flag", value: true };
+          }
+          const issued = mockRefresh.get(ask.token);
+          if (issued !== void 0) {
+            mockRefresh.delete(ask.token);
+            mockTokens.delete(issued.access);
+            subjects.delete(issued.access);
+            return { reply: "flag", value: true };
+          }
+          return { reply: "flag", value: false };
+        }
+        case "mockTokenCheck": {
+          const held = mockTokens.get(ask.accessToken);
+          if (held === void 0) return { reply: "mockToken", state: "missing", provider: null };
+          if (now() > held.expiresAt) {
+            mockTokens.delete(ask.accessToken);
+            subjects.delete(ask.accessToken);
+            return { reply: "mockToken", state: "expired", provider: null };
+          }
+          return { reply: "mockToken", state: "valid", provider: held.provider };
+        }
+      }
+    }
+  };
+}
+
+export { PENDING_GRACE_MS, createOAuthPort };

package/dist/chunk-53IPZXDP.js

@@ -0,0 +1,76 @@
+// src/kernel/lane.ts
+var LaneHeldByParkedDispatch = class extends Error {
+  ticket;
+  event;
+  constructor(ticket, event) {
+    super(
+      `dispatch #${ticket} (${event}) is parked holding the dispatch lane on this thread; resume or drop it before starting another dispatch`
+    );
+    this.name = "LaneHeldByParkedDispatch";
+    this.ticket = ticket;
+    this.event = event;
+  }
+};
+var DispatchLane = class {
+  nextTicket = 0;
+  holder;
+  depth = 0;
+  parkedEvent;
+  waiters = [];
+  assertCanReenter(turn) {
+    if (this.holder === turn && this.parkedEvent !== void 0) throw new LaneHeldByParkedDispatch(turn.ticket, this.parkedEvent);
+  }
+  async enter(turn) {
+    const holder = this.holder;
+    if (holder !== void 0 && turn === holder) {
+      if (this.parkedEvent !== void 0) {
+        throw new LaneHeldByParkedDispatch(holder.ticket, this.parkedEvent);
+      }
+      this.depth += 1;
+      return this.guard(holder, false);
+    }
+    const own = { ticket: this.nextTicket };
+    this.nextTicket += 1;
+    if (this.holder === void 0) {
+      this.take(own);
+    } else {
+      await new Promise((grant) => {
+        this.waiters.push({ turn: own, grant });
+      });
+    }
+    return this.guard(own, true);
+  }
+  take(turn) {
+    this.holder = turn;
+    this.depth = 1;
+    this.parkedEvent = void 0;
+  }
+  guard(turn, outer) {
+    let done = false;
+    return {
+      turn,
+      park: (event) => {
+        if (!done && outer && this.holder === turn && this.depth === 1) this.parkedEvent = event;
+      },
+      resume: () => {
+        if (!done && outer && this.holder === turn) this.parkedEvent = void 0;
+      },
+      release: () => {
+        if (done) return;
+        done = true;
+        if (this.holder !== turn) return;
+        this.depth -= 1;
+        if (this.depth > 0) return;
+        this.holder = void 0;
+        this.parkedEvent = void 0;
+        const next = this.waiters.shift();
+        if (next !== void 0) {
+          this.take(next.turn);
+          next.grant();
+        }
+      }
+    };
+  }
+};
+
+export { DispatchLane, LaneHeldByParkedDispatch };

package/dist/chunk-5D63EMO5.js

@@ -0,0 +1,16 @@
+import { pipeBehaviors } from './chunk-FQ6IZMIU.js';
+import { composeBehaviors } from './chunk-ZCQUUJIF.js';
+import { detectLayoutStrategy } from './chunk-EV56K4GB.js';
+import { applyEventWiring } from './chunk-MHYSHSRG.js';
+import { __export } from './chunk-MLKGABMK.js';
+
+// src/runtime/effects/composition/index.ts
+var composition_exports = {};
+__export(composition_exports, {
+  applyEventWiring: () => applyEventWiring,
+  composeBehaviors: () => composeBehaviors,
+  detectLayoutStrategy: () => detectLayoutStrategy,
+  pipeBehaviors: () => pipeBehaviors
+});
+
+export { composition_exports };

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 };

package/dist/chunk-CPSQXEJ6.js

@@ -0,0 +1,55 @@
+import { parseOrbitalTraits } from './chunk-SAS5KKCR.js';
+import { findEntityAmongOrbitals, orbitalInlineEntities } from '@almadar/core';
+import { createLogger } from '@almadar/logger';
+
+var traitIndexLog = createLogger("almadar:runtime:trait-index");
+var parseCache = /* @__PURE__ */ new WeakMap();
+function parseOrbitalCached(orbital) {
+  let cached = parseCache.get(orbital);
+  if (cached === void 0) {
+    cached = { traits: parseOrbitalTraits(orbital), entities: orbitalInlineEntities(orbital) };
+    parseCache.set(orbital, cached);
+  }
+  return cached;
+}
+function buildTraitIndex(orbitals) {
+  const parsed = orbitals.map((orbital) => ({ orbital, parsed: parseOrbitalCached(orbital).traits }));
+  const allEntities = orbitals.map((orbital) => parseOrbitalCached(orbital).entities).flat();
+  const orbitalsView = parsed.map(({ orbital, parsed: p }) => ({ schema: orbital, entity: p.entity }));
+  const byName = /* @__PURE__ */ new Map();
+  for (const { orbital, parsed: p } of parsed) {
+    const { traits, inlineTraits, entity } = p;
+    for (let i = 0; i < traits.length; i++) {
+      const traitDef = traits[i];
+      const irTrait = inlineTraits[i];
+      const linkedEntityName = irTrait?.linkedEntity;
+      let traitEntity = entity;
+      if (linkedEntityName && linkedEntityName !== traitEntity.name) {
+        const resolved = findEntityAmongOrbitals(allEntities, linkedEntityName);
+        if (resolved) {
+          traitEntity = resolved;
+        } else {
+          traitIndexLog.warn("linkedEntity:unresolved", {
+            orbital: orbital.name,
+            trait: traitDef.name,
+            linkedEntityName
+          });
+          traitEntity = { name: linkedEntityName, fields: [] };
+        }
+      }
+      const isShared = traitEntity.shared === true;
+      byName.set(traitDef.name, {
+        traitDef,
+        irTrait,
+        entity: traitEntity,
+        orbitalName: orbital.name,
+        ...orbital.id !== void 0 ? { orbitalId: orbital.id } : {},
+        frameKey: isShared ? `$shared::${traitEntity.name}` : traitDef.name,
+        isSharedEntity: isShared
+      });
+    }
+  }
+  return { byName, allEntities, orbitals: orbitalsView };
+}
+
+export { buildTraitIndex };