@almadar/shell-runtime 0.1.0 → 1.0.0

package/dist/chunk-D5USD2EX.js

@@ -1,232 +0,0 @@
-import { createHttpTransport } from './chunk-QELZ6TEJ.js';
-import { createLogger } from '@almadar/logger';
-
-var log = createLogger("almadar:runtime:server-bridge");
-var ServerBridge = class {
-  config;
-  state = {
-    connected: false,
-    eventsForwarded: 0,
-    eventsReceived: 0
-  };
-  unsubscribes = [];
-  pollTimer;
-  ws;
-  fetchFn;
-  /** The one HTTP request/response leg — shared with `@almadar/ui`'s transport (P5, EventTransport.ts). */
-  transport;
-  constructor(config) {
-    this.config = {
-      pollInterval: 5e3,
-      ...config
-    };
-    this.fetchFn = config.fetch || fetch.bind(globalThis);
-    this.transport = createHttpTransport({ serverUrl: config.serverUrl, fetch: this.fetchFn });
-  }
-  // ==========================================================================
-  // Connection Management
-  // ==========================================================================
-  /**
-   * Connect the bridge - start forwarding events
-   */
-  connect() {
-    if (this.state.connected) {
-      this.log("warn", "Already connected");
-      return;
-    }
-    this.log("info", "Connecting bridge...");
-    this.setupEventForwarding();
-    if (this.config.useWebSocket) {
-      this.setupWebSocket();
-    } else if (this.config.pollInterval && this.config.pollInterval > 0) {
-      this.setupPolling();
-    }
-    this.state.connected = true;
-    this.log("info", "Bridge connected");
-  }
-  /**
-   * Disconnect the bridge
-   */
-  disconnect() {
-    for (const unsub of this.unsubscribes) {
-      unsub();
-    }
-    this.unsubscribes = [];
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = void 0;
-    }
-    if (this.ws) {
-      this.ws.close();
-      this.ws = void 0;
-    }
-    this.state.connected = false;
-    this.log("info", "Bridge disconnected");
-  }
-  /**
-   * Get current bridge state
-   */
-  getState() {
-    return { ...this.state };
-  }
-  // ==========================================================================
-  // Event Forwarding (Client -> Server)
-  // ==========================================================================
-  setupEventForwarding() {
-    const { eventBus, forwardEvents, forwardPattern } = this.config;
-    if (forwardEvents && forwardEvents.length > 0) {
-      for (const eventType of forwardEvents) {
-        const unsub = eventBus.on(eventType, (event) => {
-          this.forwardToServer(event);
-        });
-        this.unsubscribes.push(unsub);
-      }
-    } else if (forwardPattern) {
-      if (forwardPattern === "*") {
-        const unsub = eventBus.on("*", (event) => {
-          if (!event.type.startsWith("UI:") && !event.type.startsWith("BRIDGE:")) {
-            this.forwardToServer(event);
-          }
-        });
-        this.unsubscribes.push(unsub);
-      } else {
-        const prefix = forwardPattern.replace("*", "");
-        const unsub = eventBus.on("*", (event) => {
-          if (event.type.startsWith(prefix)) {
-            this.forwardToServer(event);
-          }
-        });
-        this.unsubscribes.push(unsub);
-      }
-    }
-  }
-  async forwardToServer(event) {
-    const { serverUrl, targetOrbital } = this.config;
-    try {
-      if (targetOrbital && targetOrbital !== "broadcast") {
-        await this.sendEventToOrbital(targetOrbital, event);
-      } else {
-        const orbitals = await this.fetchOrbitals();
-        for (const orbital of orbitals) {
-          await this.sendEventToOrbital(orbital.name, event);
-        }
-      }
-      this.state.eventsForwarded++;
-      this.log("debug", `Forwarded event: ${event.type}`);
-    } catch (error) {
-      this.state.lastError = String(error);
-      this.log("error", `Failed to forward event: ${event.type}`, error instanceof Error ? error : String(error));
-    }
-  }
-  async sendEventToOrbital(orbitalName, event) {
-    const request = { event: event.type, payload: event.payload };
-    const result = await this.transport.send(orbitalName, request);
-    if (result.emittedEvents && result.emittedEvents.length > 0) {
-      for (const emitted of result.emittedEvents) {
-        this.config.eventBus.emit(`SERVER:${emitted.event}`, emitted.payload);
-        this.state.eventsReceived++;
-      }
-    }
-  }
-  async fetchOrbitals() {
-    const response = await this.fetchFn(this.config.serverUrl);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch orbitals: ${response.status}`);
-    }
-    const data = await response.json();
-    return data.orbitals || [];
-  }
-  // ==========================================================================
-  // Server -> Client (Polling)
-  // ==========================================================================
-  setupPolling() {
-    this.log("debug", "Polling mode - events received via forward response");
-  }
-  // ==========================================================================
-  // Server -> Client (WebSocket)
-  // ==========================================================================
-  setupWebSocket() {
-    const { serverUrl } = this.config;
-    const wsUrl = serverUrl.replace(/^http:/, "ws:").replace(/^https:/, "wss:").replace(/\/api\/orbitals$/, "/ws/orbitals");
-    try {
-      this.ws = new WebSocket(wsUrl);
-      this.ws.onopen = () => {
-        this.log("info", "WebSocket connected");
-      };
-      this.ws.onmessage = (msg) => {
-        try {
-          const data = JSON.parse(msg.data);
-          if (data.type === "event") {
-            this.config.eventBus.emit(`SERVER:${data.event}`, data.payload);
-            this.state.eventsReceived++;
-            this.log("debug", `Received server event: ${data.event}`);
-          }
-        } catch (error) {
-          this.log("error", "Failed to parse WebSocket message", error instanceof Error ? error : String(error));
-        }
-      };
-      this.ws.onerror = (error) => {
-        this.state.lastError = "WebSocket error";
-        this.log("error", "WebSocket error", error);
-      };
-      this.ws.onclose = () => {
-        this.log("info", "WebSocket closed");
-      };
-    } catch (error) {
-      this.log("error", "Failed to create WebSocket", error instanceof Error ? error : String(error));
-    }
-  }
-  // ==========================================================================
-  // Direct Methods
-  // ==========================================================================
-  /**
-   * Send an event directly to a specific orbital (bypassing EventBus)
-   */
-  async sendEvent(orbitalName, event, payload) {
-    try {
-      const result = await this.transport.send(orbitalName, { event, payload });
-      return {
-        success: result.success,
-        states: result.states,
-        emittedEvents: result.emittedEvents,
-        error: result.error
-      };
-    } catch (error) {
-      return { success: false, error: String(error) };
-    }
-  }
-  /**
-   * Get current state of an orbital's traits
-   */
-  async getOrbitalState(orbitalName) {
-    const { serverUrl } = this.config;
-    const url = `${serverUrl}/${orbitalName}`;
-    try {
-      const response = await this.fetchFn(url);
-      const data = await response.json();
-      if (data.success && data.orbital) {
-        const states = {};
-        for (const trait of data.orbital.traits) {
-          states[trait.name] = trait.currentState;
-        }
-        return { success: true, states };
-      }
-      return { success: false, error: data.error };
-    } catch (error) {
-      return { success: false, error: String(error) };
-    }
-  }
-  // ==========================================================================
-  // Utilities
-  // ==========================================================================
-  log(level, message, data) {
-    if (!this.config.debug && level === "debug") return;
-    const meta = data === void 0 ? {} : data instanceof Error ? { error: data } : { detail: typeof data === "string" ? data : JSON.stringify(data) };
-    log[level](message, meta);
-  }
-};
-function createServerBridge(config) {
-  return new ServerBridge(config);
-}
-
-export { ServerBridge, createServerBridge };

package/dist/chunk-EV56K4GB.js

@@ -1,63 +0,0 @@
-// src/runtime/effects/composition/layout-strategy.ts
-function hasSequentialChain(wiring) {
-  if (wiring.length < 2) {
-    return false;
-  }
-  const adjacency = /* @__PURE__ */ new Map();
-  const allTargets = /* @__PURE__ */ new Set();
-  for (const entry of wiring) {
-    let targets = adjacency.get(entry.from);
-    if (!targets) {
-      targets = /* @__PURE__ */ new Set();
-      adjacency.set(entry.from, targets);
-    }
-    targets.add(entry.to);
-    allTargets.add(entry.to);
-  }
-  const roots = [];
-  for (const from of adjacency.keys()) {
-    if (!allTargets.has(from)) {
-      roots.push(from);
-    }
-  }
-  const starts = roots.length > 0 ? roots : [...adjacency.keys()];
-  for (const start of starts) {
-    let current = start;
-    let length = 1;
-    const visited = /* @__PURE__ */ new Set([current]);
-    while (true) {
-      const nexts = adjacency.get(current);
-      if (!nexts || nexts.size === 0) break;
-      let advanced = false;
-      for (const next of nexts) {
-        if (!visited.has(next)) {
-          visited.add(next);
-          current = next;
-          length++;
-          advanced = true;
-          break;
-        }
-      }
-      if (!advanced) break;
-    }
-    if (length >= 3) {
-      return true;
-    }
-  }
-  return false;
-}
-function detectLayoutStrategy(orbitals, eventWiring) {
-  if (eventWiring && eventWiring.length > 0 && hasSequentialChain(eventWiring)) {
-    return "wizard-flow";
-  }
-  const count = orbitals.length;
-  if (count <= 1) {
-    return "single";
-  }
-  if (count <= 4) {
-    return "tabs";
-  }
-  return "sidebar";
-}
-
-export { detectLayoutStrategy };

package/dist/chunk-FQ6IZMIU.js

@@ -1,10 +0,0 @@
-// src/runtime/effects/composition/pipe.ts
-function pipeBehaviors(seed, ...steps) {
-  let current = seed;
-  for (const step of steps) {
-    current = step(current);
-  }
-  return current;
-}
-
-export { pipeBehaviors };

package/dist/chunk-HMK6YMQS.js

@@ -1,135 +0,0 @@
-import { eventPayloadOf, isInlineTrait, normalizeCallSiteConfigToValues, JsonValueSchema, isJsonObject, EntityRowSchema, orbitalInlineEntities } from '@almadar/core';
-import { ownerFieldsFromSchema } from '@almadar/core/mock';
-
-// src/runtime/entities/std-mock-seed.ts
-var SEED_ORBITAL = "MockSeedOrbital";
-var SEED_TRAIT = "MockSeed";
-function asJson(value) {
-  return JsonValueSchema.parse(JSON.parse(JSON.stringify(value)));
-}
-function fieldOf(value, name, what) {
-  if (value === void 0 || !isJsonObject(value)) throw new Error(`std-mock-seed: ${what} is not an object`);
-  const found = value[name];
-  if (found === void 0) throw new Error(`std-mock-seed: ${what} has no ${name}`);
-  return found;
-}
-function textOf(value, what) {
-  if (typeof value !== "string") throw new Error(`std-mock-seed: ${what} is not a string`);
-  return value;
-}
-function cellOf(value) {
-  return {
-    store: textOf(fieldOf(value, "store", "owner cell"), "cell store"),
-    id: textOf(fieldOf(value, "id", "owner cell"), "cell id"),
-    column: textOf(fieldOf(value, "column", "owner cell"), "cell column")
-  };
-}
-function cellsOf(value, what) {
-  if (!Array.isArray(value)) throw new Error(`std-mock-seed: ${what} is not an array`);
-  return value.map(cellOf);
-}
-function journalOf(value) {
-  return {
-    viewerId: textOf(fieldOf(value, "viewerId", "journal"), "journal viewerId"),
-    stamped: cellsOf(fieldOf(value, "stamped", "journal"), "journal stamped"),
-    deferred: cellsOf(fieldOf(value, "deferred", "journal"), "journal deferred")
-  };
-}
-function changeOf(value) {
-  const kind = fieldOf(value, "kind", "owner change");
-  if (kind !== "set" && kind !== "rekey") throw new Error("std-mock-seed: owner change kind is neither set nor rekey");
-  return { ...cellOf(value), kind, ownerId: textOf(fieldOf(value, "ownerId", "owner change"), "change ownerId") };
-}
-function storesOf(value) {
-  if (!isJsonObject(value)) throw new Error("std-mock-seed: dataset stores is not an object");
-  return Object.fromEntries(Object.entries(value).map(([store, rows]) => [store, EntityRowSchema.array().parse(rows)]));
-}
-function ownerPairsOf(schema) {
-  return ownerFieldsFromSchema(schema).map((field) => {
-    const dot = field.indexOf(".");
-    if (dot <= 0 || dot === field.length - 1) throw new Error(`std-mock-seed: owner field ${field} is not Entity.column`);
-    return { entity: field.slice(0, dot), column: field.slice(dot + 1) };
-  });
-}
-var StdMockSeed = class {
-  constructor(engine, config, user) {
-    this.engine = engine;
-    this.config = config;
-    this.user = user;
-  }
-  engine;
-  config;
-  user;
-  async ask(event, payload, done) {
-    const response = await this.engine.evaluate(
-      SEED_ORBITAL,
-      { event, targetTrait: SEED_TRAIT, payload: eventPayloadOf(asJson(payload)) },
-      { orbital: SEED_ORBITAL, ...this.user !== void 0 ? { user: this.user } : {} }
-    );
-    const failed = response.emittedEvents.find((emitted) => emitted.event === "DATASET_FAILED");
-    if (failed !== void 0) throw new Error(`std-mock-seed: ${event} refused: ${JSON.stringify(failed.payload ?? {})}`);
-    const answer = response.emittedEvents.find((emitted) => emitted.event === done);
-    if (answer === void 0) throw new Error(`std-mock-seed: ${event} did not answer ${done}`);
-    return asJson(answer.payload ?? {});
-  }
-  /** Sample the program's dataset (`DATASET_INPUT`). */
-  async dataset(program, run) {
-    const done = await this.ask("DATASET_INPUT", {
-      program,
-      count: this.config.count,
-      seed: this.config.seed,
-      nowMs: run.nowMs,
-      viewerId: run.viewerId ?? "",
-      ownerPairs: ownerPairsOf(program),
-      ...run.locale !== void 0 ? { locale: run.locale } : {}
-    }, "DATASET_DONE");
-    return { stores: storesOf(fieldOf(done, "stores", "DATASET_DONE")), journal: journalOf(fieldOf(done, "journal", "DATASET_DONE")) };
-  }
-  /**
-   * Re-point the dataset's tracked owner cells at `viewer` (`RESTAMP_INPUT`); `stores` are the current authoritative rows.
-   * `firstOwner` marks the stamp right after seeding; a persona switch restamps only when the program's
-   * `restampOnPersona` config says so, otherwise it answers no changes.
-   */
-  async restamp(program, stores, journal, viewer, firstOwner) {
-    const done = await this.ask("RESTAMP_INPUT", { program, stores, journal, viewer, firstOwner, restampOnPersona: this.config.restampOnPersona }, "RESTAMP_DONE");
-    const changes = fieldOf(done, "changes", "RESTAMP_DONE");
-    if (!Array.isArray(changes)) throw new Error("std-mock-seed: RESTAMP_DONE changes is not an array");
-    return { journal: journalOf(fieldOf(done, "journal", "RESTAMP_DONE")), changes: changes.map(changeOf) };
-  }
-};
-var STD_MOCK_SEED_SOURCE = "std/behaviors/std-mock-seed";
-var SEED_TRAIT_REF = "traits.MockSeed";
-function declaredValue(values, key, is) {
-  const value = values[key];
-  if (value === void 0 || !is(value)) throw new Error(`std-mock-seed: config ${key} is not declared as expected`);
-  return value;
-}
-function declaredSeedConfig(seedProgram, app) {
-  const seedTrait = seedProgram.orbitals.flatMap((orbital) => orbital.traits ?? []).find((t) => isInlineTrait(t) && t.name === SEED_TRAIT);
-  if (seedTrait === void 0 || !isInlineTrait(seedTrait)) throw new Error(`std-mock-seed: the seed program has no ${SEED_TRAIT} trait`);
-  const composed = (app?.orbitals ?? []).flatMap((orbital) => {
-    const aliases = (orbital.uses ?? []).filter((u) => u.from === STD_MOCK_SEED_SOURCE).map((u) => u.as);
-    return (orbital.traits ?? []).flatMap((t) => typeof t !== "string" && !isInlineTrait(t) && aliases.some((alias) => t.ref === `${alias}.${SEED_TRAIT_REF}`) ? [normalizeCallSiteConfigToValues(t.config) ?? {}] : []);
-  });
-  const values = Object.assign({}, normalizeCallSiteConfigToValues(seedTrait.config) ?? {}, ...composed);
-  return {
-    count: declaredValue(values, "count", (v) => typeof v === "number"),
-    seed: declaredValue(values, "seed", (v) => typeof v === "number"),
-    defaultPersona: declaredValue(values, "defaultPersona", (v) => typeof v === "string"),
-    restampOnPersona: declaredValue(values, "restampOnPersona", (v) => typeof v === "boolean")
-  };
-}
-function entityByStore(program) {
-  const byStore = /* @__PURE__ */ new Map();
-  for (const entity of program.orbitals.flatMap(orbitalInlineEntities)) {
-    if (entity.collection !== void 0 && entity.collection !== "") byStore.set(entity.collection, entity.name);
-  }
-  return byStore;
-}
-async function readSeededStores(persistence, program) {
-  const stores = {};
-  for (const [store, entityType] of entityByStore(program)) stores[store] = await persistence.list(entityType);
-  return stores;
-}
-
-export { StdMockSeed, declaredSeedConfig, readSeededStores };

package/dist/chunk-IHQLE5M7.js

@@ -1,62 +0,0 @@
-// src/runtime/events/identity/routing.ts
-function eventRouteKey(eventName, eventId) {
-  return eventId ? `@evt:${eventId}` : eventName;
-}
-function buildSourceMatcher(src, listenerOrbital) {
-  if (src.kind === "any") return () => true;
-  if (src.kind === "trait") {
-    if (src.traitId !== void 0) {
-      const wantedTraitId = src.traitId;
-      return (source) => !!source && source.traitId === wantedTraitId;
-    }
-    const wantedTrait2 = src.trait;
-    return (source) => !!source && source.orbital === listenerOrbital && source.trait === wantedTrait2;
-  }
-  if (src.orbitalId !== void 0 && src.traitId !== void 0) {
-    const wantedOrbitalId = src.orbitalId;
-    const wantedTraitId = src.traitId;
-    return (source) => !!source && source.orbitalId === wantedOrbitalId && source.traitId === wantedTraitId;
-  }
-  const wantedOrbital = src.orbital;
-  const wantedTrait = src.trait;
-  return (source) => !!source && source.orbital === wantedOrbital && source.trait === wantedTrait;
-}
-function parseListenSource(listener, listenerOrbital) {
-  const explicit = listener.source;
-  if (explicit && typeof explicit === "object") {
-    return {
-      bareEvent: listener.event,
-      matcher: buildSourceMatcher(explicit, listenerOrbital)
-    };
-  }
-  const key = listener.event;
-  const parts = key.split(".");
-  if (parts.length === 1) {
-    return { bareEvent: key, matcher: () => true };
-  }
-  if (parts.length === 2) {
-    const [sourceOrStar, eventName] = parts;
-    if (sourceOrStar === "*") {
-      return { bareEvent: eventName, matcher: () => true };
-    }
-    return {
-      bareEvent: eventName,
-      matcher: buildSourceMatcher(
-        { kind: "trait", trait: sourceOrStar },
-        listenerOrbital
-      )
-    };
-  }
-  if (parts.length >= 3) {
-    const eventName = parts[parts.length - 1];
-    const trait = parts[parts.length - 2];
-    const orbital = parts.slice(0, parts.length - 2).join(".");
-    return {
-      bareEvent: eventName,
-      matcher: buildSourceMatcher({ kind: "orbital", orbital, trait }, listenerOrbital)
-    };
-  }
-  return { bareEvent: key, matcher: () => true };
-}
-
-export { buildSourceMatcher, eventRouteKey, parseListenSource };

package/dist/chunk-JFWFDUTR.js

@@ -1,35 +0,0 @@
-import { readSeededStores } from './chunk-HMK6YMQS.js';
-import { orbitalInlineEntities, personaFromIdentityRow } from '@almadar/core';
-import { identityEntitiesOf } from '@almadar/core/mock';
-import { createLogger } from '@almadar/logger';
-
-var log = createLogger("almadar:shell-web:mock-seed");
-function bindDeclaredCollections(store, entities) {
-  for (const entity of entities) {
-    if (entity.name && entity.collection && entity.browser !== true && entity.persistence !== "runtime") {
-      store.bindCollection?.(entity.name, entity.collection);
-    }
-  }
-}
-async function seedMockStore(host, schema, viewer) {
-  bindDeclaredCollections(host.persistence, schema.orbitals.flatMap(orbitalInlineEntities));
-  const named = viewer.namedByHost ? viewer.current() : void 0;
-  const dataset = await host.seeder.dataset(schema, { nowMs: host.nowMs, ...named !== void 0 ? { viewerId: named.id } : {} });
-  if (viewer.namedByHost) return { viewer: named, journal: dataset.journal };
-  const declared = host.seeder.config.defaultPersona;
-  if (declared === "") return { viewer: void 0, journal: dataset.journal };
-  const identity = identityEntitiesOf(schema.orbitals)[0];
-  const row = identity?.collection !== void 0 ? (dataset.stores[identity.collection] ?? []).find((r) => r.id === declared) : void 0;
-  const resolved = row === void 0 ? void 0 : personaFromIdentityRow(row);
-  if (resolved === void 0) throw new Error(`std-mock-seed: defaultPersona ${declared} names no ${identity?.name ?? "identity"} row of the seeded dataset`);
-  const restamp = await host.seeder.restamp(schema, dataset.stores, dataset.journal, resolved, true);
-  log.debug("seeded", { identity: identity?.name, viewer: resolved.id, changes: restamp.changes.length });
-  return { viewer: resolved, journal: restamp.journal };
-}
-async function restampMockOwner(host, schema, journal, user) {
-  const stores = await readSeededStores(host.persistence, schema);
-  const restamp = await host.seeder.restamp(schema, stores, journal, user, false);
-  return restamp.journal;
-}
-
-export { bindDeclaredCollections, restampMockOwner, seedMockStore };

package/dist/chunk-MHYSHSRG.js

@@ -1,54 +0,0 @@
-import { isInlineTrait } from '@almadar/core';
-
-// src/runtime/effects/composition/event-wiring.ts
-function findInlineTrait(orbitals, name) {
-  for (const orbital of orbitals) {
-    for (const traitRef of orbital.traits) {
-      if (isInlineTrait(traitRef) && traitRef.name === name) {
-        return traitRef;
-      }
-    }
-  }
-  return null;
-}
-function hasEmit(emits, event) {
-  return emits.some((e) => e.event === event);
-}
-function hasListen(listens, event, triggers) {
-  return listens.some((l) => l.event === event && l.triggers === triggers);
-}
-function applyEventWiring(orbitals, wiring) {
-  const cloned = JSON.parse(
-    JSON.stringify(orbitals)
-  );
-  for (const entry of wiring) {
-    const sourceTrait = findInlineTrait(cloned, entry.from);
-    if (sourceTrait) {
-      if (!sourceTrait.emits) {
-        sourceTrait.emits = [];
-      }
-      if (!hasEmit(sourceTrait.emits, entry.event)) {
-        sourceTrait.emits.push({
-          event: entry.event,
-          scope: "external"
-        });
-      }
-    }
-    const targetTrait = findInlineTrait(cloned, entry.to);
-    if (targetTrait) {
-      if (!targetTrait.listens) {
-        targetTrait.listens = [];
-      }
-      if (!hasListen(targetTrait.listens, entry.event, entry.triggers)) {
-        targetTrait.listens.push({
-          event: entry.event,
-          triggers: entry.triggers,
-          scope: "external"
-        });
-      }
-    }
-  }
-  return cloned;
-}
-
-export { applyEventWiring };

package/dist/chunk-MLKGABMK.js

@@ -1,7 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-export { __export };