@almadar/runtime 6.31.0 → 6.33.0

package/dist/chunk-O5VGKPTG.js

@@ -0,0 +1,435 @@
+import { isEntityCall } from '@almadar/core';
+import { createLogger, isLogLevelEnabled } from '@almadar/logger';
+
+// src/ui/contract-errors.ts
+var RendererContractViolationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RendererContractViolationError";
+  }
+};
+
+// src/ui/slots.ts
+function aggregateSlotContent(slot, sources) {
+  const entries = Array.from(sources.values());
+  if (entries.length === 0) return void 0;
+  if (entries.length === 1) return entries[0];
+  Array.from(sources.keys());
+  const children = entries.map((entry) => ({
+    type: entry.pattern?.type ?? "box",
+    ...entry.props
+  }));
+  return {
+    slot,
+    pattern: { type: "stack", direction: "vertical", gap: "lg", children },
+    props: { direction: "vertical", gap: "lg", children },
+    source: entries[0].source
+  };
+}
+function isNonNullObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function assertHasFunctionMethods(label, value, methods) {
+  for (const method of methods) {
+    if (typeof value[method] !== "function") {
+      throw new RendererContractViolationError(`${label}.${method} must be a function`);
+    }
+  }
+}
+function assertIsSlotManager(value) {
+  if (!isNonNullObject(value)) {
+    throw new RendererContractViolationError("SlotManager must be a non-null object");
+  }
+  assertHasFunctionMethods("SlotManager", value, [
+    "getContent",
+    "setContent",
+    "clearSlot",
+    "getAllSlots",
+    "subscribe"
+  ]);
+}
+function assertIsMultiSourceSlotManager(value) {
+  if (!isNonNullObject(value)) {
+    throw new RendererContractViolationError("MultiSourceSlotManager must be a non-null object");
+  }
+  assertHasFunctionMethods("SlotManager", value, [
+    "getContent",
+    "setContent",
+    "clearSlot",
+    "getAllSlots",
+    "subscribe"
+  ]);
+  assertHasFunctionMethods("MultiSourceSlotManager", value, [
+    "getTraitContent",
+    "subscribeTrait",
+    "updateTraitContent"
+  ]);
+}
+function validateSlotContent(content) {
+  const errors = [];
+  if (content.slot === void 0 || content.slot === null) {
+    errors.push({ message: "SlotContent.slot is required", path: "slot" });
+  }
+  if (!("pattern" in content)) {
+    errors.push({ message: "SlotContent.pattern is required", path: "pattern" });
+  }
+  return errors;
+}
+function createSlotSetter(manager) {
+  return {
+    addPattern: (slot, pattern, props) => {
+      manager.setContent({
+        slot,
+        pattern,
+        props
+      });
+    },
+    clearSlot: (slot) => {
+      manager.clearSlot(slot);
+    }
+  };
+}
+
+// src/ui/wrapCallbackForEvent.ts
+function wrapCallbackForEvent(qualifiedEvent, callbackArgs, emit) {
+  const argNames = (callbackArgs ?? []).map((a) => a.name);
+  if (argNames.length === 0) {
+    return () => emit(qualifiedEvent);
+  }
+  return (...args) => {
+    const payload = {};
+    for (let i = 0; i < argNames.length; i += 1) {
+      payload[argNames[i]] = args[i];
+    }
+    emit(qualifiedEvent, payload);
+  };
+}
+var PERF_NAMESPACE = "almadar:perf:canvas";
+var log = createLogger(PERF_NAMESPACE);
+var RING_SIZE = 50;
+var ring = [];
+var writeIdx = 0;
+var subscribers = /* @__PURE__ */ new Set();
+var notifyScheduled = false;
+var revision = 0;
+var cachedSnapshot = [];
+var cachedRevision = -1;
+function scheduleNotify() {
+  if (notifyScheduled) return;
+  notifyScheduled = true;
+  queueMicrotask(() => {
+    notifyScheduled = false;
+    revision++;
+    for (const fn of subscribers) fn();
+  });
+}
+function push(entry) {
+  if (ring.length < RING_SIZE) {
+    ring.push(entry);
+  } else {
+    ring[writeIdx] = entry;
+  }
+  writeIdx = (writeIdx + 1) % RING_SIZE;
+  scheduleNotify();
+}
+function isEnabled() {
+  return isLogLevelEnabled("DEBUG", PERF_NAMESPACE);
+}
+function now() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function perfStart(name) {
+  if (!isEnabled()) return -1;
+  if (typeof performance !== "undefined" && typeof performance.mark === "function") {
+    try {
+      performance.mark(`${name}-start`);
+    } catch {
+    }
+  }
+  return now();
+}
+function perfEnd(name, startToken, detail) {
+  if (startToken < 0 || !isEnabled()) return;
+  const endTs = now();
+  const durationMs = endTs - startToken;
+  if (typeof performance !== "undefined" && typeof performance.measure === "function") {
+    try {
+      performance.mark(`${name}-end`);
+      performance.measure(name, `${name}-start`, `${name}-end`);
+    } catch {
+    }
+  }
+  push({ name, durationMs, ts: endTs, detail });
+  log.debug(name, () => ({ durationMs, ...detail ?? {} }));
+}
+function perfTime(name, fn, detail) {
+  const t = perfStart(name);
+  try {
+    return fn();
+  } finally {
+    perfEnd(name, t, detail);
+  }
+}
+function getPerfSnapshot() {
+  if (ring.length < RING_SIZE) return ring.slice();
+  return [...ring.slice(writeIdx), ...ring.slice(0, writeIdx)];
+}
+function getSnapshot() {
+  if (cachedRevision !== revision) {
+    cachedSnapshot = getPerfSnapshot();
+    cachedRevision = revision;
+  }
+  return cachedSnapshot;
+}
+function subscribe(fn) {
+  subscribers.add(fn);
+  return () => {
+    subscribers.delete(fn);
+  };
+}
+function pushPerfEntry(entry) {
+  if (!isEnabled()) return;
+  push(entry);
+}
+function clearPerf() {
+  ring.length = 0;
+  writeIdx = 0;
+  scheduleNotify();
+}
+var perfStore = {
+  subscribe,
+  getSnapshot
+};
+
+// src/ui/prepareSchemaForPreview.ts
+function generateEntityRow(entity, idx) {
+  const row = { id: String(idx) };
+  for (const f of entity.fields) {
+    if (f.name === void 0 || f.name === "id") continue;
+    row[f.name] = generateFieldValue(entity.name, f, idx);
+  }
+  return row;
+}
+function generateFieldValue(entityName, field, idx) {
+  if ("values" in field && field.values && field.values.length > 0) {
+    return field.values[(idx - 1) % field.values.length];
+  }
+  const fieldName = field.name ?? "";
+  switch (field.type) {
+    case "string":
+      return `${entityName} ${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)} ${idx}`;
+    case "number":
+      return idx * 10;
+    case "boolean":
+      return idx % 2 === 0;
+    default:
+      return field.default ?? null;
+  }
+}
+function buildMockData(schema) {
+  const t = perfStart("build-mock-data");
+  const result = {};
+  for (const orbital of schema.orbitals) {
+    const entity = orbital.entity;
+    if (!entity || typeof entity === "string") continue;
+    if (isEntityCall(entity)) continue;
+    const entityName = entity.name;
+    if (!entityName) continue;
+    if (entity.instances && entity.instances.length > 0) {
+      result[entityName] = entity.instances;
+      continue;
+    }
+    const rows = Array.from(
+      { length: 10 },
+      (_, i) => generateEntityRow(entity, i + 1)
+    );
+    result[entityName] = rows;
+  }
+  for (const orbital of schema.orbitals) {
+    for (const traitRef of orbital.traits ?? []) {
+      if (!isInlineTrait(traitRef)) continue;
+      const trait = traitRef;
+      const sourceEntity = trait.sourceEntityDefinition;
+      if (!sourceEntity || isEntityCall(sourceEntity)) continue;
+      const sourceName = sourceEntity.name;
+      if (!sourceName) continue;
+      if (!result[sourceName]) {
+        result[sourceName] = sourceEntity.instances && sourceEntity.instances.length > 0 ? sourceEntity.instances : Array.from(
+          { length: 10 },
+          (_, i) => generateEntityRow(sourceEntity, i + 1)
+        );
+      }
+      const reboundName = trait.linkedEntity;
+      if (!reboundName || reboundName === sourceName) continue;
+      const reboundRows = result[reboundName];
+      if (!reboundRows || reboundRows.length === 0) continue;
+      reboundRows.forEach((row, i) => {
+        for (const f of sourceEntity.fields) {
+          if (f.name === void 0 || f.name === "id") continue;
+          if (row[f.name] !== void 0) continue;
+          row[f.name] = generateFieldValue(sourceName, f, i + 1);
+        }
+      });
+    }
+  }
+  perfEnd("build-mock-data", t, { orbitalCount: schema.orbitals.length, entityCount: Object.keys(result).length });
+  return result;
+}
+function isInlineTrait(traitRef) {
+  return typeof traitRef === "object" && traitRef !== null && "stateMachine" in traitRef;
+}
+function findDataState(sm, initialStateName) {
+  return sm.states.find((s) => {
+    if (s.name === initialStateName) return false;
+    return sm.transitions.some(
+      (t) => t.event === "INIT" && (t.from === s.name || Array.isArray(t.from) && t.from.includes(s.name))
+    );
+  });
+}
+function rewriteTraitInitialState(trait, mockData) {
+  const sm = trait.stateMachine;
+  if (!sm) return trait;
+  const linkedEntity = trait.linkedEntity;
+  if (!linkedEntity || !mockData[linkedEntity]?.length) return trait;
+  const initialStateName = sm.states.find((s) => s.isInitial)?.name ?? sm.states[0]?.name;
+  if (!initialStateName) return trait;
+  const dataState = findDataState(sm, initialStateName);
+  if (!dataState) return trait;
+  const updatedStates = sm.states.map((s) => {
+    if (s.name === initialStateName) return { ...s, isInitial: false };
+    if (s.name === dataState.name) return { ...s, isInitial: true };
+    return s;
+  });
+  return { ...trait, stateMachine: { ...sm, states: updatedStates } };
+}
+function adjustSchemaForMockData(schema, mockData) {
+  let changed = false;
+  const updatedOrbitals = schema.orbitals.map((orbital) => {
+    const traits = orbital.traits ?? [];
+    const updatedTraits = traits.map((traitRef) => {
+      if (!isInlineTrait(traitRef)) return traitRef;
+      const updated = rewriteTraitInitialState(traitRef, mockData);
+      if (updated !== traitRef) changed = true;
+      return updated;
+    });
+    return changed ? { ...orbital, traits: updatedTraits } : orbital;
+  });
+  return changed ? { ...schema, orbitals: updatedOrbitals } : schema;
+}
+function prepareSchemaForPreview(input) {
+  const parsed = typeof input === "string" ? JSON.parse(input) : input;
+  const mockData = buildMockData(parsed);
+  const schema = adjustSchemaForMockData(parsed, mockData);
+  return { schema, mockData };
+}
+
+// src/ui/orbitalsByTrait.ts
+function buildOrbitalsByTrait(schema, resolvedPages = []) {
+  const map = {};
+  if (!schema?.orbitals) return map;
+  const pagePathToOrbital = {};
+  for (const orb of schema.orbitals) {
+    for (const traitRef of orb.traits ?? []) {
+      let traitName;
+      if (typeof traitRef === "string") {
+        const parts = traitRef.split(".");
+        traitName = parts[parts.length - 1];
+      } else if ("ref" in traitRef && typeof traitRef.ref === "string") {
+        const parts = traitRef.ref.split(".");
+        traitName = traitRef.name ?? parts[parts.length - 1];
+      } else if ("name" in traitRef && typeof traitRef.name === "string") {
+        traitName = traitRef.name;
+      }
+      if (traitName) map[traitName] = orb.name;
+    }
+    for (const pg of orb.pages ?? []) {
+      const path = typeof pg === "string" ? pg : pg?.path;
+      if (path) pagePathToOrbital[path] = orb.name;
+    }
+  }
+  for (const page of resolvedPages) {
+    const orbital = page.path ? pagePathToOrbital[page.path] : void 0;
+    if (!orbital) continue;
+    for (const traitName of page.traitNames) {
+      if (traitName && !(traitName in map)) map[traitName] = orbital;
+    }
+  }
+  return map;
+}
+var log2 = createLogger("almadar:runtime:verify");
+var MAX_EVENT_LOG = 200;
+var EMPTY_SUMMARY = {
+  totalChecks: 0,
+  passed: 0,
+  failed: 0,
+  warnings: 0,
+  pending: 0
+};
+function emptySnapshot() {
+  return {
+    checks: [],
+    transitions: [],
+    bridge: null,
+    summary: EMPTY_SUMMARY,
+    traits: []
+  };
+}
+function ensureVerificationApi() {
+  if (typeof window === "undefined") return void 0;
+  if (!window.__orbitalVerification) {
+    window.__orbitalVerification = {
+      getSnapshot: emptySnapshot,
+      getChecks: () => [],
+      getTransitions: () => [],
+      getBridge: () => null,
+      getSummary: () => EMPTY_SUMMARY,
+      waitForTransition: () => Promise.resolve(null),
+      getTraitSnapshots: () => []
+    };
+  }
+  return window.__orbitalVerification;
+}
+function getOrbitalVerification() {
+  if (typeof window === "undefined") return void 0;
+  return window.__orbitalVerification;
+}
+function bindEventBus(eventBus) {
+  const api = ensureVerificationApi();
+  if (!api) return;
+  api.sendEvent = (event, payload, traitScope) => {
+    const prefixed = event.startsWith("UI:") ? event : traitScope ? `UI:${traitScope}.${event}` : `UI:${event}`;
+    log2.debug("sendEvent", {
+      event: prefixed,
+      traitScope,
+      payloadKeys: payload ? Object.keys(payload) : []
+    });
+    eventBus.emit(prefixed, payload);
+  };
+  const eventLog = [];
+  api.eventLog = eventLog;
+  api.clearEventLog = () => {
+    eventLog.length = 0;
+  };
+  if (eventBus.onAny) {
+    const verificationEventLogger = (event) => {
+      if (eventLog.length < MAX_EVENT_LOG) {
+        eventLog.push({
+          type: event.type,
+          payload: event.payload,
+          timestamp: Date.now()
+        });
+      }
+    };
+    Object.defineProperty(verificationEventLogger, "name", {
+      value: "runtime-verify:eventLog"
+    });
+    eventBus.onAny(verificationEventLogger);
+  }
+}
+function bindTraitStateGetter(getter) {
+  const api = ensureVerificationApi();
+  if (!api) return;
+  api.getTraitState = getter;
+}
+
+export { PERF_NAMESPACE, RendererContractViolationError, adjustSchemaForMockData, aggregateSlotContent, assertIsMultiSourceSlotManager, assertIsSlotManager, bindEventBus, bindTraitStateGetter, buildMockData, buildOrbitalsByTrait, clearPerf, createSlotSetter, ensureVerificationApi, getOrbitalVerification, perfEnd, perfStart, perfStore, perfTime, prepareSchemaForPreview, pushPerfEntry, validateSlotContent, wrapCallbackForEvent };

package/dist/chunk-OQJIK6PZ.js

@@ -0,0 +1,163 @@
+// src/mockRandom.ts
+var seedState = 42;
+function seedRandom(value) {
+  seedState = (value ?? 42) >>> 0;
+}
+function nextFloat() {
+  seedState = seedState * 1664525 + 1013904223 >>> 0;
+  return seedState / 4294967296;
+}
+function randomInt({ min, max }) {
+  return Math.floor(nextFloat() * (max - min + 1)) + min;
+}
+function randomFloat({
+  min,
+  max,
+  fractionDigits = 2
+}) {
+  const value = nextFloat() * (max - min) + min;
+  const factor = 10 ** fractionDigits;
+  return Math.round(value * factor) / factor;
+}
+function randomBoolean() {
+  return nextFloat() < 0.5;
+}
+function randomArrayElement(array) {
+  return array[randomInt({ min: 0, max: array.length - 1 })];
+}
+function shuffleArray(array) {
+  const copy = array.slice();
+  for (let i = copy.length - 1; i > 0; i--) {
+    const j = randomInt({ min: 0, max: i });
+    const tmp = copy[i];
+    copy[i] = copy[j];
+    copy[j] = tmp;
+  }
+  return copy;
+}
+function randomPastDate({ years = 1 } = {}) {
+  const now = Date.now();
+  const maxAge = years * 365 * 24 * 60 * 60 * 1e3;
+  const age = Math.floor(nextFloat() * maxAge);
+  return new Date(now - age);
+}
+function randomRecentDate({ days = 30 } = {}) {
+  const now = Date.now();
+  const maxAge = days * 24 * 60 * 60 * 1e3;
+  const age = Math.floor(nextFloat() * maxAge);
+  return new Date(now - age);
+}
+function randomAnytimeDate() {
+  const now = Date.now();
+  const maxAge = 100 * 365 * 24 * 60 * 60 * 1e3;
+  const age = Math.floor(nextFloat() * maxAge);
+  return new Date(now - age);
+}
+var LOREM_WORDS = [
+  "lorem",
+  "ipsum",
+  "dolor",
+  "sit",
+  "amet",
+  "consectetur",
+  "adipiscing",
+  "elit",
+  "sed",
+  "do",
+  "eiusmod",
+  "tempor",
+  "incididunt",
+  "ut",
+  "labore",
+  "et",
+  "dolore",
+  "magna",
+  "aliqua",
+  "enim",
+  "ad",
+  "minim",
+  "veniam",
+  "quis",
+  "nostrud",
+  "exercitation",
+  "ullamco",
+  "laboris",
+  "nisi",
+  "aliquip",
+  "ex",
+  "ea",
+  "commodo",
+  "consequat",
+  "duis",
+  "aute",
+  "irure",
+  "in",
+  "reprehenderit",
+  "voluptate",
+  "velit",
+  "esse",
+  "cillum",
+  "fugiat",
+  "nulla",
+  "pariatur",
+  "excepteur",
+  "sint",
+  "occaecat",
+  "cupidatat",
+  "non",
+  "proident",
+  "sunt",
+  "culpa",
+  "qui",
+  "officia",
+  "deserunt",
+  "mollit",
+  "anim",
+  "id",
+  "est",
+  "laborum"
+];
+function randomWords(count) {
+  const words = [];
+  for (let i = 0; i < count; i++) {
+    words.push(randomArrayElement(LOREM_WORDS));
+  }
+  return words.join(" ");
+}
+function randomSentence() {
+  const words = randomWords(randomInt({ min: 4, max: 8 }));
+  return words.charAt(0).toUpperCase() + words.slice(1) + ".";
+}
+function randomUuid() {
+  const hex = () => randomInt({ min: 0, max: 15 }).toString(16);
+  return `${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}-${hex()}${hex()}${hex()}${hex()}-4${hex()}${hex()}${hex()}-${hex()}${hex()}${hex()}${hex()}-${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}${hex()}`;
+}
+function randomColor() {
+  const channel = () => randomInt({ min: 0, max: 255 }).toString(16).padStart(2, "0");
+  return `#${channel()}${channel()}${channel()}`;
+}
+var PASSWORD_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*";
+function randomPassword(length = 12) {
+  let password = "";
+  for (let i = 0; i < length; i++) {
+    password += randomArrayElement(PASSWORD_CHARS.split(""));
+  }
+  return password;
+}
+function randomEmail() {
+  const user = randomWords(1).toLowerCase().replace(/\s+/g, ".");
+  const domain = randomWords(1).toLowerCase().replace(/\s+/g, "");
+  return `${user}@${domain}.com`;
+}
+function randomUrl() {
+  const slug = randomWords(2).toLowerCase().replace(/\s+/g, "-");
+  return `https://example.com/${slug}`;
+}
+function randomPhone() {
+  const area = randomInt({ min: 200, max: 999 });
+  const prefix = randomInt({ min: 200, max: 999 });
+  const line = randomInt({ min: 0, max: 9999 }).toString().padStart(4, "0");
+  return `+1 (${area}) ${prefix}-${line}`;
+}
+
+export { randomAnytimeDate, randomArrayElement, randomBoolean, randomColor, randomEmail, randomFloat, randomInt, randomPassword, randomPastDate, randomPhone, randomRecentDate, randomSentence, randomUrl, randomUuid, randomWords, seedRandom, shuffleArray };

package/dist/chunk-SCRAHWOC.js

@@ -0,0 +1,82 @@
+// src/ui/embedded-traits.ts
+var TRAIT_BINDING_PREFIX = "@trait.";
+function collectTraitRefsFromValue(value, into) {
+  if (value === null || value === void 0) return;
+  if (typeof value === "string") {
+    if (value.startsWith(TRAIT_BINDING_PREFIX)) {
+      const rest = value.slice(TRAIT_BINDING_PREFIX.length);
+      const dot = rest.indexOf(".");
+      const traitName = dot === -1 ? rest : rest.slice(0, dot);
+      if (traitName.length > 0) into.add(traitName);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectTraitRefsFromValue(item, into);
+    return;
+  }
+  if (typeof value === "object") {
+    for (const v of Object.values(value)) {
+      collectTraitRefsFromValue(v, into);
+    }
+  }
+}
+function collectTraitRefsFromEffects(effects, into) {
+  if (!effects) return;
+  for (const effect of effects) {
+    if (!Array.isArray(effect)) continue;
+    if (effect[0] === "render-ui" && effect.length >= 3) {
+      collectTraitRefsFromValue(effect[2], into);
+      continue;
+    }
+    for (let i = 1; i < effect.length; i++) {
+      const arg = effect[i];
+      if (Array.isArray(arg)) collectTraitRefsFromEffects([arg], into);
+      else collectTraitRefsFromValue(arg, into);
+    }
+  }
+}
+function collectTraitRefsFromResolvedTrait(trait) {
+  const out = /* @__PURE__ */ new Set();
+  for (const transition of trait.transitions ?? []) {
+    collectTraitRefsFromEffects(transition.effects, out);
+  }
+  for (const tick of trait.ticks ?? []) {
+    collectTraitRefsFromEffects(tick.effects, out);
+  }
+  return out;
+}
+function collectEmbeddedTraits(schema) {
+  const out = /* @__PURE__ */ new Set();
+  if (!schema?.orbitals) return out;
+  for (const orbital of schema.orbitals) {
+    const traits = orbital.traits;
+    if (!Array.isArray(traits)) continue;
+    for (const traitRef of traits) {
+      if (!traitRef || typeof traitRef !== "object") continue;
+      const resolved = traitRef._resolved;
+      const target = resolved && typeof resolved === "object" ? resolved : traitRef;
+      if (typeof traitRef !== "string" && "config" in traitRef && traitRef.config) {
+        collectTraitRefsFromValue(traitRef.config, out);
+      }
+      if (target.config) {
+        collectTraitRefsFromValue(target.config, out);
+      }
+      const transitions = target.stateMachine?.transitions;
+      if (!Array.isArray(transitions)) continue;
+      for (const t of transitions) {
+        collectTraitRefsFromEffects(t.effects, out);
+      }
+      collectTraitRefsFromEffects(target.initialEffects, out);
+      const ticks = target.ticks;
+      if (Array.isArray(ticks)) {
+        for (const tick of ticks) {
+          collectTraitRefsFromEffects(tick.effects, out);
+        }
+      }
+    }
+  }
+  return out;
+}
+
+export { collectEmbeddedTraits, collectTraitRefsFromEffects, collectTraitRefsFromResolvedTrait, collectTraitRefsFromValue };

package/dist/createOsHandlers.d.ts

@@ -1,4 +1,4 @@
-import { a as EffectHandlers } from './types-D-9feVsj.js';
+import { E as EffectHandlers } from './types-ConZnrpe.js';
 import { EventPayload } from '@almadar/core';
 
 /**