@almadar/shell-runtime 0.1.0 → 1.1.0

package/dist/chunk-4ZICQ5PM.js

@@ -1,192 +0,0 @@
-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

@@ -1,76 +0,0 @@
-// 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

@@ -1,16 +0,0 @@
-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-CPSQXEJ6.js

@@ -1,55 +0,0 @@
-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 };

package/dist/chunk-CQP5XAX6.js

@@ -1,173 +0,0 @@
-import { parseCron, cronMinuteKey, cronMatches } from './chunk-CROS2GEX.js';
-
-// src/runtime/time/TickScheduler.ts
-var EVERY_PASS = 0;
-var CRON_CHECK_INTERVAL_MS = 1e3;
-var TickScheduler = class {
-  ticks = /* @__PURE__ */ new Map();
-  nextId = 1;
-  running = false;
-  paused = false;
-  frameHandle = null;
-  hasRaf;
-  constructor() {
-    this.hasRaf = typeof requestAnimationFrame === "function" && typeof cancelAnimationFrame === "function";
-  }
-  /**
-   * Register a tick. `intervalMs <= 0` means "every pass" (a frame-interval
-   * tick, matching LOLO's `interval: "frame"`). Returns a handle to stop
-   * just this tick.
-   */
-  add(intervalMs, onDue) {
-    const id = this.nextId++;
-    this.ticks.set(id, {
-      kind: "interval",
-      intervalMs: intervalMs > 0 ? intervalMs : EVERY_PASS,
-      accumulatedMs: 0,
-      lastTimestamp: null,
-      onDue
-    });
-    this.ensureRunning();
-    return {
-      stop: () => {
-        this.ticks.delete(id);
-        this.maybeStop();
-      }
-    };
-  }
-  /**
-   * Register a cron-scheduled tick (`ticks { ... every "0 9 * * *" }`).
-   * Fires at most once per matching calendar minute. Throws if `expression` isn't a valid 5-field cron
-   * string; callers on a path the compiler has already validated (e.g.
-   * generated code) won't hit this, but a raw runtime value might.
-   */
-  addCron(expression, onDue) {
-    const fields = parseCron(expression);
-    const id = this.nextId++;
-    this.ticks.set(id, {
-      kind: "cron",
-      fields,
-      accumulatedMs: CRON_CHECK_INTERVAL_MS,
-      // check on the first pass, not after a full second
-      lastTimestamp: null,
-      lastFiredMinuteKey: -1,
-      onDue
-    });
-    this.ensureRunning();
-    return {
-      stop: () => {
-        this.ticks.delete(id);
-        this.maybeStop();
-      }
-    };
-  }
-  /** Stop every tick and the shared loop. */
-  stopAll() {
-    this.ticks.clear();
-    this.maybeStop();
-  }
-  /** True while the scheduler is paused (no tick callback fires and no backlog accumulates). */
-  get isPaused() {
-    return this.paused;
-  }
-  /**
-   * Halt the shared loop without dropping registered ticks. No `onDue`
-   * fires again until `resume()`. A no-op if already paused.
-   */
-  pause() {
-    if (this.paused) return;
-    this.paused = true;
-    this.stopLoop();
-  }
-  /**
-   * Restart the shared loop after `pause()`. Every registered tick's phase
-   * is reset (`lastTimestamp = null`) so the paused duration is never
-   * counted as elapsed time — the same "first pass just captures the
-   * timestamp" behavior a freshly `add()`-ed tick gets, which is what keeps
-   * resume from bursting a backlog of missed beats. A no-op if not paused.
-   */
-  resume() {
-    if (!this.paused) return;
-    this.paused = false;
-    for (const tick of this.ticks.values()) {
-      tick.lastTimestamp = null;
-    }
-    if (this.ticks.size > 0) {
-      this.ensureRunning();
-    }
-  }
-  ensureRunning() {
-    if (this.running || this.paused) return;
-    this.running = true;
-    if (this.hasRaf) {
-      const loop = (timestamp) => {
-        if (!this.running) return;
-        this.advance(timestamp);
-        this.frameHandle = requestAnimationFrame(loop);
-      };
-      this.frameHandle = requestAnimationFrame(loop);
-    } else {
-      this.frameHandle = setInterval(() => this.advance(Date.now()), 16);
-    }
-  }
-  maybeStop() {
-    if (this.ticks.size > 0 || !this.running) return;
-    this.stopLoop();
-  }
-  /** Cancel the active rAF/interval loop, if any, and clear the running flag. */
-  stopLoop() {
-    this.running = false;
-    if (this.frameHandle !== null) {
-      if (this.hasRaf) {
-        cancelAnimationFrame(this.frameHandle);
-      } else {
-        clearInterval(this.frameHandle);
-      }
-      this.frameHandle = null;
-    }
-  }
-  advance(timestamp) {
-    for (const tick of this.ticks.values()) {
-      if (tick.kind === "cron") {
-        this.advanceCron(tick, timestamp);
-        continue;
-      }
-      if (tick.intervalMs <= EVERY_PASS) {
-        tick.onDue();
-        continue;
-      }
-      if (tick.lastTimestamp === null) {
-        tick.lastTimestamp = timestamp;
-        continue;
-      }
-      tick.accumulatedMs += timestamp - tick.lastTimestamp;
-      tick.lastTimestamp = timestamp;
-      if (tick.accumulatedMs >= tick.intervalMs) {
-        tick.onDue();
-        tick.accumulatedMs = tick.accumulatedMs % tick.intervalMs;
-      }
-    }
-  }
-  /** Cron ticks check calendar-match at most once a second, deduped per matching minute. */
-  advanceCron(tick, timestamp) {
-    if (tick.lastTimestamp === null) {
-      tick.lastTimestamp = timestamp;
-      return;
-    }
-    tick.accumulatedMs += timestamp - tick.lastTimestamp;
-    tick.lastTimestamp = timestamp;
-    if (tick.accumulatedMs < CRON_CHECK_INTERVAL_MS) return;
-    tick.accumulatedMs = 0;
-    const now = /* @__PURE__ */ new Date();
-    const minuteKey = cronMinuteKey(now);
-    if (minuteKey !== tick.lastFiredMinuteKey && cronMatches(tick.fields, now)) {
-      tick.lastFiredMinuteKey = minuteKey;
-      tick.onDue();
-    }
-  }
-};
-function createTickScheduler() {
-  return new TickScheduler();
-}
-
-export { TickScheduler, createTickScheduler };

package/dist/chunk-CROS2GEX.js

@@ -1,49 +0,0 @@
-// src/runtime/time/cron.ts
-function parseCronField(field, min, max) {
-  const values = /* @__PURE__ */ new Set();
-  for (const part of field.split(",")) {
-    if (part === "*") {
-      for (let i = min; i <= max; i++) values.add(i);
-    } else if (part.includes("/")) {
-      const [range, stepStr] = part.split("/");
-      const step = parseInt(stepStr, 10);
-      const start = range === "*" ? min : parseInt(range, 10);
-      for (let i = start; i <= max; i += step) values.add(i);
-    } else if (part.includes("-")) {
-      const [lo, hi] = part.split("-").map(Number);
-      for (let i = lo; i <= hi; i++) values.add(i);
-    } else {
-      values.add(parseInt(part, 10));
-    }
-  }
-  return values;
-}
-function parseCron(expression) {
-  const parts = expression.trim().split(/\s+/);
-  if (parts.length !== 5) {
-    throw new Error(`Invalid cron expression (expected 5 fields): ${expression}`);
-  }
-  return {
-    minute: parseCronField(parts[0], 0, 59),
-    hour: parseCronField(parts[1], 0, 23),
-    day: parseCronField(parts[2], 1, 31),
-    month: parseCronField(parts[3], 1, 12),
-    weekday: parseCronField(parts[4], 0, 6)
-  };
-}
-function isValidCronExpression(expression) {
-  try {
-    parseCron(expression);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function cronMatches(fields, date) {
-  return fields.minute.has(date.getMinutes()) && fields.hour.has(date.getHours()) && fields.day.has(date.getDate()) && fields.month.has(date.getMonth() + 1) && fields.weekday.has(date.getDay());
-}
-function cronMinuteKey(date) {
-  return date.getFullYear() * 1e8 + date.getMonth() * 1e6 + date.getDate() * 1e4 + date.getHours() * 100 + date.getMinutes();
-}
-
-export { cronMatches, cronMinuteKey, isValidCronExpression, parseCron, parseCronField };