277 Commits (912be7769a55d80c888850a833cdb682ae4676e3)

 

All Branches   

Search

Author	SHA1	Message	Date
dev	48b646ecc4	demos/switch: full Sema tab visualisations matching toggle ... The earlier switch demo Sema tab was a stub linking to the toggle docs page. Now it ships the full per-channel signature cards (motion preview with x8 amplification, sound spectrum bars, color affects, presence preview), the live intent picker, and the Play button that fires on the live switch via uix.semantic.emit. Mirrors the structure used in toggle so the two pilots stay symmetric for future migrations. The play-button targets data-switch (was data-toggle in the toggle demo). The intent-picker drives the same `intent` state that the soma-driven recipe consumes through data-color, so Play replays motion + sound + the data-color theme on the actual track without flipping state. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	4d26761263	docs + switch: align active docs to canon, migrate switch to eidos wrapper ... Phase 4 (docs alignment with the canonical guide): - active_architecture.md — Dialog example refactored to the new event shape (target inside semantic, explicit verb + sequence). Verbs table grouped by family with the post-canon vocabulary (select/ toggle moved to commit, edit removed from handle, new verbs added). Section 10 (Estado actual) updated to 2026-05-08 with current progress: doctrina cerrada, eidos en producción, SoundChannel eager-init, switch migrated, etc. "Para profundizar" §14 points at the canonical guide. - morfo/README.md — Step 5.5 added covering the doctrinal event shape with all fields (semantic.family, .verb, .target, .sequence, .intent) and the two naming shapes ({verb}-{variant} and {family}-{verb}). - sema/README.md — verbs section restructured to Record-by-family matching the runtime; documents the verbs that moved between families per the canon. Naming shapes section updated with both forms and validateEventName signature. - CLAUDE.md — "Session hand-off" rewritten with the post-canon state. Pointer at GUIA_IMPLEMENTACION_SEMAUIX.md as the canonical source. Pending list refreshed: switch is the immediate next component, persistence/a11ySemantic/polymorphism deferred until real consumers appear. Switch migration to the eidos wrapper pattern: - morfo/components/switch.ts — adds events: [{ commit-toggle }] with the doctrinal shape (verb=toggle, sequence=post, intent fromProp binding to the 4 supported intents). New data-* (data-color with the 6-token Toggle/Switch subset, data-readonly, data-invalid, data-required) and corresponding aria-*. scope expanded to ['soma', 'sema']. - soma/components/switch/types.ts — adds intent, color, readonly, invalid, aria-labelledby props with full JSDoc. Subset constrained per guide §3.1 (Toggle/Switch row). - soma/components/switch/switch-provider.svelte.ts — runtime-direct, Field integration via FieldProvider.get(), isDisabled/isReadonly/ isRequired/isInvalid OR-merge derivations, intent ↔ color resolution (intent wins when evaluative), runtime.trigger( 'commit-toggle') in onclick. - soma/components/switch/components/switch.svelte — wires the new props through bindProps. - eidos/components/switch/{switch.css, switch.svelte, types.ts, index.ts, README.md} — full subdirectory pattern, mirroring toggle. Recipe drops legacy success/warning/danger/info selectors; declares the 6 doctrinal data-color values directly. Wrapper auto-renders Switch.Thumb inside the track and exposes an optional `thumb` snippet for in-thumb glyphs. - eidos/components/switch.css (legacy flat) deleted; eidos/index.css updated to import the subdirectory recipe. - web/routes/switch/+page.svelte — interactive testbed with all soma props as live controls + tabs (Live, Soma, Morfo, Sema, Eidos, Notes). Mirrors toggle's structure. npm run check holds at the 39-error baseline. Tests 217/217 green. Pending: - Migrate collapsible / dialog / drawer / popover / toast / avatar to the eidos wrapper pattern. - Persistence + holds-by-intent — defer until first signal.warn / signal.alert consumer. - a11ySemantic + polymorphic events — defer until concrete need. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	d4dfdaffa9	sema/morfo/eidos: align with GUIA_IMPLEMENTACION_SEMAUIX (canonical guide) ... The new doctrinal guide at src/docs/GUIA_IMPLEMENTACION_SEMAUIX.md supersedes src/docs/sema-implementation-guide.md and locks the canonical vocabulary, event shape and color tokens. This commit aligns the codebase to that canon in three concrete moves. Phase 1 — sema/verbs.ts vocabulary: - Restructured from flat array to family-keyed Record per the guide. - Moved select / toggle / acknowledge → commit (these fix state, not contact). Removed edit from handle (it's shift.enter-mode now). - Added new verbs per the canon: contact (tap, focus, trigger, release), commit (complete, restore, expire, set, remove, reorder), signal (remind), handle (rotate, scroll, reorder), shift (route, step, return, context), sustain (start, loading, waiting, syncing, processing, streaming, pending, retrying, end). - validateEventName now recognises both naming shapes: {verb}-{variant} (head=verb) and {family}-{verb} (head=family). - New helper familyForVerb. Tests rewritten — 16/16 green. Phase 2 — morfo event shape: - target moved from event-level into event.semantic. Adds optional semantic.verb (advisory, validated against SEMA_VERBS[family]) and optional semantic.sequence ('pre' | 'coincident' | 'post'). - compile.ts and schema.ts updated. The 22 events across toggle, toast, popover, drawer, dialog refactored to the new shape with explicit verb + sequence. - Polymorphic capability (allowedFamilies + defaultSemantic) and a11ySemantic deferred — no current consumer needs them; will land when the first concrete usage appears. Phase 5 — color tokens (doctrinal 8): - themes/base/light.css and dark.css rewritten to expose primary, secondary, neutral, affirm, fulfill, risk, threat, loss. Renames success→fulfill, warning→risk, danger→threat (same hex). New primitives for secondary (slate-blue), affirm (teal-mint, low activation), loss (deep violet-grave, posterior). info palette deleted entirely — per guide, "info no es intent, es signal.announce + neutral". - _static.css legacy compatibility aliases (--color-bg, --color-success, --color-error, --color-accent, ...) deleted. Clean cut, no transition. Consumers reference doctrinal palettes directly. - 29 consumers (token files + recipes) migrated: - All --*-color-info-* declarations dropped. - Component palettes extended with secondary / affirm / loss. - switch + checkbox recipes updated to use [data-color='affirm'| 'risk'|'threat'|'secondary'] (was 'success'|'warning'|'danger'| 'info'). - toast tokens + recipe renamed to affirm/fulfill/risk/threat/loss (was success/error/warning/info). - meter, progress, mark, badge, button tokens renamed. - Contracts (contracts/contract.css + contracts/components/*) updated. - focus-ring-color-error in themes now points to --color-risk-border (validation errors are signal.warn + risk per doctrina, not threat). Phase 4 (partial): - src/docs/sema-implementation-guide.md deleted (superseded by the canonical guide). Tests: 217/217 green across uix. npm run check holds at the 39-error baseline (all pre-existing in unrelated test files; none introduced). Pending in follow-up commits: - Update active_architecture.md, sema/README.md, morfo/README.md, CLAUDE.md to reflect the canon. - Switch component migration to the eidos wrapper pattern. - Persistence field (untilAction / untilFix / stateBound) and holds-by-intent — defer until the first signal.warn / signal.alert consumer appears. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	2d35f4b3e9	docs: prune obsolete audits + studies, refresh remaining references ... Deleted 60 obsolete documents that no longer reflect the active-uix state: - 47 per-component audit logs (*-audit.md, audit_N.md, AUDIT.md) - 5 global soma audits (AUDIT_1, codex_audit, soma-audit-04-20/21, audit-prompt template) - 5 closed studies (soma/study, morfo/study, morfo/DESIGN, morfo/ PROVIDER_STUDY_2026-04-23, uix/CONTINUITY_2026-04-24) - 2 superseded refactor proposals (refactor_claude, refactor_code) - 1 stale bug log (form/BUG-onchange-onblur-hang — repro path src/routes/test/sium/kitchen-sink no longer exists) Updated the remaining operational references to drop dead links and reflect the post-cleanup architecture: - src/uix/README.md — rewritten links section, dropped pointers to terra/air/CONTINUITY/refactor docs, updated adom/dom paths - src/uix/active_architecture.md — header now dated 2026-05-08, lists the major shifts since 2026-04-26 (provider inheritance dropped, eidos in production, doctrina parte IV, sound eager-init); pendings section reflects the eidos migration roadmap; "see also" purged of deleted files - src/uix/morfo/README.md — file tree updated (removed DESIGN/study, added compile/runtime/PERMUTATION_RUNNER); see-also pruned - src/uix/sema/README.md — SoundChannel section now describes the eager-init pattern (constructor-time, not lazy); pointer to sema-implementation-guide added - src/uix/soma/README.md — drops terra/air mentions, declares the actual dependency direction (eidos -> soma, not the reverse) - src/uix/soma/SOMA_ARCHITECTURE.md — §15 rewritten as "Estado actual y deuda histórica" reflecting Provider-inheritance-drop; demo path updated to web/routes/ - src/uix/soma/COMPONENT_GUIDE.md — A23 dates section now points to $libs/days (no external/dates façade); demo paths swapped from /test/soma/* to web/routes/ - src/uix/morfo/PERMUTATION_RUNNER.md — paths swapped to web/routes/ with a relocation note - CLAUDE.md — Refactor Documents section replaced with Reference Documents pointing to per-layer READMEs npm run check holds at baseline (39 pre-existing errors, none new). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	f5a2a7fb49	eidos: pilot wrapper pattern + doctrinal API conventions ... Toggle as the eidos pilot: subdirectory layout (recipe + Svelte wrapper + types + index + README) replacing the flat CSS-only form. Pattern is documented in eidos/components/README.md and the toggle README. Shared types live in eidos/lib/types.ts. First export is `Size` (8 values xxs..xxl + full); components narrow with `Extract<Size, ...>` per the per-component-subset doctrine. No `Eidos` prefix on types — module path already conveys the layer. API doctrine: - soma stays compound (Toggle.Provider) for symmetry with multi-part - eidos exports both default + Provider so single-part components accept both `<Toggle>` (ergonomic) and `<Toggle.Provider>` (compound-style consumers) SoundChannel eager-init fixes the autoplay race: AudioContext is created + resumed synchronously on the first user gesture (capture-phase listener registered in the constructor), avoiding the previous race where the first emit() scheduled the resume in a microtask outside the gesture window. Demo page (web/routes/toggle/+page.svelte) restructured so the live preview renders ALWAYS above the tablist — Sema-tab Play buttons can fire on the real toggle. Motion preview amplifies scale ×8 visually only; doctrinal values stay in the <dl>. Conventions 7-13 added to src/docs/sema-implementation-guide.md covering: directory structure, wrapper composition, no Eidos prefix, soma compound vs eidos flat, iconOnly sr-only body, sound eager-init, docs-preview amplification. CLAUDE.md gets a session hand-off block listing where things stand and next concrete steps (migrate switch/collapsible/dialog/drawer/popover/ toast/avatar; wire topbar sound mute to masterGain; rename theme tokens to drop the success/warning/danger fallback aliases). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	4546e448bd	demos: web/routes/* for the 8 migrated soma components ... First demos under the new web/routes location (configured by phase C of the cleanup as `kit.files.routes`). One demo per component: toggle, switch, collapsible, avatar, dialog, drawer, popover, toast. Layout (web/routes/+layout.svelte): - Bootstraps the UIX via createActiveUix({ lang: { schema: {}, defaultLocale: 'es' } }) — minimal config, full UIX surface. - Wraps in <Uix> which sets the active-uix context and creates the Soma scope so providers can require it. - Imports the eidos index.css so the visual layer is applied. - Tiny demo-only stylesheet (web/routes/layout.css) for the page chrome (topbar, demo grid, sections) — explicitly NOT part of eidos. Each demo page exercises the public API: - toggle: bound, initially-pressed, disabled - switch: bound, disabled - collapsible: bound show/hide, disabled trigger - avatar: loaded, error fallback, delayed - dialog: basic with overlay + focus trap + escape dismissal - drawer: right / left / bottom (with handle) - popover: click + hover trigger - toast: 4 intents (fulfill, risk, threat, neutral) via createToaster Verified end-to-end with scripts/demo-probe.ts (Playwright): - All 9 routes (landing + 8 demos) serve 200. - Zero console errors except avatar's pravatar.cc network failure (sandbox limitation, not a real bug). - Interactive checks: dialog open shows modal + overlay backdrop + focused Cancel button; popover open positions floating content next to trigger; toast Fulfill shows the green-tinted shadow driven by data-event-intent='fulfill' from sema's visual channel reacting to the morfo's announce event semantics — confirms the full morfo → sema → eidos pipeline works end-to-end on a migrated soma component. scripts/demo-probe.ts: small Playwright runner that loads each route, captures console errors, takes a screenshot of the static state, then clicks the trigger on dialog/collapsible/popover/toast for a second "open" screenshot. Output goes to g:/tmp/demos/. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	1b9740f50d	soma/{dialog,drawer,popover,toast}: Phase A — runtime-direct migration ... Closes Phase A of the soma cleanup. Every soma component that was already runtime-aware (Toggle, Switch, Collapsible, Avatar from prior commits + the four in this commit) now lives without the `Provider<T>` inheritance. Pattern applied to each (8 classes total across the four components): - Drop `extends Provider<...>`. Each class is plain. - Drop module-level `createAttrs(morfo)` and `registerContract(morfo)` side-effect calls. - Drop `super(opts, ...)`. Constructors inline: root: this.opts = opts; XxxProvider.ctx.set(this); … child: this.opts = opts; this.provider = XxxProvider.require(); … - Drop `assertProps()` wrapping. Eidos `lint.ts` covers contract validation at design time; morfo type system covers enum mismatches at compile time. - `props` derived: `{ ...runtime.partProps(part), …overrides }`. - For sub-parts that own a per-instance prop (Title.level, Toast.Action.altText), pass the source through `registerPart(..., { props: { x: () => opts.x.current } })` so resolution stays local to that part's effect. - For ref-tracking callbacks (Dialog/Drawer/Popover content/overlay, Drawer trigger/handle), use `registerPart(..., { onRefChange })` instead of the legacy `super(opts, spec, undefined, onRefChange)`. Component-specific notes: - Dialog: 7 classes; root tracks parent + nesting via context lookup BEFORE `ctx.set(this)`. `dismissWith(action)` API kept identical. - Drawer: 8 classes; gesture/snap/handle plumbing untouched. The drawer morfo doesn't declare `value:` sources for `data-state`, `data-side`, `data-dragging`, etc., so those stay as inline overrides in each part's `props` (component-specific computed state, not morfo contract). To be lifted into the morfo as a follow-up if it pays off in eidos selectors. - Popover: 8 classes; floating layer (`FloatingProvider`/Anchor/ Content/Arrow) wires through unchanged. - Toast: 7 classes; multi-runtime structure preserved — root runtime carries Viewport, each Item creates its own runtime so `partRef('item')` resolves to that toast's element. Title / Description / Action / Close inside an Item register on the Item's runtime, not the root's. - alert-dialog: small drive-by — `this.dialog.soma?.langs.ts(…)` became `Soma.get()?.langs.ts(…)` because `DialogProvider.soma` is no longer an instance field. Verified: 209/209 UIX tests green; TS clean for all migrated files (remaining repo-wide TS errors pre-existing, unrelated). After this commit: - 8 soma components are runtime-direct (toggle, switch, collapsible, avatar, dialog, drawer, popover, toast). - ~52 components still use `Provider<T>` via the legacy `baseProps + resolveMorfoProps` path. Those will migrate as Fase B — opportunistically (each time one is touched for another reason) rather than in a sweep, per the user's standing preference for small, surgical commits. - The `Provider<T>` base class stays as transitional infrastructure until Phase B drains. Final deletion lands in Phase C. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	74c8b2e189	soma/{switch,avatar}: pilots 3+4 — runtime-direct, drop Provider inheritance ... Same migration shape as toggle / collapsible. After 4 pilots the pattern is consistent enough to extract a tiny base class — that's a follow-up commit. Switch (root + Thumb) — exercises `runtime.keydown` for action dispatch (Enter / Space → 'toggle' action that calls `preventDefault()` before flipping state). Avatar (root + Image + Fallback) — exercises a multi-part component where one child (Image) drives a watch.pre side effect to preload the image and update parent state, and another (Fallback) reads the parent's `status` reactively. Per-class diff in both files: - drop `extends Provider<...>` - drop module-level `createAttrs(morfo)` and `registerContract(morfo)` - drop `super(opts, ...)` calls; root inlines `ctx.set(this)`, children inline `this.opts = opts; this.provider = Parent.require()` - drop `this.assertProps(...)` wrapping in `props` derived - drop `WithRefOpts` extension; inline `id: Active<string>; ref: State<HTMLElement | null>` per child opts shape (more opt-in) Avatar's `AvatarFallbackOpts` keeps `ref: State<HTMLElement | null>` required because the fallback always renders DOM. `AvatarImageOpts` and the root `AvatarOpts` derive from props via `OptsFromProps`. Verified: 209/209 UIX tests green, TS clean for both files. After this commit the migration sample is: - toggle (single part, no ctx) - switch (single part + ctx + actions/keyboard) - collapsible (3 parts + ctx + cross-part id sources via partRef) - avatar (3 parts + ctx + side-effect watch.pre + multi-state) Common shape across all four: - `readonly opts: T;` declaration + `this.opts = opts` assignment - root: `XxxProvider.ctx.set(this)` (when ctx present) - root: `Soma.require()` + `soma.uix.runtime(morfo, sources)` + `runtime.registerPart('provider', { id, ref })` - children: `this.provider = XxxProvider.require()` + `parent.runtime.registerPart(part, { id, ref })` - `props` derived → `{ ...runtime.partProps(part), ...customProps }` The 60+ unmigrated components still use the legacy `Provider<T>` base (baseProps + resolveMorfoProps path). That class stays put until those components are also runtime-aware. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	7d125262d8	soma/collapsible: pilot — drop Provider inheritance (multi-part + context) ... Second pilot. Collapsible exercises the multi-part case Toggle didn't: 3 providers (root + Trigger + Content), one shared morfo runtime created by the root, and Svelte context wiring so children can find the parent. The migration shape mirrors Toggle but factors in the extra plumbing. What changed: - All three classes (`CollapsibleProvider`, `CollapsibleTriggerProvider`, `CollapsibleContentProvider`) drop `extends Provider<...>`. - Root: `CollapsibleProvider.ctx.set(this)` is called manually in the constructor (replaces the implicit `super(opts, spec, ctx)` setup). The `context()` helper from `\$soma/provider/context` is independent of the `Provider` base class and remains unchanged. - Children: just store `this.opts = opts` and look up the parent via `CollapsibleProvider.require()`. No `super(opts, spec)` call. - Drop module-level `createAttrs(collapsibleMorfo)` and `registerContract(collapsibleMorfo)` — same dead-side-effect pattern Toggle had. - Drop `assertProps` in every `props` derived. Eidos linter + morfo types cover what the runtime contract validation did. What stayed identical: - Public surface — `CollapsibleProvider.create(opts)`, `CollapsibleProvider.require()`, `state.props`, `state.toggle()`. - The shared-runtime pattern: root creates `uix.runtime(morfo, sources)` once; children call `parent.runtime.registerPart('trigger' | 'content', { id, ref })`. This is what the morfo runtime was designed for. - The `triggerId` / `contentId` cross-part state sources for `partRef` resolution. Children publish their id via direct assign (per the "id registration: direct assign" rule, not \$effect). - All 209 UIX tests green. Note on `WithRefOpts`: the `Provider` base used `extends WithRefOpts, StateProps<...>, ActiveProps<...>` to compose the opts type. Without the base, the migrated classes inline `id: Active<string>; ref: State<HTMLElement | null>` directly. Tradeoff: a couple of extra lines of opts shape per class, but the type composition is now opt-in (children that don't need a ref can omit it) instead of mandated by inheritance. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	bf49f22b64	soma/toggle: pilot — drop Provider inheritance, use MorfoRuntime directly ... First soma component to live without the `Provider` base class. Toggle already used `uix.runtime(toggleMorfo, sources)` for the morfo-derived attrs since an earlier refactor; this commit removes the residual inheritance + dev-time validation scaffolding that was no longer pulling its weight. What changed: - `ToggleProvider` no longer extends `Provider<ToggleOpts>`. It is a plain class that owns `opts`, the field hookup, and the runtime. - Drop the module-level `createAttrs(toggleMorfo)` (dead — return value was unused) and `registerContract(toggleMorfo)` (the contract registry is only read by `assertContract`, which we no longer call for this component). - Drop `super(opts, { morfo: toggleMorfo, part: 'provider' })`. The runtime's `registerPart('provider', { id, ref })` already attaches the ref via `attachRef` internally. - Drop `this.assertProps(...)` wrapping in the `props` derived. The eidos linter (`scripts/eidos-lint.ts`) already validates emitted selectors against the morfo's `cssSelectors` contract at design time, and the morfo type system catches enum mismatches at compile time. Runtime contract validation was belt-and-suspenders. What stayed identical: - Public surface (`ToggleProvider.create(opts)`, `state.props`, `state.snippetProps`). - `OptsFromProps`/`bindProps` from `\$soma/provider/opts` — those helpers are independent of the `Provider` class and remain useful. - The wrapper `toggle.svelte` is untouched; it still consumes `state.props` and `state.snippetProps` as before. - All 209 UIX tests green. The `Provider` base class is intentionally not deprecated. The other 60+ soma components still depend on it. Toggle proves the pattern works for runtime-only components; future migrations follow per concrete need (a 2nd consumer of the new pattern justifies extracting shared bits, per the "no premature abstraction" rule). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	52532f5542	soma/provider: dedupe against the morfo compiler (Phase 2b minimal) ... The Provider base class re-implemented every helper from the morfo resolver verbatim — 9 functions plus its own `resolveMorfoProps` walk. The runtime already routes through `compileMorfo` + `evalAttrPlan` since Phase 2a; the Provider is now wired the same way. What changed in soma/provider/provider.svelte.ts: - Drop the local `findMorfoPart`, `shouldEmitMorfoEntry`, `resolveMorfoPrimitiveSource`, `resolveMorfoSource`, `resolveMorfoDataValue`, `resolveMorfoAriaValue` (~75 LOC of literal duplication of resolver.ts). - Drop the manual `resolveMorfoProps` walk (~28 LOC). New body is seven lines: spread `compiledPart.staticAttrs`, then `evalAttrPlan` each `dynamicAttrs` plan and skip undefined results. - Drop the `createAttrs(spec.morfo)` call from the constructor; read `compiled.parts.attrs[part]` directly. No semantic change. - Drop the `findMorfoPart` walk for the part metadata; read `compiled.parts.byKebab.get(part)` (O(1)). - `_morfoPartMeta: MorfoPart | undefined` becomes `_compiledPart: CompiledPart | undefined`. Same role, richer info. Net diff: provider.svelte.ts goes 287 → 149 lines (-138). What stayed identical: the public API (`baseProps` getter, `assertProps` helper, `resolveMorfoProps(bindings)` signature, the dual constructor overload for legacy subclasses without a morfo spec) plus the behavioral contract — same context registration, same data-attr contract validation, same prop snapshot shape for subclass `\$derived.by` blocks. Subclasses are not touched. Side effect: `resolveMorfoProps` now emits ARIA boolean values as the literal strings 'true'/'false' (via `evalAttrPlan`'s `aria-boolean` mode) instead of JS booleans. Aligns the Provider with the morfo runtime's behavior (resolver.ts already returned strings; only provider.svelte.ts had been emitting booleans). Svelte stringifies both identically when spread onto an element, so the rendered DOM is unchanged. All 209 UIX tests still green. Also re-export the compile.ts surface (`compileMorfo`, `evalAttrPlan`, `CompiledMorfo`, `CompiledPart`, `AttrPlan`, `KeyboardPlan`, `ActionPlan`, contracts, etc.) from `\$uix/morfo` so consumers don't have to dig into the file. Fix a stale comment that still pointed at the deleted `\$uix/lib/types`. Phase 2b proper (kernel rewrite with the 8 abstractions: ComponentInstance / PartScope / PartRegistry / SourceRegistry / ActionDispatcher / SemanticEmission / LayoutFacts / BehaviorRegistry) is parked on purpose. None of those abstractions has two concrete consumers today; deduplicating against the existing compiler is the honest first move and unblocks any future kernel work without churn. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	7fe9cbffc4	morfo: wire MorfoRuntime to consume CompiledMorfo (Phase 2a) ... The runtime is now the first production caller of `compileMorfo`. Each per-tick effect previously walked the raw morfo tree; now it reads pre-resolved plans off the compiled output. What changed in runtime.svelte.ts: - Single `compileMorfo(morfo)` call at the top (cached by WeakMap, so multiple component instances of the same morfo share the result). - `findMorfoPart` linear scan → `compiled.parts.byKebab.get(...)` O(1). - `createAttrs(morfo)` walk → `compiled.parts.attrs` (pre-built). - `findEvent` linear scan → `compiled.actions.byName.get(...)` O(1). - `resolvePartAttrs` per-effect walk over `data` + `aria` arrays → `{ ...staticAttrs, ...evalAttrPlan(plan, bindings) for plan in dynamicAttrs }`. `staticAttrs` (literals + role) are pre-resolved at compile time; only `dynamicAttrs` is re-evaluated per tick. - Keyboard matching: `matchesKeySpec(specString, event)` re-parsed the string every keystroke. Now the compiler emits `KeyboardPlan` with a precomputed `ParsedKey`; matching is a flat field compare. - Event dispatch uses `ActionPlan` (compiled view) instead of raw `MorfoEvent`. `event.target.target` partRef-unwrap → `action.target`. What was added in compile.ts: - `evalAttrPlan(plan, bindings)` — evaluates one AttrPlan: short-circuits on falsy condition, then branches once on `mode` instead of on `source.kind` × `values.length` × `value.kind` per tick. Reuses the pure helpers in resolver.ts (`shouldEmitMorfoEntry`, `resolveMorfoSource`). - Bug fix in `parseKey`: do not trim the literal key segment. `' '` (Space) was being collapsed to empty string. The pre-existing `matchesKeySpec` had a comment warning about this; the refactor needed to preserve the same invariant. Caught by an existing runtime test (Switch keyboard with Enter+Space). Verified: 209/209 UIX tests green (morfo + soma + sema + eidos + active-uix). The remaining 2 TS errors in runtime.svelte.test.ts (lines 366 and 385) are pre-existing test casts and unrelated. resolver.ts is no longer called from runtime.svelte.ts directly except for the two pure helpers `shouldEmitMorfoEntry` (used by evalAttrPlan and by keydown's condition check) and `MorfoBindings` (the binding shape). The non-pure walk functions (`findMorfoPart`, `resolvePartAttrs`) remain in resolver.ts for any consumer that still imports them, but the runtime no longer does. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	ba487dfc62	soma/form: align with the new ecosystem ... The form component still imported from paths that were deleted in the active-uix cleanup: - form.svelte: \$lib/sium/svelte (SiumProvider) - form-auto-fields: \$lib/sium/core (Schema, SchemaKind, SiumShape) \$langs (LangInstance) Changes: - form.svelte: drop the SiumProvider context fallback. The form receives the schema via the `schema` prop (or none, for forms with only `defaults`). The old fallback let a parent context inject the schema implicitly; that was a single-call-site coupling and the new ecosystem has no equivalent context yet. Re-introduce it later via a soma-level scope only if a second consumer asks for it (2-of-3 rule). - form-auto-fields.svelte: \$lib/sium/core → \$sium (Schema, SchemaKind, SiumShape are re-exported from the package barrel) \$langs (LangInstance) → \$lang (ActiveLang). The CompatibleLang Pick<…, 'ts' | 't'> shape stays identical since ActiveLang carries the same surface. Verified: svelte-check errors went 46 → 42 (the 4 form errors are gone; remaining 42 are pre-existing in other components unrelated to the cleanup). No form tests exist anymore (both were deleted in earlier phases as casualties of the same import drift). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	8df2e9f748	uix: relocate Layer + PartRef to src/uix/types.ts ... When src/uix/lib/types.ts went down with the rest of src/uix/lib/ in phase A of the cleanup, the Layer and PartRef cross-layer primitives went with it. Three files still imported them via `'../lib/types'`: - src/uix/sema/types.ts - src/uix/morfo/types.ts - src/uix/morfo/compile.ts Move the two types to src/uix/types.ts (top-level shared, sibling to all UIX layers — no layer "owns" a cross-layer primitive), translate the doc comment to English, and update the three importers to `'../types'`. No semantic change. Verified: svelte-check went from 49 errors to 46 (the 3 caused by the deletion are gone); the remaining 46 are pre-existing and unrelated. Vitest: morfo + eidos + sema = 136/136 green. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	c69b8be32a	cleanup phase E follow-up: drop dead form test + fix doc rot ... - Remove src/uix/soma/components/form/components/form.svelte.test.ts — same casualty as the auto-fields test removed in phase B: imports from \$langs and \$lib/sium/* (both deleted). - Update arts/session/ssr.ts JSDoc example: \$lib/app → \$active-app. Note: form.svelte and form-auto-fields.svelte themselves still import from \$lib/sium/* and \$langs. They will not compile against the new ecosystem and need a rewrite or deletion as a separate decision — flagged but not changed here. Also note: src/arts/cache/test/engine-cache.test.ts fails with "defineActiveCache is not a function". The test file is untracked (was never committed); the failure predates this branch and is not caused by the cleanup. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	3e4c0ece44	cleanup phase D: rewrite CLAUDE.md to reflect new architecture ... Drops references to terra/air/lib (deleted in phases A-B). New architecture section: arts/libs/svrs at the runtime + helper layer; uix/{morfo, sema, soma, eidos, active-uix} at the UI layer, with morfo as the cross-layer contract (compileMorfo + cached contracts.cssSelectors). Path-alias table updated to match svelte.config.js / vite.config.ts after phase C. Build/test commands point at the new test paths. Critical-rules block: drop "NEVER modify terra source code" (terra is gone) and the soma-audit references (legacy markdown). Keep "NEVER delete files without explicit instruction" — this cleanup happened under explicit user direction, the rule still holds. Auto-memory in ~/.claude/projects/...: dropped feedback_terra_readonly, feedback_air_wrapper_children, feedback_follow_terra_patterns, feedback_architecture_fidelity, feedback_layout_kills_outlines (refs deleted src/routes/layout.css), feedback_check_dias_before_porting (consolidated into feedback_date_library), project_terra_air_dead, project_session_state, project_activeapp_refactor. Added project_active_uix_cleanup with the new state. Updated feedback_date_library to point at \$libs/days. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	8e800031fe	cleanup phase C: reconfig SvelteKit + aliases + web/routes skeleton ... svelte.config.js / vite.config.ts: - Drop dead aliases: \$lib, \$glob, \$langs, @/ling, @/logr, @/glob, @/actx, @/uiux, \$terra (their target dirs were removed in phase B). - Add \$reactive at the top level (was previously hidden under the "legacy" block; the target src/libs/reactive is current). - Set kit.files.routes to "web/routes" — demos move out of src/ and will be re-authored from scratch alongside the new architecture. - vite.config.ts: extract the alias map into a single `aliases` const shared by both Vite resolve and the server-test project, instead of duplicating it. web/routes/+layout.svelte + +page.svelte: minimal SvelteKit boot so `npm run dev` and `npm run build` find a routes tree. Real demos (active-uix, soma, morfo, sema, eidos) will be added as sibling routes once the runtime is wired. Verified: `npx svelte-kit sync` regenerates .svelte-kit/tsconfig.json without any of the dead aliases. .svelte-kit/types/web/routes/ is populated, confirming the new routes path is active. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	0a3914086c	cleanup phase B: delete obsolete UI layers + legacy lib ... Removed in this commit: - src/uix/air/ — old visual layer (~2.5k files) - src/uix/terra/ — reference primitives (~765 files) - src/lib/ — legacy root: actx, ling, logr, ext, glob, util/dias, util/funcs, sium status notes, uiux (~334 files). Replaced by src/arts/, src/libs/, src/svrs/. - src/uix/soma/components/form/components/form-auto-fields.svelte.test.ts — only file in the codebase still importing from \$uix/air. Form auto-fields will be rebuilt with soma primitives if/when needed. Verified post-deletion: zero matches for `from '\$lib(?!s)`, `\$glob`, `\$langs`, `@/ling`, `@/logr`, `@/glob`, `@/actx`, `@/uiux`, `\$terra`, `\$uix/(air|lib|terra)` across the remaining src/. The new ecosystem (arts/, libs/, svrs/, uix/{active-uix, soma, sema, eidos, morfo}) is self-contained. Aliases in svelte.config.js / vite.config.ts still reference the deleted paths — that's the next commit (phase C). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	90622e5d58	cleanup phase A: delete src/uix/lib + src/routes ... `src/uix/lib/` (13 files): orphaned DOM utility layer; replaced by `src/libs/dom/` in the new ecosystem. Zero inbound imports. `src/routes/` (459 files): test routes for the dead terra/air/soma demos, plus a few stragglers under sema/eidos/sium. Demos will be re-authored fresh under `web/routes/` once the SvelteKit config is updated. No production code paths were touched — only the legacy reference implementation and its test pages. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	83d2e0d843	eidos: lint a CSS file against its morfo contract ... Consumes `compileMorfo(morfo).contracts.cssSelectors` to classify every `[data-*]` selector in an eidos CSS file: - morfo-backed: the runtime writes the attr; eidos reacts to it. - eidos-only: the marker is present (`[data-toggle]`) but at least one `data-*` is not declared on the morfo part. Legitimate design tokens (`data-color`, `data-size`, `data-variant`) and drift cases (`data-dialog-header` — a part the morfo no longer declares) both land here; the lint tool reports them so authors can decide. - invalid: the attr IS declared on the morfo, but with a value outside the declared enum. Bug. Also reports `unusedFromContract`: selectors the compiler promises that no eidos rule consumes — the inverse direction of drift. Two CLI entry points: - `scripts/eidos-lint.ts <component>` — single-component report - `scripts/eidos-lint-all.ts` — sweep across every eidos component Initial sweep finds 0 invalid, 134 eidos-only, 82 unused contract selectors across 11 components. Real drift hotspots: dialog/drawer `header`/`footer` (eidos parts the morfos don't declare), popover's `data-side × data-last-action` compounds, tooltip's `data-state='delayed-open'`. Deliberate left as-is for the user to triage — fixes belong in a separate commit. Tests cover toggle (clean baseline), dialog (drift detector for header/footer + dead `data-disabled`), and a synthetic invalid case. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	2c32c842bd	morfo: introduce compile.ts — Phase 1 of the UIX refactor ... `compileMorfo(morfo)` returns a `CompiledMorfo` with pre-resolved plans, dependency analysis, and frozen contracts. Memoised by morfo identity via `WeakMap` so the runtime pays compile cost once per morfo (HMR-friendly). What the compiled form replaces: - `createAttrs(morfo)` walk → `parts.attrs` (kebab → marker) - `findMorfoPart(parts, target)` linear search → `parts.byKebab` map - `resolvePartAttrs()` source.kind branching every effect → split into `staticAttrs` (literals + role hoisted at compile time) and `dynamicAttrs[]` (`AttrPlan` with explicit `mode`) - keyboard string parsing each tick → `KeyboardPlan` with `ParsedKey` - `flattenMorfoParts` walk per `registerContract` call → `contracts.dataAttrsByPart` + `contracts.cssSelectors` - per-part `deps.{states,props,parts,needsTranslations}` for narrow effects; aggregate `requiredSources` for cross-cutting audits Mode taxonomy (`AttrMode`): `html-presence`, `aria-boolean`, `enum`, `string`, `data-state-derived` — the runtime branches once on a discriminated union instead of re-walking source/condition/values. Tests cover: parts walking + tree links, static/dynamic split, keyboard parse, actions, CSS selector contracts, required-source aggregation, per-part deps, mapRef inner-source extraction, cache identity, frozen output, duplicate-kebab errors. 28 tests, all green. No runtime callers wired up yet — that's Phase 2 (kernel + runtime consumes CompiledMorfo). Old `resolver.ts` / `create-attrs.ts` paths remain functional for the existing runtime. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	217d6969e4	active-uix: uix.runtime(morfo, sources) auto-injects dom + semantic ... Adds a single convenience method on `ActiveUix` so soma providers stop duplicating the `dom: this.soma.dom, semantic: this.soma.semantic` boilerplate at every `createMorfoRuntime` callsite. Before (8 providers, identical lines): this.runtime = createMorfoRuntime(dialogMorfo, { dom: this.soma.dom, // ← duplicated everywhere semantic: this.soma.semantic, // ← duplicated everywhere states: { … }, props: { … }, events: { … } }) After: this.runtime = this.soma.uix.runtime(dialogMorfo, { states: { … }, props: { … }, events: { … } }) The implementation is a thin convenience — internally `uix.runtime()` calls `createMorfoRuntime(morfo, { dom: this.dom, semantic: this.semantic, …sources })`. No registry, no scope ids, no per-instance lifecycle to track. Per-provider runtime ownership unchanged. The user explicitly chose this minimal fix over a "single shared runtime + scope handles" design after weighing the tradeoffs. Migrated callsites: avatar, collapsible, dialog, drawer, popover, switch, toast, toggle (8 providers, ~10 callsites including toast's two — root + item). The `createMorfoRuntime` named import dropped from each (only `MorfoRuntime` type kept where the field is annotated). 3 new tests on `active-uix.svelte.test.ts`: - returns a MorfoRuntime with auto-injected services - caller does not pass dom or semantic - attach mode uses the external app's dom + semantic Verified: vitest 17/17 active-uix (was 14), 211/211 UIX, smoke 68/68, morfo-check 66/66.	5 months ago
dev	9009cbfe8c	active-uix: standalone mode no longer wraps active-app ... Earlier design mistake: `createActiveUix(options)` was internally calling `createActiveApp(...)` to compose the UIX services. That violated the contract — active-uix was supposed to be either a substitute for active-app (when no app exists) or a complement (when an external app injects services). Fix: standalone mode now instantiates each UIX service directly via the canonical factories — no `active-app` involved: - core: createEngineLogger, createEngineBus, createActiveTimers, createActivePrefs (with empty schema) - lang: createActiveLang(schema, defaultLocale, fallbackChain) - dom: createActiveDom - frontend: createActiveFrontend (auto-applies to <html>) - format: createActiveFormat (clock from timers) - semantic: new EngineSemantic(opts) active-uix manages every owned lifecycle: dispose() tears them down in reverse dependency order. Attach mode is unchanged — wraps an external app, validates UIX services, doesn't touch app.dispose(). Type changes: - `ActiveUix.app: ActiveApp | undefined`. Present only in attach mode (it's the underlying app); `undefined` in standalone (no app exists). - `ActiveUix.bus: EngineBus` (generic envelope). Standalone gets a fresh bus, attach gets the App's bus with its event map. UIX components don't care about typed events; consumers that do re-narrow at the call site. - Removed `prefs?` and `extraServices?` from `ActiveUixOptions`. Apps that need a custom prefs schema or services beyond UIX should use attach mode (compose `createActiveApp` themselves). New tests cover both modes: standalone (8 tests including service disposal verification, idempotent dispose, format opt-out, componentLangs registration toggle), attach (6 tests including missing-services error, identity-equal service proxying, no disposal of external app), and cross-mode parity (1 test). Verified: vitest 15 files / 211 tests, smoke 68/68, morfo-check 66/66.	5 months ago
dev	83b841a7ca	active-uix: introduce UIX layer between active-app and components ... Decouples the UIX layer (soma / morfo runtime / sema / eidos) from the App composition layer (`active-app`). UIX components no longer import `\$active-app` directly — they read services through `getActiveUix()`. Two boot paths produce the same `ActiveUix`: - **Standalone** — `createActiveUix({ lang, semantic, … })` bootstraps an `ActiveApp` internally with the UIX services plus any `extraServices`. Owns the app — `dispose()` propagates. - **Attach** — `attachActiveUix(externalApp)` wraps an app the application composed itself (typically when it has services beyond UIX: cache, session, http, …). The external app must declare the UIX services; helper `defineUixServices(options)` returns the slice ready to spread into `createActiveApp({ services })`. Does NOT own the app. In both cases components see only `ActiveUix`. They have no way to tell which boot path was used. Module: src/uix/active-uix/ ├── index.ts barrel ($active-uix) ├── types.ts ActiveUix, ActiveUixOptions, AttachActiveUixOptions ├── services.ts defineUixServices() + UIX_REQUIRED_SERVICES ├── active-uix.svelte.ts createActiveUix() + attachActiveUix() + ActiveUixImpl ├── components/uix.svelte <Uix uix={...}> wrapper (sets context + creates Soma) └── svelte/context.svelte.ts setActiveUix() / getActiveUix() / tryGetActiveUix() Surface exposed by `ActiveUix`: - UIX services: lang, frontend, format (optional), dom, semantic - Core: logger, bus, timers, prefs - Config: somaPortalTo - `app` escape hatch for advanced integration code (NOT for UIX components) Wiring done by active-uix at boot: - `App.lang.extend('components', componentLangs)` — soma component translations always available without per-app boilerplate. - Frontend service auto-configured with `applyDom: true` + `target: () => document.documentElement` so theme/dir/density land on `<html>` automatically. Migration: - `Soma.create()` reads `getActiveUix()` instead of `getActiveApp()`. Soma class no longer imports `\$active-app`. - 3 layouts (test/eidos, test/sium, test/soma) replace `createActiveApp + setActiveApp + <Soma>` with `createActiveUix + <Uix>`. Boilerplate drops ~20 lines per layout. - 7 sium pages replace `getActiveApp() + app.lang.setLocale(…)` with `getActiveUix() + uix.lang.setLocale(…)`. Validation: - `attachActiveUix(app)` throws `ActiveUixMissingServiceError` if the external app didn't declare lang/frontend/dom/semantic. - `getActiveUix()` throws `ActiveUixNoContextError` if no `<Uix>` ancestor mounted. `\$active-uix` alias wired in svelte.config.js + vite.config.ts (both client and server projects). Verified: vitest 197/197, smoke 68/68, morfo-check 66/66, playwright probe (4 routes including dialog with sound) zero page/console errors.	5 months ago
dev	5898cc58c7	libs/reactive: export ActiveProps and StateProps types ... Follow-up to 4bf6dea4 — that commit added the type definitions to `src/libs/reactive/types.ts` but the corresponding re-export from `src/libs/reactive/index.ts` was lost during the staging shuffle. Without this, `import { type ActiveProps } from '$libs/reactive'` would fail on a fresh checkout even though the consumers across soma assume those types are exported from the libs barrel (the previous commit rewrote 79 of them to that import path).	5 months ago
dev	4bf6dea420	remove backward-compat re-export shims ... Per architectural feedback: when relocating code to its correct layer, do the migration completely — update every consumer directly and delete the original. No re-export barrels at the old paths. Removed shims: - `src/uix/soma/attrs/` — was re-exporting `createAttrs` / `registerContract` / `assertContract` / `getContract` from `$uix/morfo` and the bool/data-attr formatters from `$libs/dom`. All 66 importing files updated to import from the canonical locations directly. - `src/uix/soma/reactive/` — `reactive.svelte.ts` was a thin re-export of `$libs/reactive`. The 79 consumers (every soma provider + layers + types) now import primitives directly from `$libs/reactive`. The `opts.ts` Props↔Opts bridge moved to `src/uix/soma/provider/opts.ts` (its natural home — provider plumbing, not reactive primitives). - `attachRef` / `RefAttachment` re-export from `src/uix/soma/provider/provider.svelte.ts` and from `src/uix/soma/index.ts`. Both removed. Consumers (`floating.svelte.ts`, `date-field-provider.svelte.ts`) now import directly from `$libs/reactive`. Also: - Moved `ActiveProps<T>` / `StateProps<T>` types to `src/libs/reactive/types.ts` — they're trivial generic helpers over `Active<T>` / `State<T>` and shouldn't have lived in soma. - Stripped soma's root barrel (`src/uix/soma/index.ts`) of every re-export of libs/morfo concerns. It now only re-exports actually-soma surfaces (Provider base, mergeProps, css helpers, id, types, Soma class). Result: - `grep -r '\$soma' src/uix/morfo` → 0 matches - `grep -r '\$uix' src/libs` → 0 matches - `src/uix/soma/attrs/` and `src/uix/soma/reactive/` no longer exist - Every import statement now reflects the real architectural layer Verified: vitest 19/20 files / 214 tests (1 pre-existing air dead- branch fail using `bun:test`), smoke 68/68, morfo-check 66/66.	5 months ago
dev	d9b6521020	fix dependency direction: morfo no longer imports from soma ... The previous DOM consolidation commit left a wrong-direction edge — `src/uix/morfo/runtime.svelte.ts` imported `createAttrs` from `$soma/attrs` and `attachRef`/`RefAttachment` from `$soma/provider`. Morfo is the declaration layer; soma is one of its consumers; morfo must not depend on soma. Moves: - `createAttrs` (`src/uix/soma/attrs/create-attrs.ts`) → `src/uix/morfo/create-attrs.ts`. It's a pure morfo→data-attr-name derivation; its natural home is alongside the morfo declarations it derives from. Soma is a consumer like any other. - `contracts.ts` (registerContract / assertContract / getContract) → `src/uix/morfo/contracts.ts`. Same reasoning: contracts derive from a morfo's `data: [{ values }]` enum. - `attachRef` + `RefAttachment` (extracted from `src/uix/soma/provider/provider.svelte.ts`) → `src/libs/reactive/attach-ref.svelte.ts`. It bridges Svelte's `{@attach}` system with the `State` reactive box; both ends are in libs/reactive, so it lives there. - Bool/data-attr formatters from `src/uix/soma/attrs/helpers.ts` (boolToStr, boolToEmptyStrOrUndef, boolToTrueOrUndef, getDataOpenClosed, getDataChecked, getAriaChecked) → `src/libs/dom/attrs.ts`. Pure DOM-attr value formatters with no morfo dependency — they're libs/dom material. Critical bug fix uncovered by the move: `src/uix/soma/reactive/reactive.svelte.ts` was a parallel implementation of the reactive primitive system, with its OWN `ActiveSymbol` / `WritableSymbol` instances — different from the ones in `$libs/reactive`. As soon as `attachRef` (now in libs) tried to detect a soma-created `State` via `isState`, the guard returned false and the function fell into the setter-fn branch, throwing "ref is not a function" in 10+ form tests. Fix: rewrite `soma/reactive/reactive.svelte.ts` as a thin re-export of `$libs/reactive`. They now share the same symbol identities, so every cross-layer guard works consistently. Compatibility: - `$soma/attrs` is now a backward-compat barrel that re-exports from `$uix/morfo` (createAttrs, contracts) and `$libs/dom` (helpers). Existing soma providers continue working unchanged. - `$soma/provider/provider.svelte.ts` re-exports `attachRef` / `RefAttachment` from libs for any importer that still uses the legacy path. Verified post-cleanup: - `grep -r '$soma' src/uix/morfo` → 0 matches (no morfo→soma) - `grep -r '$uix' src/libs` → 0 matches (no libs→uix) - vitest 14 files / 197 tests - smoke 68/68 - morfo-check 66/66	5 months ago
dev	9b07cead6b	uix: consolidate DOM + relocate morfo runtime to its layer ... Three architectural cleanups in one cut: 1. **morfo runtime relocates to its own layer.** The MorfoRuntime + the pure morfo→attrs resolver (and their tests) move from `src/uix/soma/morfo/` → `src/uix/morfo/`. They were never soma-specific — they interpret a morfo declaration on behalf of any consumer. Soma was just the only consumer at the time. The new barrel at `$uix/morfo` re-exports `createMorfoRuntime`, `MorfoRuntime`, `MorfoRuntimeSources`, `RegisterPartOpts`, `SourceMap`, `SemanticEmitter`, `TriggerOptions`, plus the resolver helpers (`findMorfoPart`, `resolvePartAttrs`, `shouldEmitMorfoEntry`, etc.). 2. **`src/uix/adom/` is gone.** The runtime pieces (`createActiveDom`, `BodyScrollLock`, `DOMContext`, `RovingFocusGroup`, viewport) all live at `$adom` (`src/arts/adom/`) which is the canonical ecosystem-level ActiveDom. The `apply.ts` types and helpers (`DomAttrValue`, `applyChange`, `removeAttrs`, `StructuralChange`) live in `$libs/dom` and are re-exported from `$adom`. The 4 last `$uix/adom` import sites updated to `$adom`. 3. **`src/uix/soma/dom/` is gone.** The 14 utilities (`isBrowser`, `getDocument`, `isHTMLElement`, focus + tabbable helpers, etc.) all exist as a superset in `$libs/dom`. The 12 soma consumers updated their imports from `'../dom'` / `'$soma/dom'` → `'$libs/dom'`. No functional change — purely import-path consolidation. `src/uix/active-uix/` is preserved as an empty placeholder for the future cross-layer composition class that will set up morfo + soma + sema + eidos together. The relocated runtime now imports cleanly: - `ActiveDom`, `DomAttrValue` ← `$adom` - `EngineSemantic`, sema helpers ← `$uix/sema` - `Active`, `State` ← `$libs/reactive` (was `$soma/reactive`) - `createAttrs` ← `$soma/attrs` (cross-layer; createAttrs is morfo logic that lives in soma for now — slated for relocation in a follow-up) - `attachRef`, `RefAttachment` ← `$soma/provider/...` (idem) Verified: vitest 14 files / 197 tests, smoke 68/68, morfo-check 66/66.	5 months ago
dev	a6e2c1e443	sema: align vocabulary with libro_semantica (signal, shift, loss) ... Updates the canonical semantic vocabulary to match the latest formulation in src/docs/libro_semantica_completo.txt: Families (7, was 6): contact, commit, signal, handle, emerge, shift, sustain - `alert` → `signal` (rename: same perceptual function — attention / salience — but the book's name reflects the broader scope including notify, warn, emphasize, announce). - `shift` (NEW, transitional): frame change. Modal mount, navigation, mode change. Differs from emerge in that it reorganizes planes (heavier backdrop, deeper shadow) — "cruce de umbral" not just "aparición". Per book rule, the frame doesn't carry intent on its own; evaluation belongs to a companion `signal` event. Intents (6, was 5): neutral, affirm, fulfill, risk, threat, loss - `loss` (NEW): consummated negative consequence (negative valence, low activation, posterior). Differs from `threat` (anterior, high activation, convokes action): loss registers, doesn't convoke. Per book §11.5 "la amenaza no es la pérdida". sema-map.ts perceptual values: - `signal` family entry: kept the prior `alert` numbers verbatim (semantics is the same — attention/salience) under the new name. - `shift` family entry: motion 260ms ease-in-out 0.98→1, sound pitch 500 ascending gain 0.18 (deliberately quieter than emerge's 0.20 to not compete with companion signal), presence with stronger backdrop (0.5) + shadow (blur 32 y 12 op 0.2) emphasizing plane reorganization. - `loss` intent deltas: descending sound contour (-150 pitch), contraction (scale.to -0.04, motion duration ×0.95 — brief but grave), color toward purple-grave (hue replace 280, lower saturation/intensity), withdrawn presence (backdrop 0.05, no glow). ARIA `role="alert"` (W3C live region) is unrelated and untouched in soma/announce, soma/toast and morfo announce/field/form. The toast morfo gains `loss → role:'status' aria-live:'polite'` mapping — loss is consummated so it shouldn't interrupt. Verbs added per the book's worked examples: signal {warn, notify, emphasize}, shift {enter-mode, exit-mode, navigate}, commit {save, discard, delete}, contact {press, click, hover}, handle {pick, carry, drop}, emerge {reveal, show, hide}. Verified: vitest 9 files / 99 tests, smoke 68/68, morfo-check 66/66.	5 months ago
dev	3faa4473f2	eidos/accordion: fix trigger rotating 90deg when open ... The air → eidos refactor stripped the `.air-accordion-*` class hooks but left 5 rulesets with their selector empty (just whitespace before `{`). The most visible damage was line 161: [data-accordion-trigger][data-state='open'] { transform: rotate(var(--eidos-accordion-indicator-rotation)); } Empty selector after the trailing space → the rule matched the trigger button itself instead of the intended `.air-accordion-trigger-indicator` descendant. So expanding any item rotated its title 90deg. The other four orphaned rules (trigger-main flex layout, trigger-label, indicator size/transition, content-inner padding) were dormant noise but also dropped — the morfo doesn't declare an Indicator part and the demo doesn't render the inner wrapper, so there's nothing to style. Content padding is now applied directly to `[data-accordion-content]` since there's no inner wrapper. Animation-height includes padding, which matches the natural scrollHeight measurement. Verified: - playwright probe: trigger `transform: none` in both closed and open state (was `matrix(...)` rotating 90deg before) - smoke 68/68	5 months ago
dev	930d4c8c16	soma: emit perceptual signal on open in dialog/drawer/popover ... Diagnosis: clicking "open" on dialog/drawer/popover produced no sound (or any semantic feedback). Cause: every overlay trigger was bypassing `runtime.trigger(...)` with a direct `handleOpen()` because the morfo's declared target part (overlay content) doesn't yet exist in the DOM when the trigger fires — and `runtime.trigger` was throwing when the target part had no registered ref. Fix: - `MorfoRuntime.trigger(name, opts?)` now accepts `{ fallbackTarget?: HTMLElement }`. When the declared target part is unmounted, the fallback is used as the visual signal target so the perceptual signal still fires. Sound / vibra channels don't care about the target; the visual channel writes its `data-event*` to the trigger briefly, which is the natural locus of the user's action anyway. - Dialog / Drawer / Popover triggers now go through `runtime.trigger` with the trigger element as `fallbackTarget`. Each provider's `events` map gains an `open` (or `present`) entry that runs `handleOpen()` as the runtime's handler step — preserving the prewrite → emit → handler order. - Popover's toggle uses `close-dismiss` for the close direction so both directions emit a perceptual signal, not just open. Soma class: `soma.dom` and `soma.semantic` are now non-optional again (matching pre-migration semantics — every layout declares both services). `soma.format.*` slices stay optional. Verified end-to-end with a Playwright probe that spies AudioContext construction: Open dialog → 2 oscillators (was 0) Press Escape → +2 (was 2) Click overlay → +2 (was 0) Gates: vitest 7 files / 78 tests, smoke 68/68, morfo-check 66/66.	5 months ago
dev	86f01f5d8e	sema: revive resolver + signatures + real SoundChannel ... Restores the resolver-driven architecture that was deleted in the channel-modules refactor (commit a0a1485b). Each signal now flows through a single resolution that produces an `EffectiveSignature`, and each channel reads its own slice — so the visual hold, the sound earcon, and (future) motion / color / presence channels all share a single family-level perceptual budget defined in `SEMA_MAP`. New surfaces: - `src/uix/sema/sema-map.ts` — typed perceptual map (port of the legacy `sema-map.json`) with per-family `base` (motion / sound / color / presence) + `activeChannels` and per-intent `deltas` using the number / `{op:'add'}` / `{op:'multiply'}` / `{op:'replace'}` / recursive-merge semantics from before. - `src/uix/sema/resolver.ts` — pure `resolveSignature(signal)` that returns an `EffectiveSignature`. Empty signature when family is missing so channels skip rather than throw. Intent deltas only apply to valenced families. Optional `soundPack` per-event sample URLs. - `src/uix/sema/chans/sound.ts` — real `SoundChannel` (~290 lines, ported from a0a1485b^). Single AudioContext + master GainNode, auto-unlock for Safari/iOS via `click` / `touchstart` / `keydown` with capture, ADSR-lite synthesis (sine + 5th → biquad lowpass → envelope, AM modulator when roughness > 0.2), contour via `osc.detune`, optional sample playback with `AudioBuffer` cache. Errors absorbed silently — sema is ornamental. Architectural changes: - `Channel.handle(signal, effective)` — every channel now receives the resolved signature alongside the signal. Channels can ignore it. - `EngineSemantic.emit` resolves once per emit, dispatches both args. - `VisualChannel` hold resolution chain is now (highest priority first): 1. `signal.hold` 2. `effective.motion.duration` ← NEW: from sema-map 3. family fallback table (SEMA_DURATIONS) 4. engine `defaultHold` Behavior change: families with motion in the map (alert: 220ms, contact: 80ms, commit: 180ms, …) now use those values instead of the previous label-based 600ms / 120ms / 240ms fallbacks. The fallback table remains as a safety net for families without motion (sustain). - `EngineSemanticOptions` adds `sound?: true | false | SoundChannelOptions | Channel`. Sound is opt-in (audible side effects). Layouts wire `defineEngineSemantic({ sound: true })`. Tests: - New `resolver.test.ts` (7 tests) — locks down family base, intent deltas, multiplicative ops, transitional-family no-op, deep-clone. - `visual.test.ts` — every `handle` call now passes a stub `EffectiveSignature`. Two new tests: motion.duration takes the hold, and signal.hold overrides effective.motion.duration. - `engine.test.ts` — `makeChannel` mock signature updated. - `emit.test.ts` — alert family default test now expects 220ms (from sema-map) instead of 600ms. Verified: - vitest: 6 files / 53 tests green - smoke: 68/68 soma routes 200 OK - morfo-check: 66/66 morfos validate	5 months ago
dev	9338be2662	soma+layouts: migrate App composition to createActiveApp (Phase 4 part 3) ... Replaces the legacy `$lib/ext/app` `App.create({ langs, presentation })` composition pattern with the new ecosystem's `createActiveApp({ services })` across all three test layouts (eidos / sium / soma) and rewires Soma + morfo runtime to consume the new surface. What changed: - Soma class (uix/soma/core/soma.svelte.ts) now reads from `getActiveApp()` in $active-app context and adapts its historical names over the new ecosystem: `soma.langs → app.lang`, `soma.presentation → app.frontend`, `soma.dates/nums/money/units → app.format.{dates,numbers,currency,units}`. All 12 soma component providers consume Soma unchanged. - New context bridge: $active-app exports `setActiveApp(app)` / `getActiveApp()` / `tryGetActiveApp()` (mirrors `setBus` / `getBus` from $bus). Throws `AappNoContextError` (new code APP_ERR_NO_CONTEXT) when no App is in scope. - 3 layouts (test/eidos, test/sium, test/soma) replace `App.create({ langs, presentation })` with `createActiveApp({ services: { lang, frontend, format, dom, semantic } })` + `setActiveApp(App)` and call `App.lang.extend(...)` post-construction for runtime translation modules. - 7 sium test pages migrate `App.get()` → `getActiveApp()`, `app.langs` → `app.lang`, `app.setLocale(x)` → `app.lang.setLocale(x)`. - Morfo runtime exports a tiny `SemanticEmitter` type (`Pick<EngineSemantic, 'emit'>`) so consumers and tests don't have to satisfy the full EngineSemantic surface. - soma/core/langs.ts and sium plural import migrate `LangNode` / `p` from `$lib/ext/lang/*` → `$libs/lang`. After this commit no consumer outside `src/lib/` imports from `$lib/ext/app`, `$lib/ext/lang`, or `$lib/ext/presentation`. The legacy shims under `src/lib/ext/` remain for now (Phase 5 will delete them). Verified: - svelte-check: only 2 pre-existing errors (event.ts, runtime test) - vitest: 6 files / 69 tests green (sema + morfo runtime) - smoke: 68/68 soma routes 200 OK - morfo-check: 66/66 morfos validate against demo DOM - playwright: /test/sium/{login,booking,color} + /test/eidos/toggle render full content with 0 page errors / 0 console errors - eidos recipe check: dialog provider chain end-to-end OK	5 months ago
dev	a7adfc43b1	sema: add defineEngineSemantic factory for createActiveApp composition ... Adapts EngineSemantic to the AppServiceFactory contract so apps composed with `createActiveApp` can declare semantic as a service: services: { semantic: defineEngineSemantic({ visual: { defaultHold: 400 } }) } The factory lives in `src/uix/sema/` (not in `arts/active-app/service- factories/`) because semantic coordination is a UIX-layer concern, not generic app infrastructure like cache / auth / perm. EngineSemantic itself stays unchanged — the factory just wraps it, declares no core/service deps, and disposes the engine on teardown.	5 months ago
dev	746ce8dbe8	sema: rename SemanticEngine → EngineSemantic + .destroy() → .dispose() ... Aligns sema's engine class with the new ecosystem's Engine* / Active* naming convention (per src/arts/README.md): - Engine* — public methods over private state. No reactive surface. - Active* — Engine* extended with $state + onChange listeners. Sema's SemanticEngine is purely imperative: a channel registry + an async dispatch. No $state, no listeners, no loading/lastError. So by convention it must be Engine*, not Active*. Renames (mechanical): SemanticEngine → EngineSemantic SemanticEngineOpts → EngineSemanticOptions (also aligned to EngineSiumOptions / EngineHttpOptions name) .destroy() → .dispose() (uniform with the rest of the ecosystem; only one call site, in engine.test.ts) Touched code: engine.ts, exports.ts, emit.test.ts, engine.test.ts + README.md (kept consistent). Also sweep src/lib/ext/app/{defaults, app.svelte}.ts which still mention the old name in fallback wiring. Air's docs (AIR_*.md) and the legacy CONTINUITY note kept untouched (dead branch). This commit is purely a rename. The next commit (Phase 4 part 2) adds the defineEngineSemantic factory and migrates soma + the 3 layouts to createActiveApp. Verification: sema 44/44, smoke 68/68, morfo-check 66/66. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	c3dbd47f5b	morfo/schema: migrate $lib/sium/core → $sium (Phase 3) ... Drop-in path change. The new $sium barrel ($arts/sium) re-exports the exact same surface the legacy $lib/sium/core provided: object, array, string, boolean, literal, union, discriminated, optional Schema (type) SiumValidationError Three import statements updated. Zero behavior change. Verification: morfo tests 21/21, smoke 68/68, morfo-check 66/66. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	b532b3a1e4	migrate $lib/util/* → $libs/* in soma + test pages (Phase 2) ... Mechanical sweep of legacy util imports to the new $libs/* equivalents. Drop-in: surfaces are compatible (verified per-module before sed). $lib/util/dias → $libs/days (vendored dias, exact match) $lib/util/colors → $libs/color (same exports) $lib/util/arrays → $libs/arrays (same) $lib/util/strings → $libs/strings (same) $lib/util/funcs → $libs/funcs (same) $lib/util/objs → $libs/objs (same) $lib/util/numbers → $libs/numbers (same) 28 files touched: 6 soma source files (color, color-field, color-picker providers + external/{colors,dates} adapters) + 22 test pages (date/time/range pickers, calendar, color, sium booking/color/kitchen-sink). Skipped intentionally: - src/uix/terra/** and src/uix/air/** (dead branches per memory). - src/lib/** internal references (legacy folder itself). - Documentation .md files (Phase 6 cleanup). Verification: smoke 68/68, morfo-check 66/66. Note on the bash sed escaping: first attempt with double-quoted patterns produced `$lib$libs/days` because `\\$lib` inside double quotes only matched the trailing `/util/dias` portion. Fixed by switching to single-quoted sed expressions ('s|\$lib/util/dias| $libs/days|g') so bash leaves both `$` literals alone for sed. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	62eb00fe8a	deprecate src/lib + wire new ecosystem aliases (Phase 0+1) ... Phase 0 — mark legacy as deprecated: - Add @deprecated JSDoc header to all 27 top-level barrels under src/lib (ext/{app,lang,dates,money,nums,units,presentation}, {actx,ling,logr,glob,sium,util}, root index.ts). - Add src/lib/README.md with the migration map: legacy module → new equivalent under src/arts + src/libs + src/svrs. - Zero behavior change. Only IDE strikethrough at usage sites. Phase 1 — wire new ecosystem aliases in vite.config.ts and svelte.config.js: - 18 new $arts/* aliases: $active-app, $adom, $auth, $bus, $cache, $connection, $format, $frontend, $http, $lang, $logger, $orca, $perm, $prefs, $session, $sium, $storage, $timer. - $libs (src/libs), $locale (src/libs/locale), $svrs (src/svrs). - $reactive rewired from src/lib/util/reactive to src/libs/reactive (export surfaces verified compatible — same symbols, drop-in). - Legacy aliases ($lib, $glob, $langs, @/ling, @/logr, @/glob, @/actx, @/uiux) preserved for backwards compat during migration. - SvelteKit auto-regenerates .svelte-kit/tsconfig.json paths from svelte.config.js, so TS resolution updates without manual edits. The migration plan (Phases 2-6) lives in src/lib/README.md: Phase 2 — sweep src/lib/util/* imports to $libs/* (drop-in). Phase 3 — morfo/schema.ts: 3 imports to $libs/standard-schema. Phase 4 — soma's App.create() composition to createActiveApp with explicit service slots (including semantic for sema). Only step that changes architecture. Phase 5 — sweep ~82 test pages to use new aliases. Phase 6 — remove src/lib/{glob,ling,actx} after verifying no consumers; investigate sium and util/{dates,times,timers}. Verification: smoke 68/68, morfo-check 66/66. svelte-check baseline unchanged for the alias rewire (no Cannot-find-module errors). The 2 dialog-provider possibly-undefined errors at lines 113-114 are pre-existing (this.soma vs this.soma! after Soma.get() returning Soma | undefined) — not introduced by this commit. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	800e794cea	eidos batch: Accordion + Tabs + Checkbox recipes + demos ... Mechanical translation from air's CSS (--air-* → --eidos-*, --_air-* → --_eidos-*, drop .air-* class gates): - eidos/components/accordion.css (205 lines): variants surface/ghost, sizes sm/md/lg, indicator-placement, motion-disabled. Selectors align with morfo: data-accordion / data-accordion-{item,header, trigger,content}. - eidos/components/tabs.css (222 lines): variants line/pills/surface, sizes xs/sm/md/lg, orientation. Selectors align: data-tabs / data-tabs-{list,trigger,content}. - eidos/components/checkbox.css (183 lines): states checked / unchecked / indeterminate, color variants (primary/success/warning/ danger/info/neutral), sizes. Selectors align: data-checkbox / data-checkbox-{indicator,group,group-label}. Demos at /test/eidos/{accordion,tabs,checkbox}. Layout nav + index page updated. Verification: smoke 68/68, morfo-check 66/66, all 3 pages 200. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	b5453af9c4	popover: extend morfo with events + soft-migrate provider + exit tinting ... Same harmonization pattern as Drawer (which mirrored Dialog): Morfo (`morfo/components/popover.ts`): - Added 6 events: present + 5 close-* (save/cancel/dismiss/ dismiss-outside/after-fail). present + close-cancel/dismiss/ dismiss-outside use family='emerge'; close-save uses commit/fulfill; close-after-fail uses alert/threat. - Added data-last-action to Content's data array. - scope: ['soma', 'sema']. Eidos (`eidos/components/popover.css`): - Tint rules: combine [data-state='closed'] + [data-side] + [data-last-action] to color the trigger-facing edge (opposite to the popover side) during exit. saved → success, failed → danger, cancelled/dismissed/dismissed-outside → neutral. Soma (`soma/components/popover/popover-provider.svelte.ts`): - PopoverProvider injects MorfoRuntime + dismissWith(action). - Registers content part on mount. - Wires close paths through runtime.trigger(): Close.onclick → 'close-cancel' Escape (Dismissal) → 'close-dismiss' InteractOutside → 'close-dismiss-outside' - PopoverProvider class re-exported from $soma/components/popover. Demo (`test/eidos/popover/+page.svelte`): - Tinted-exit section with Save/Cancel/Fail buttons via local _dismiss-button.svelte (mirror of Dialog/Drawer pattern). Verification: smoke 68/68, morfo-check 66/66. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	106b972075	drawer: extend morfo with events + soft-migrate provider + exit tinting ... The Drawer's "show" semantic was missing from the morfo, so close paths went straight to handleClose() without the prewrite → emit → handler cadence. User flagged this — drawer DOES have a present/dismiss semantic, equivalent in surface to Dialog. Morfo (`morfo/components/drawer.ts`): - Added `events[]` mirroring Dialog: present, close-save, close-cancel, close-dismiss, close-dismiss-outside, close-after-fail - Added `data-last-action` (saved/cancelled/dismissed/dismissed-outside/ failed) to Content's data so the prewrite has a declared slot - scope: ['soma', 'sema'] now (sema participates via signal emit) Eidos (`eidos/components/drawer.css`): - Reserved a 3px transparent border on the LEADING edge of Content per side (the edge facing the user, opposite to the slide-out direction): right→border-left, left→border-right, top→border-bottom, bottom→border-top - Tint rules: combine [data-state='closed'] + [data-side] + [data-last-action] so the right edge gets colored during the close animation (saved → success, failed → danger, cancelled/dismissed → neutral) Soma (`soma/components/drawer/drawer-provider.svelte.ts`): - DrawerProvider injects a MorfoRuntime (same pattern as Dialog soft- migration). Registers content part. Wires events.{close-save, close-cancel, close-dismiss, close-dismiss-outside, close-after-fail} to handleClose(). - dismissWith(action) public method — same API as Dialog.dismissWith. - Replaced 4 close paths with runtime.trigger(): Close.onclick → 'close-cancel' Escape (modal) → 'close-dismiss' Escape (non-modal) → 'close-dismiss' Overlay.onclick → 'close-dismiss-outside' Drag-to-dismiss (gesture) keeps direct handleClose() — the visible slide-out IS the close, no 240ms hold makes sense. - DrawerProvider class re-exported from $soma/components/drawer. Demo (`test/eidos/drawer/+page.svelte`): - New "Exit tinting by causa" section with Save/Cancel/Fail buttons that call dismissWith() through a local _dismiss-button.svelte (same pattern as Dialog's). Verification (playwright): save t=83ms lastAction=saved hold=240ms (commit family) cancel t=119ms lastAction=cancelled hold=240ms (emerge) fail t=127ms lastAction=failed hold=600ms (alert) Smoke 68/68, morfo-check 66/66. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	d76f4eaf11	test/eidos: 2x2 grid with breathing room for tooltip + popover side demos ... The previous layout (`repeat(4, 1fr)` with 0.5rem gap) packed the four sides in a horizontal row. Floating's collision detection saw the tooltip on `side='right'` had no room (the next button was 8px away) and shifted the placement, making the popover/tooltip appear far from its trigger. Switch to 2x2 grid with 4-7rem gaps and 3rem padding so each trigger has enough surrounding space for the tooltip/popover to render at the requested side without the floating layer flipping or shifting. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	5f6373e200	eidos/tooltip: recipe + per-side fade animations + demo ... Translates `air/components/tooltip/tooltip.css` (small — 31 lines, only Content + sizes styled) and adds: - Arrow fill (matches tooltip bg) - Per-side entrance/exit animations keyed off [data-side] (Floating layer) and [data-state]. Distance is smaller than Popover (2px vs 4px) — tooltip is lighter visually. - State handling for tooltip's three-value [data-state]: 'closed' → exit animation 'delayed-open' → entrance animation (hover after openDelay) 'instant-open' → no animation (keyboard focus, deliberate invocation; the user wants it now, not after a slide) Demo (test/eidos/tooltip): 4-side grid + sizes (sm/md/lg). Verification: smoke 68/68, morfo-check 66/66. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	d31bbc23f0	eidos/popover: recipe + per-side fade/scale animations + demo ... Translates `air/components/popover/popover.css` (small — 67 lines, only Content + Close styled) and adds three eidos extensions: 1. Trigger envelope ([data-popover-trigger]) — air relied on the Button recipe via .air-button class. Eidos applies a baseline button-style envelope here, consuming Capa 2 directly. 2. Overlay fade ([data-popover-overlay][data-state='open'/'closed']) — for modal popovers. The morfo declares Overlay as optional; consumer renders it when modal=true. 3. Per-side entrance/exit animations keyed off [data-side] (top/right/bottom/left) and [data-state]. Soma's Floating layer writes data-side based on resolved placement. The popover slides into place from the trigger edge — fade + small translate (4px) + scale (0.985 → 1). Air's "revelation" pattern: ~180ms entrance / 120ms exit. Demo (test/eidos/popover): basic + 4-side grid. Each side button anchors a Popover.Content with the matching `side` prop so the animation direction matches placement. Verification: smoke 68/68, morfo-check 66/66. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	abf197a37c	eidos/drawer: recipe + slide-in/out per side + demo (modal & non-modal) ... Translates `air/components/drawer/drawer.css` to `eidos/components/ drawer.css` (mechanical: --air-* → --eidos-*, drop .air-* gates) and adds the entrance/exit animations air's recipe was missing — air drove drawer transitions through `air.semantic.contextIn/Out` Svelte transitions, which don't exist in the morfo-driven path. Without them the drawer snapped in/out instantly. Per-side keyframes: right → translateX(100%) left → translateX(-100%) top → translateY(-100%) bottom → translateY(100%) Plus overlay fade keyed off data-state. All ~240ms entrance / 180ms exit (moderate / normal). The Presence layer waits for getAnimations().finished so the content stays mounted during exit. Demo (test/eidos/drawer): - Modal section: 4 side buttons, render Drawer.Overlay (backdrop + focus trap, page non-interactive while open). - Non-modal section: 4 side buttons, omit Drawer.Overlay + pass modal={false}. No backdrop. Page behind stays interactive. Soma's Dismissal layer auto-adjusts (interactOutsideBehavior default flips from 'ignore' to 'close'). The Drawer morfo doesn't declare `events` yet, so no runtime.trigger() cadence + no exit-tinting like Dialog. Recipe + animations only. Verification (playwright probe): top t=140ms translateY(-372) → t=406ms 0 right t=99ms translateX(452) → t=389ms 0 bottom t=94ms translateY(372) → t=390ms 0 left t=111ms translateX(-349) → t=428ms 0 Smoke 68/68, morfo-check 66/66. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	b096237d3e	soma/dialog: dismissWith(action) public API + tinted demo section ... Expose a programmatic dismiss method on DialogProvider that fires the matching close-* event through the runtime, and use it from the eidos Dialog demo to make the exit-tinting visible. Soma: - DialogProvider.dismissWith('save'|'cancel'|'fail'|'dismiss'| 'dismiss-outside') maps to the corresponding morfo event (close-save, close-cancel, close-after-fail, close-dismiss, close-dismiss-outside) and fires runtime.trigger(). - DialogProvider class re-exported from $soma/components/dialog so consumers can call DialogProvider.get() inside a child component. Demo (test/eidos/dialog): - New "Exit tinting by causa" section with three buttons that close the same dialog via three different events: Save → close-save → border-top tinted success (240ms hold) Cancel → close-cancel → border-top tinted neutral (240ms hold) Fail → close-after-fail → border-top tinted danger (600ms hold) The 600ms fail hold is sema's family='alert' default — the dialog stays open longer for the user to register the failure before close. - Uses a small _dismiss-button.svelte child component that captures DialogProvider.get() at component init time. The inline onclick pattern (Dialog.DialogProvider.get()?.dismissWith(...)) doesn't work from the parent route's scope because Svelte's getContext is init-time-only — the route is the parent of Dialog.Provider, not a child. The _dismiss-button is rendered inside Dialog.Content so its init-time context lookup resolves correctly. Verification (playwright probe): save t=144ms lastAction=saved hold=240ms cancel t=116ms lastAction=cancelled hold=240ms fail t=117ms lastAction=failed hold=600ms (full alert family) Smoke 68/68. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	bb8c8657e1	soma/dialog: soft-migrate close-* events through MorfoRuntime ... Inject a MorfoRuntime side-channel in DialogProvider that fires the prewrite → semantic.emit → handler cadence for the close-* events declared in the dialog morfo. The legacy provider machinery (assertProps + resolveMorfoProps + Provider class hierarchy) stays — runtime is alongside, not replacing. Wiring: - DialogProvider creates the runtime in its constructor with `events.{close-save, close-cancel, close-dismiss, close-dismiss-outside, close-after-fail}` all delegating to handleClose(). The runtime gets dom + semantic from soma + state sources for `open` + prop sources for `disabled`/`modal`. - DialogContentProvider registers the content part with the runtime when its constructor runs, so trigger() can resolve `event.target = partRef('content')` to a real DOM node. - DialogTriggerProvider.onclick keeps direct handleOpen() — the 'open' event in the morfo targets content, but content isn't in the DOM until AFTER open flips. Chicken-and-egg. - DialogCloseProvider.onclick → trigger('close-cancel'). - DialogContentProvider's dismissal callbacks: onEscapeKeydown → trigger('close-dismiss') onInteractOutside → trigger('close-dismiss-outside') What this unlocks: Each close path now writes `data-last-action` (saved/cancelled/ dismissed/dismissed-outside/failed) BEFORE flipping data-state, visible during the exit animation. The dialog recipe's tint rules in eidos finally fire in vivo. Verification (playwright check-eidos-recipes): @8ms post-click lastAction=cancelled state=open (prewrite) @241ms lastAction=cancelled state=open (signal hold) @378ms lastAction=cancelled state=closed (exit) @493ms opacity=0.017 (exiting) The 240ms wait between click and exit is sema's family='emerge' hold. The user can override per-event via `morfo.events[].hold` if 240ms feels too long for a dialog cancel. Smoke 68/68, morfo-check 66/66. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	084322d3db	eidos/dialog: add [data-dialog-trigger] envelope (button-style) ... Air's dialog relied on the Button recipe (`.air-button` class on trigger). Eidos has no class composition, so the trigger was inheriting only the archetype's cursor + focus ring, leaving it with the browser-default button look. Add a baseline envelope in dialog.css consuming Capa 2 tokens directly (--eidos-color-{surface-raised, surface-overlay, border-default, content-primary}, --eidos-control-height-md, --eidos-radius-md, --eidos-space-3, --eidos-duration-fast). Hover and data-state='open' both shift to surface-overlay. Disabled fades to 0.5. Trigger isn't a separate component with its own Capa 3 tokens — it's a part of Dialog using the system surface. Direct Capa 2 consumption is appropriate here (same as archetype rules). Verification: smoke 68/68, morfo-check 66/66; visual confirmed via playwright screenshot — Open dialog/Open small/Open large render with proper button envelope. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	a50b18d1f1	eidos: drop legacy hand-rolled tokens.css, consume air-translated tokens ... Replace the V1.5 hand-rolled motion/easing/tint/opacity/focus-ring tokens with the air-translated equivalents already in eidos/themes/ base/_static.css and eidos/themes/base/light.css. Substitutions applied to archetypes.css, events.css, components/ dialog.css: --eidos-motion-fast → --eidos-duration-fast (120ms) --eidos-motion-base → --eidos-duration-slow (320ms) --eidos-easing-standard → --eidos-ease-default --eidos-easing-decelerate → --eidos-ease-out --eidos-easing-emphasized → --eidos-ease-spring --eidos-tint-neutral → --eidos-color-neutral-element --eidos-tint-affirm → --eidos-color-success-element --eidos-tint-fulfill → --eidos-color-success-element --eidos-tint-risk → --eidos-color-warning-element --eidos-tint-threat → --eidos-color-danger-element var(--eidos-opacity-hover) → 0.85 (single-site, archetype-internal) var(--eidos-opacity-disabled) → 0.5 (single-site, archetype-internal) Focus ring tokens (--eidos-focus-ring-{color,width,offset}) unchanged — same names already exist in air's _static.css/light.css. `affirm` and `fulfill` collapse to the same `success-element` because air's intent vocabulary doesn't distinguish them. The morfo's data-intent attr still preserves the distinction at the structural layer; the visual mapping is just the same color. Updated scripts/check-eidos-recipes.ts to navigate to the per-component demo URLs (/test/eidos/{toggle,switch,dialog}) since the index page no longer renders the recipes directly. Verification: smoke 68/68, morfo-check 66/66. Playwright entrance/exit curves intact (opacity interpolates over the configured durations). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	fa6b01c319	test/eidos: split into per-component demos with shared layout ... Restructure the demos to mirror /test/soma's pattern: index page plus one demo per recipe, all under a shared layout that loads the eidos CSS chain and the Soma + App scaffolding once. test/eidos/ ├── +layout.svelte Soma + App + sticky nav bar ├── +page.svelte index (links + foundation explanation) ├── toggle/+page.svelte colors / sizes / variants / states ├── switch/+page.svelte colors / sizes / disabled ├── collapsible/+page.svelte ├── toast/+page.svelte fire by intent (5 intents) └── dialog/+page.svelte default + size variants Each demo exercises the variants air's CSS exposes (data-color, data-size, data-variant) by adding the attrs directly to the Provider element — they're a-la-carte since the morfos don't declare them yet. Future work: extend the morfos to declare these attrs as first-class props. Verification: all 6 routes return 200; smoke 68/68 (only covers /test/soma — eidos routes not in scope), morfo-check 66/66. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago