@almadar/shell-web 0.0.0-stage → 0.1.0

package/dist/chunk-3BBUBJFF.js

@@ -0,0 +1,339 @@
+// src/lib/themeTokens.ts
+function applyFlat(obj, table, vars) {
+  if (!obj) return;
+  for (const { cssVar, key } of table) {
+    const value = obj[key];
+    if (value !== void 0) vars[cssVar] = value;
+  }
+}
+var DENSITY_SPACING_VARS = [
+  { cssVar: "--space-0", key: "space0" },
+  { cssVar: "--space-1", key: "space1" },
+  { cssVar: "--space-2", key: "space2" },
+  { cssVar: "--space-3", key: "space3" },
+  { cssVar: "--space-4", key: "space4" },
+  { cssVar: "--space-5", key: "space5" },
+  { cssVar: "--space-6", key: "space6" },
+  { cssVar: "--space-7", key: "space7" },
+  { cssVar: "--space-8", key: "space8" },
+  { cssVar: "--space-9", key: "space9" },
+  { cssVar: "--space-10", key: "space10" },
+  { cssVar: "--space-11", key: "space11" },
+  { cssVar: "--space-12", key: "space12" }
+];
+var DENSITY_ELEMENT_VARS = [
+  { cssVar: "--button-height-sm", key: "buttonHeightSm" },
+  { cssVar: "--button-height-md", key: "buttonHeightMd" },
+  { cssVar: "--button-height-lg", key: "buttonHeightLg" },
+  { cssVar: "--input-height-sm", key: "inputHeightSm" },
+  { cssVar: "--input-height-md", key: "inputHeightMd" },
+  { cssVar: "--input-height-lg", key: "inputHeightLg" },
+  { cssVar: "--row-height-compact", key: "rowHeightCompact" },
+  { cssVar: "--row-height-normal", key: "rowHeightNormal" },
+  { cssVar: "--row-height-spacious", key: "rowHeightSpacious" },
+  { cssVar: "--card-padding-sm", key: "cardPaddingSm" },
+  { cssVar: "--card-padding-md", key: "cardPaddingMd" },
+  { cssVar: "--card-padding-lg", key: "cardPaddingLg" },
+  { cssVar: "--dialog-padding", key: "dialogPadding" },
+  { cssVar: "--section-gap", key: "sectionGap" }
+];
+var TYPE_FAMILY_VARS = [
+  { cssVar: "--font-family-display", key: "displayFamily" },
+  { cssVar: "--font-family-body", key: "bodyFamily" },
+  { cssVar: "--font-family-mono", key: "monoFamily" }
+];
+var TYPE_HEADING_VARS = [
+  { cssVar: "--heading-weight", key: "headingWeight" },
+  { cssVar: "--heading-transform", key: "headingTransform" },
+  { cssVar: "--heading-tracking", key: "headingTracking" },
+  { cssVar: "--heading-style", key: "headingStyle" },
+  { cssVar: "--heading-shadow", key: "headingShadow" }
+];
+var TYPE_SIZE_KEYS = [
+  "xs",
+  "sm",
+  "base",
+  "lg",
+  "xl",
+  "2xl",
+  "3xl",
+  "4xl",
+  "display-1",
+  "display-2"
+];
+var TYPE_INTENT_VARS = [
+  { key: "headingMajor", cssName: "heading-major" },
+  { key: "headingMinor", cssName: "heading-minor" },
+  { key: "bodyEmphasis", cssName: "body-emphasis" },
+  { key: "bodyDefault", cssName: "body-default" },
+  { key: "bodyQuiet", cssName: "body-quiet" },
+  { key: "caption", cssName: "caption" },
+  { key: "numeric", cssName: "numeric" }
+];
+var MOTION_DURATION_KEYS = [
+  "instant",
+  "fast",
+  "normal",
+  "slow",
+  "dramatic"
+];
+var MOTION_EASING_KEYS = [
+  "linear",
+  "standard",
+  "emphasized",
+  "spring"
+];
+var MOTION_INTENT_VARS = [
+  { key: "enter", cssName: "enter" },
+  { key: "exit", cssName: "exit" },
+  { key: "hover", cssName: "hover" },
+  { key: "press", cssName: "press" },
+  { key: "expand", cssName: "expand" },
+  { key: "transition", cssName: "transition" }
+];
+var MOTION_SHAPE_VARS = [
+  { cssVar: "--motion-modal-enter-from-transform", key: "modalEnter" },
+  { cssVar: "--motion-modal-exit-to-transform", key: "modalExit" },
+  { cssVar: "--motion-popover-enter-from-transform", key: "popoverEnter" },
+  { cssVar: "--motion-popover-exit-to-transform", key: "popoverExit" },
+  { cssVar: "--motion-toast-enter-from-transform", key: "toastEnter" },
+  { cssVar: "--motion-toast-exit-to-transform", key: "toastExit" },
+  { cssVar: "--motion-page-enter-from-transform", key: "pageEnter" },
+  { cssVar: "--motion-enter-rise-from-transform", key: "enterRise" },
+  { cssVar: "--motion-enter-scale-from-transform", key: "enterScale" },
+  { cssVar: "--motion-enter-slide-from-transform", key: "enterSlide" }
+];
+var ICONOGRAPHY_VARS = [
+  { cssVar: "--icon-family", key: "family" },
+  { cssVar: "--icon-stroke-width", key: "strokeWidth" },
+  { cssVar: "--icon-default-size", key: "defaultSize" }
+];
+var ELEVATION_VARS = [
+  { cssVar: "--elevation-card", key: "cardElevation" },
+  { cssVar: "--elevation-popover", key: "popoverElevation" },
+  { cssVar: "--elevation-dialog", key: "dialogElevation" },
+  { cssVar: "--elevation-toast", key: "toastElevation" },
+  { cssVar: "--elevation-interactive", key: "interactiveElevation" },
+  { cssVar: "--elevation-pressed", key: "pressedElevation" }
+];
+var GEOMETRY_VARS = [
+  { cssVar: "--radius-container", key: "radiusContainer" },
+  { cssVar: "--radius-interactive", key: "radiusInteractive" },
+  { cssVar: "--radius-pill", key: "radiusPill" },
+  { cssVar: "--border-hairline", key: "borderHairline" },
+  { cssVar: "--border-standard", key: "borderStandard" },
+  { cssVar: "--border-heavy", key: "borderHeavy" },
+  { cssVar: "--corner-shape", key: "cornerShape" },
+  { cssVar: "--corner-shape-pill", key: "cornerShapePill" },
+  { cssVar: "--corner-shape-interactive", key: "cornerShapeInteractive" },
+  { cssVar: "--border-style", key: "borderStyle" },
+  { cssVar: "--border-style-interactive", key: "borderStyleInteractive" }
+];
+var SURFACE_VARS = [
+  { cssVar: "--surface-backdrop", key: "backdrop" },
+  { cssVar: "--surface-card-image", key: "cardImage" },
+  { cssVar: "--surface-page-image", key: "pageImage" },
+  { cssVar: "--surface-page-image-size", key: "pageImageSize" },
+  { cssVar: "--surface-diagram", key: "diagram" },
+  { cssVar: "--surface-edge-mask", key: "edgeMask" },
+  { cssVar: "--surface-edge-height", key: "edgeHeight" },
+  { cssVar: "--surface-texture-mask", key: "textureMask" },
+  { cssVar: "--surface-texture-size", key: "textureSize" },
+  { cssVar: "--surface-accent-image", key: "accentImage" },
+  { cssVar: "--surface-scrim", key: "scrim" }
+];
+var DIAGRAM_VARS = [
+  { cssVar: "--diagram-stroke-thin", key: "strokeThin" },
+  { cssVar: "--diagram-stroke-normal", key: "strokeNormal" },
+  { cssVar: "--diagram-stroke-bold", key: "strokeBold" },
+  { cssVar: "--diagram-line-cap", key: "lineCap" },
+  { cssVar: "--diagram-line-join", key: "lineJoin" },
+  { cssVar: "--diagram-dash", key: "dash" },
+  { cssVar: "--diagram-dot", key: "dot" },
+  { cssVar: "--diagram-fill-style", key: "fillStyle" },
+  { cssVar: "--diagram-fill-opacity", key: "fillOpacity" },
+  { cssVar: "--diagram-roughness", key: "roughness" },
+  { cssVar: "--diagram-glow", key: "glow" },
+  { cssVar: "--diagram-shadow", key: "shadow" },
+  { cssVar: "--diagram-marker", key: "marker" },
+  { cssVar: "--diagram-label-font", key: "labelFont" },
+  { cssVar: "--diagram-label-size", key: "labelSize" },
+  { cssVar: "--diagram-label-weight", key: "labelWeight" },
+  { cssVar: "--diagram-label-case", key: "labelCase" },
+  { cssVar: "--diagram-corner", key: "corner" }
+];
+var SCENE_VARS = [
+  { cssVar: "--material-roughness", key: "materialRoughness" },
+  { cssVar: "--material-metalness", key: "materialMetalness" },
+  { cssVar: "--material-flat", key: "materialFlat" },
+  { cssVar: "--material-outline", key: "materialOutline" },
+  { cssVar: "--light-ambient", key: "lightAmbient" },
+  { cssVar: "--light-key", key: "lightKey" },
+  { cssVar: "--light-key-color", key: "lightKeyColor" },
+  { cssVar: "--scene-fog", key: "fog" }
+];
+var LEGACY_PREFIXES = {
+  colors: "--color-",
+  radii: "--radius-",
+  spacing: "--space-",
+  shadows: "--shadow-"
+};
+function themeTokensToCssVars(tokens, mode = "light", darkVariant) {
+  const vars = {};
+  const isDark = mode === "dark";
+  const pickColors = isDark && darkVariant?.colors ? darkVariant.colors : tokens.colors;
+  if (pickColors) {
+    for (const [key, value] of Object.entries(pickColors)) {
+      vars[`${LEGACY_PREFIXES.colors}${key}`] = value;
+    }
+    if (isDark && darkVariant?.colors && tokens.colors) {
+      for (const [key, value] of Object.entries(tokens.colors)) {
+        const varName = `${LEGACY_PREFIXES.colors}${key}`;
+        if (!(varName in vars)) vars[varName] = value;
+      }
+    }
+  }
+  const pickRadii = isDark && darkVariant?.radii ? darkVariant.radii : tokens.radii;
+  if (pickRadii) {
+    for (const [key, value] of Object.entries(pickRadii)) {
+      vars[`${LEGACY_PREFIXES.radii}${key}`] = value;
+    }
+  }
+  const pickSpacing = isDark && darkVariant?.spacing ? darkVariant.spacing : tokens.spacing;
+  if (pickSpacing) {
+    for (const [key, value] of Object.entries(pickSpacing)) {
+      vars[`${LEGACY_PREFIXES.spacing}${key}`] = value;
+    }
+  }
+  const pickTypography = isDark && darkVariant?.typography ? darkVariant.typography : tokens.typography;
+  if (pickTypography) {
+    for (const [key, value] of Object.entries(pickTypography)) {
+      vars[`--${key}`] = value;
+    }
+  }
+  const pickShadows = isDark && darkVariant?.shadows ? darkVariant.shadows : tokens.shadows;
+  if (pickShadows) {
+    for (const [key, value] of Object.entries(pickShadows)) {
+      vars[`${LEGACY_PREFIXES.shadows}${key}`] = value;
+    }
+  }
+  const pickDensity = isDark && darkVariant?.density ? darkVariant.density : tokens.density;
+  emitDensity(pickDensity, vars);
+  const pickTypeScale = isDark && darkVariant?.typeScale ? darkVariant.typeScale : tokens.typeScale;
+  emitTypeScale(pickTypeScale, vars);
+  const pickMotion = isDark && darkVariant?.motion ? darkVariant.motion : tokens.motion;
+  emitMotion(pickMotion, vars);
+  const pickIconography = isDark && darkVariant?.iconography ? darkVariant.iconography : tokens.iconography;
+  emitIconography(pickIconography, vars);
+  const pickElevation = isDark && darkVariant?.elevation ? darkVariant.elevation : tokens.elevation;
+  emitElevation(pickElevation, vars);
+  const pickGeometry = isDark && darkVariant?.geometry ? darkVariant.geometry : tokens.geometry;
+  emitGeometry(pickGeometry, vars);
+  const pickIllustration = isDark && darkVariant?.illustration ? darkVariant.illustration : tokens.illustration;
+  emitIllustration(pickIllustration, vars);
+  const pickSurface = isDark && darkVariant?.surface ? darkVariant.surface : tokens.surface;
+  applyFlat(pickSurface, SURFACE_VARS, vars);
+  const pickDiagram = isDark && darkVariant?.diagram ? darkVariant.diagram : tokens.diagram;
+  applyFlat(pickDiagram, DIAGRAM_VARS, vars);
+  const pickScene = isDark && darkVariant?.scene ? darkVariant.scene : tokens.scene;
+  applyFlat(pickScene, SCENE_VARS, vars);
+  return vars;
+}
+function emitDensity(density, vars) {
+  if (!density) return;
+  applyFlat(density.spacing, DENSITY_SPACING_VARS, vars);
+  applyFlat(density, DENSITY_ELEMENT_VARS, vars);
+}
+function typeSizeKeyStr(k) {
+  return k;
+}
+function typeWeightStr(w) {
+  return w;
+}
+function emitTypeIntent(name, intent, vars) {
+  const sizeKey = typeSizeKeyStr(intent.size);
+  const weight = typeWeightStr(intent.weight);
+  vars[`--intent-${name}-size`] = `var(--text-${sizeKey})`;
+  vars[`--intent-${name}-weight`] = `var(--font-weight-${weight})`;
+  vars[`--intent-${name}-leading`] = `var(--leading-${sizeKey})`;
+}
+function emitTypeScale(ts, vars) {
+  if (!ts) return;
+  applyFlat(ts, TYPE_FAMILY_VARS, vars);
+  applyFlat(ts, TYPE_HEADING_VARS, vars);
+  if (ts.scale) {
+    const s = ts.scale;
+    for (const k of TYPE_SIZE_KEYS) {
+      const entry = s[k];
+      if (entry !== void 0) {
+        vars[`--text-${k}`] = entry.size;
+        vars[`--leading-${k}`] = entry.lineHeight;
+      }
+    }
+  }
+  if (ts.intents) {
+    const i = ts.intents;
+    for (const { key, cssName } of TYPE_INTENT_VARS) {
+      const intent = i[key];
+      if (intent) emitTypeIntent(cssName, intent, vars);
+    }
+  }
+}
+function emitMotionIntent(name, intent, vars) {
+  vars[`--intent-${name}-duration`] = `var(--duration-${intent.duration})`;
+  vars[`--intent-${name}-easing`] = `var(--easing-${intent.easing})`;
+}
+function emitMotion(m, vars) {
+  if (!m) return;
+  if (m.durations) {
+    const d = m.durations;
+    for (const k of MOTION_DURATION_KEYS) {
+      const v = d[k];
+      if (v !== void 0) vars[`--duration-${k}`] = v;
+    }
+  }
+  if (m.easings) {
+    const e = m.easings;
+    for (const k of MOTION_EASING_KEYS) {
+      const v = e[k];
+      if (v !== void 0) vars[`--easing-${k}`] = v;
+    }
+  }
+  if (m.intents) {
+    const i = m.intents;
+    for (const { key, cssName } of MOTION_INTENT_VARS) {
+      const intent = i[key];
+      if (intent) emitMotionIntent(cssName, intent, vars);
+    }
+  }
+  applyFlat(m.shapes, MOTION_SHAPE_VARS, vars);
+  if (m.entry?.default !== void 0) vars["--motion-enter-default"] = enterKeyframe(m.entry.default);
+  if (m.entry?.stagger !== void 0) vars["--motion-enter-stagger"] = m.entry.stagger;
+  if (m.busyDelay !== void 0) vars["--motion-busy-delay"] = m.busyDelay;
+  if (m.awaitingSkeleton !== void 0) vars["--awaiting-skeleton-display"] = m.awaitingSkeleton ? "block" : "none";
+}
+function enterKeyframe(enter) {
+  return enter === "none" ? "none" : `almadar-enter-${enter}`;
+}
+function emitIconography(i, vars) {
+  applyFlat(i, ICONOGRAPHY_VARS, vars);
+}
+function emitElevation(e, vars) {
+  applyFlat(e, ELEVATION_VARS, vars);
+}
+function emitGeometry(g, vars) {
+  applyFlat(g, GEOMETRY_VARS, vars);
+}
+function emitIllustration(il, vars) {
+  if (!il?.loadingAsset) return;
+  vars["--illustration-loading"] = `url("${il.loadingAsset}")`;
+  vars["--loader-mark-display"] = "inline-block";
+  vars["--loader-icon-display"] = "none";
+}
+function resolveThemeForRuntime(theme) {
+  if (theme === void 0) return void 0;
+  if (typeof theme === "string") return void 0;
+  return theme;
+}
+
+export { DENSITY_ELEMENT_VARS, DENSITY_SPACING_VARS, DIAGRAM_VARS, ELEVATION_VARS, GEOMETRY_VARS, ICONOGRAPHY_VARS, LEGACY_PREFIXES, MOTION_DURATION_KEYS, MOTION_EASING_KEYS, MOTION_INTENT_VARS, MOTION_SHAPE_VARS, SCENE_VARS, SURFACE_VARS, TYPE_FAMILY_VARS, TYPE_HEADING_VARS, TYPE_INTENT_VARS, TYPE_SIZE_KEYS, enterKeyframe, resolveThemeForRuntime, themeTokensToCssVars };

package/dist/chunk-42FY4RYA.js

@@ -0,0 +1,191 @@
+import { traitLevelFromDescription } from './chunk-VFF5OO47.js';
+import { useContentSurface, useEventBus, Typography, Icon, cn, domPassthrough } from './chunk-MBQAMMSE.js';
+import { useState } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+function generateItemId(item, index) {
+  if (item.id) return item.id;
+  const headerText = item.header ?? item.title;
+  if (typeof headerText === "string") {
+    return `accordion-${headerText.toLowerCase().replace(/\s+/g, "-")}-${index}`;
+  }
+  return `accordion-item-${index}`;
+}
+function normalizeItem(item, index) {
+  return {
+    ...item,
+    id: generateItemId(item, index),
+    header: item.header ?? item.title ?? ""
+  };
+}
+var Accordion = ({
+  items,
+  multiple = false,
+  defaultOpenItems,
+  defaultOpen,
+  openItems: controlledOpenItems,
+  onItemToggle,
+  className,
+  toggleEvent,
+  surface = "auto",
+  ...rest
+}) => {
+  const contentSurface = useContentSurface(surface);
+  const eventBus = useEventBus();
+  const normalizedItems = items.map(
+    (item, index) => normalizeItem(item, index)
+  );
+  const resolveDefaultOpen = () => {
+    if (defaultOpenItems) return defaultOpenItems;
+    if (defaultOpen) {
+      return defaultOpen.filter((index) => index >= 0 && index < normalizedItems.length).map((index) => normalizedItems[index].id);
+    }
+    return normalizedItems.filter((item) => item.defaultOpen).map((item) => item.id);
+  };
+  const [internalOpenItems, setInternalOpenItems] = useState(
+    new Set(resolveDefaultOpen())
+  );
+  const openItemsSet = controlledOpenItems ? new Set(controlledOpenItems) : internalOpenItems;
+  const handleToggle = (itemId) => {
+    const isOpen = openItemsSet.has(itemId);
+    const newOpenItems = new Set(openItemsSet);
+    if (isOpen) {
+      newOpenItems.delete(itemId);
+    } else {
+      if (!multiple) {
+        newOpenItems.clear();
+      }
+      newOpenItems.add(itemId);
+    }
+    if (controlledOpenItems === void 0) {
+      setInternalOpenItems(newOpenItems);
+    }
+    onItemToggle?.(itemId, !isOpen);
+    if (toggleEvent) eventBus.emit(`UI:${toggleEvent}`, { itemId, isOpen: !isOpen });
+  };
+  return contentSurface.provide(
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ...domPassthrough(rest),
+        className: cn("w-full divide-y divide-border", contentSurface.className && cn(contentSurface.className, "overflow-hidden"), className),
+        children: normalizedItems.map((item) => {
+          const isOpen = openItemsSet.has(item.id);
+          const isDisabled = item.disabled;
+          return /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsxs("div", { className: "overflow-hidden", children: [
+            /* @__PURE__ */ jsxs(
+              "button",
+              {
+                type: "button",
+                onClick: () => !isDisabled && handleToggle(item.id),
+                disabled: isDisabled,
+                className: cn(
+                  "w-full flex items-center justify-between px-4 py-3",
+                  "hover:bg-muted",
+                  "transition-colors duration-fast",
+                  "focus:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-inset",
+                  "disabled:opacity-50 disabled:cursor-not-allowed",
+                  isOpen && "bg-muted font-bold"
+                ),
+                "aria-expanded": isOpen,
+                "aria-controls": `accordion-content-${item.id}`,
+                children: [
+                  /* @__PURE__ */ jsx("div", { className: "flex-1 text-left", children: typeof item.header === "string" ? /* @__PURE__ */ jsx(Typography, { variant: "body", weight: "medium", children: item.header }) : item.header }),
+                  /* @__PURE__ */ jsx(
+                    Icon,
+                    {
+                      name: "chevron-down",
+                      size: "sm",
+                      className: cn(
+                        "transition-transform duration-fast",
+                        isOpen && "transform rotate-180"
+                      )
+                    }
+                  )
+                ]
+              }
+            ),
+            isOpen && /* @__PURE__ */ jsx(
+              "div",
+              {
+                id: `accordion-content-${item.id}`,
+                className: "px-4 py-3 border-t-heavy border-border",
+                children: item.content
+              }
+            )
+          ] }) }, item.id);
+        })
+      }
+    )
+  );
+};
+Accordion.displayName = "Accordion";
+
+// src/lib/avl-play.ts
+function armsOf(trait, from, event) {
+  return trait.transitions.filter((t) => t.from === from && t.event === event);
+}
+function armPosition(trait, transition) {
+  return armsOf(trait, transition.from, transition.event).findIndex((t) => t.index === transition.index);
+}
+function firedTransition(trait, step) {
+  if (step.result.firedArm === void 0 || !step.result.transitionFired) return void 0;
+  return armsOf(trait, step.from, step.result.event)[step.result.firedArm];
+}
+var ofTrait = (steps, orbital, trait) => steps.filter((s) => s.orbital === orbital && s.trait === trait);
+function stateMachinePlayback(trait, orbital, steps, cursor) {
+  const played = ofTrait(steps.slice(0, cursor + 1), orbital, trait.name);
+  const visitedStates = [];
+  for (const step of played) {
+    for (const state of [step.result.state.before, step.result.state.after]) {
+      if (state !== null && visitedStates[visitedStates.length - 1] !== state) visitedStates.push(state);
+    }
+  }
+  const last = played[played.length - 1];
+  if (!last) return { visitedStates };
+  return {
+    activeState: last.result.state.after ?? last.result.state.before ?? void 0,
+    activeTransition: firedTransition(trait, last)?.index,
+    visitedStates
+  };
+}
+function tracedTransition(trait, trace) {
+  const arms = armsOf(trait, trace.from, trace.event);
+  const arm = trace.firedArm;
+  if (arm !== void 0) return arms[arm];
+  const entering = arms.filter((t) => t.to === trace.to);
+  return entering.length === 1 ? entering[0] : void 0;
+}
+function tracePlayback(trait, traces) {
+  const hops = traces.filter((t) => t.traitName === trait.name);
+  const visitedStates = [];
+  for (const hop of hops) {
+    for (const state of [hop.from, hop.to]) {
+      if (visitedStates[visitedStates.length - 1] !== state) visitedStates.push(state);
+    }
+  }
+  const last = hops[hops.length - 1];
+  if (!last) return { visitedStates };
+  return { activeState: last.to, activeTransition: tracedTransition(trait, last)?.index, visitedStates };
+}
+function describedTransitionLines(description, running, transition) {
+  const printed = traitLevelFromDescription(description);
+  if (!printed || !description.source) return void 0;
+  const match = armsOf(printed, transition.from, transition.event)[armPosition(running, transition)];
+  const lines = match ? description.source.transitions.find((l) => l.index === match.index) : void 0;
+  return lines ? { start: lines.start, end: lines.end } : void 0;
+}
+function transitionPlayback(trait, orbital, transition, steps, cursor) {
+  const arm = armPosition(trait, transition);
+  const played = ofTrait(steps.slice(0, cursor + 1), orbital, trait.name);
+  for (let i = played.length - 1; i >= 0; i--) {
+    const step = played[i];
+    if (step.from !== transition.from || step.result.event !== transition.event) continue;
+    const fired = step.result.transitionFired && step.result.firedArm === arm;
+    const guard = step.result.guards?.find((g) => g.arm === arm);
+    if (fired || guard) return { step, fired, ...guard ? { guard } : {}, effects: fired ? step.result.effects : [] };
+  }
+  return void 0;
+}
+
+export { Accordion, armPosition, armsOf, describedTransitionLines, firedTransition, stateMachinePlayback, tracePlayback, transitionPlayback };

package/dist/chunk-5QTYQTPS.js

@@ -0,0 +1,15 @@
+// src/types/slot-host.ts
+function assertUniqueSlotsPerHost(manifest) {
+  const seenBySlot = /* @__PURE__ */ new Map();
+  for (const [regionId, region] of Object.entries(manifest.regions)) {
+    const existingRegionId = seenBySlot.get(region.slot);
+    if (existingRegionId !== void 0) {
+      throw new Error(
+        `assertUniqueSlotsPerHost: regions "${existingRegionId}" and "${regionId}" both bind slot "${region.slot}" \u2014 a slot may be mounted by only one region per host.`
+      );
+    }
+    seenBySlot.set(region.slot, regionId);
+  }
+}
+
+export { assertUniqueSlotsPerHost };