85 Commits (e21bf6c8b84a8fe72ed8a9b90c1e01b585981288)

Author	SHA1	Message	Date
dev	6d25364b21	Clarify Morfo value attrs runtime contract	5 months ago
dev	f331c988c1	Route UIX managed DOM writes through ActiveDom	5 months ago
dev	b90d0a24a9	Reduce UIX runtime allocation churn	5 months ago
dev	c12b1c48c8	Refactor active uix architecture	5 months ago
dev	cb5097b3c3	Add active eidos runtime and morfo lang registry	5 months ago
dev	7214ae7940	uix: drawer/popover/toast/accordion eidos wrappers + sema packs + /uix docs scaffold ... - eidos: migrate drawer / popover / toast / accordion to wrapper subdirectory pattern (provider + parts + tokens + recipe per component); avatar wrapper added; toggle/switch/collapsible recipe polish. - sema: per-component packs (accordion, drawer, popover, toast); engine / resolver / event / sema-map updates; visual channel hold refinements. - morfo: drawer event surface (variant, dragToDismiss, isDragging, minSize/ maxSize, onDragStart); popover/toast/accordion event refinements; schema + types updates. - soma: drawer provider rewrite (variant, dragToDismiss, isDragging binding, drag callbacks); toast provider/toaster restructure with toast-main + toast-status parts; popover content/arrow polish; gesture/floating layer updates; manipulation layer scaffold; avatar removed (eidos owns it now). - web/routes: legacy demos updated for new APIs; new /uix docs scaffold (web/routes/uix/) with Radix-style shell, theme/lang/format/semantic prefs, and standardized component template (Drawer page first — 6 tabs, live controls, drag-hint arrows, scroll-safe body wrapper). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	e6862265e2	sema/morfo/eidos: typed selector builder + dialog wrapper + emerge color ... sema architecture - sema-map: 5-channel registry (motion / sound / color / presence / haptic) via SemaChannelSignatures declaration merging; engine stamps data-event-* tokens; flat CSS-style cascade replaces the eventLabel-overrides middle layer. - sema-map: emerge family gains base.color so intent deltas can shift hue / saturation / intensity. Without a base, the resolver was skipping the channel and Dialog open with intent='threat' rendered as neutral blue in the Sema tab visualisation. - types: SEMA_FAMILY_POLICY const drives compile-time + runtime intent requirements per family. Object shape so future per-family policy fields fit alongside. Emerge events MAY now declare intent (canon update — a Dialog confirming threat carries it in its very appearance). - chans: rename vibra→haptic, add HapticChannel V1 (Vibration API); SoundChannel eager-init on first user gesture (autoplay race fix). morfo selector discipline - morfo/selectors.ts (new): semaSelector(morfo, partKebab, matchers?) — type-checked against morfo.parts and morfo.events. Sema cascade rules MUST use it; hand-written strings are an architecture violation that breaks silently when morfo renames a part. - dialog morfo: open carries intent via fromProp; close-cancel / close-dismiss / close-dismiss-outside drop intent (cancellation has no evaluative load); close-save stays hardcoded fulfill (commit fulfils the user's decision regardless of dialog context). eidos dialog migration (4th pilot) - eidos/components/dialog/: full subdirectory wrapper — flat <Dialog> + compound Provider/Trigger/Overlay/Content/Title/Description/Close/Header/ Footer; size + position responsive props; sheet auto-form on narrow viewports; closePosition for the auto-X. - sema/components/dialog.ts: cascade rules use semaSelector(dialogMorfo, 'content', matchers?). Intent block adds character (haptic kind / pattern) but never overrides pitch / gain / contour — those are intent.deltas signature ownership and overriding flattens per-intent perceptual difference. demo controls + dialog page - src/lib/_demo (DemoSwitch / DemoEnum / DemoText / DemoRange) — unified controls reused across all component demos. - web/routes/dialog: live preview always rendered above tabs; per-event Sema tab with independent intent probe; signature visualisation + Play buttons with fallback target chain. documentation - CLAUDE.md: intent.deltas signature ownership rule; eidos drift defense doctrine (types over lint); 2026-05-09 hand-off entry. - morfo/README: Typed selector builder section. - eidos/README: linter section reframed as opt-in safety net for plain CSS recipes; the architectural mechanism is compile-time typing. - sema/README: open channel registry + flat cascade docs + override semantics + intent policy const + selector builder discipline. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	d10281bc94	collapsible: migrate to eidos wrapper pattern (third pilot) ... Third component migrated to the eidos wrapper subdirectory pattern, following the new "check air baseline first" discipline. Air baseline recovered from commit 0a391408^: - air/components/collapsible: 3 wrappers (Provider/Trigger/Content) with `class` passthrough, `bind:open`, `onOpenChange`, manual `air.interaction.play('expansion', enter|exit)` perceptual emit. - No size, intent, color, or chevron slot. Migration decisions (presented BEFORE coding per scope-approval rule): - Two doctrinal events (`expand` + `collapse`, both emerge family, sequence='pre', no intent — emerge is transitional). Replaces air's manual `air.interaction.play` with `runtime.trigger('expand'| 'collapse')` which atravieses visual + sound + vibra channels. - No intent/color/size — air didn't have them and disclosure is non-evaluative per guide §3.1. - Multi-part API: Provider + Trigger + Content (no flat default per doctrine §10). Files: - src/uix/morfo/components/collapsible.ts: scope expanded to ['soma', 'sema'], events array added with two emerge events. - src/uix/soma/components/collapsible/collapsible-provider.svelte.ts: runtime.events handlers `expand`/`collapse` mutate state; toggle() fires runtime.trigger(next ? 'expand' : 'collapse'). - src/uix/eidos/components/collapsible/{collapsible.css, collapsible-provider.svelte, collapsible-trigger.svelte, collapsible-content.svelte, types.ts, index.ts, README.md}. - src/uix/eidos/components/collapsible.css (legacy flat) deleted. - src/uix/eidos/index.css: import path updated to subdirectory. - web/routes/collapsible/+page.svelte: full interactive testbed with tabs (Live, Soma, Morfo, Sema, Eidos, Notes) mirroring switch's structure. Sema tab shows per-channel signature cards for both expand and collapse events. Disciplina formalizada en CLAUDE.md hand-off + memory entry: "Check air baseline first" before any future eidos migration. Switch shipped without this check and lost ResponsiveProp<Size> (regression). Don't repeat with collapsible/dialog/drawer/popover/toast/avatar. npm run check holds at the 39-error baseline. Tests 218/218 green. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	3d0b234ec8	soma/morfo/active-uix: relocate runtime + rename SomaRuntime + sema opcional ... Architectural correction. Morfo was importing Svelte runes, $adom, and $uix/sema — all violations of "morfo is pure declarative DNA". The runtime that interprets a CompiledMorfo lives where it executes: soma. Move: - src/uix/morfo/runtime.svelte.ts → src/uix/soma/runtime.svelte.ts - src/uix/morfo/runtime.svelte.test.ts → src/uix/soma/runtime.svelte.test.ts Rename (consistent with the move; "soma's runtime", per the doctrine "morfo declares, soma executes"): - class MorfoRuntime → SomaRuntime - createMorfoRuntime() → createSomaRuntime() - type MorfoRuntimeSources → SomaRuntimeSources - error prefixes [morfo-runtime] → [soma-runtime] Sema is now genuinely ornamental: - ActiveUix.semantic returns EngineSemantic | undefined (no longer throws when no engine is configured). Components in SSR / headless tests / audio-disabled environments stay functional. - SomaRuntime.trigger() skips the emit step AND the target-resolution check when no engine is present — only requires a DOM target when something will actually be emitted. - Soma.semantic getter returns | undefined too (was non-optional). Consumers updated: - src/uix/active-uix/active-uix.svelte.ts — imports createSomaRuntime from $soma; semantic getter returns | undefined - src/uix/active-uix/types.ts — interface SomaRuntime, semantic | undefined - 8 providers (toggle, switch, collapsible, dialog, drawer, popover, toast, avatar) — type SomaRuntime, import path $soma - src/uix/soma/index.ts — re-exports createSomaRuntime + types - src/uix/morfo/index.ts — drops the runtime re-exports (morfo is pure) - src/uix/sema/signal.ts — JSDoc reference updated - src/uix/soma/core/soma.svelte.ts — semantic getter | undefined Test added: SomaRuntime.trigger() succeeds without a semantic engine (skips emit + target check, runs handler directly). Docs aligned to the new shape: - active_architecture.md — runtime locations, sema as ornamental - soma/SOMA_ARCHITECTURE.md, soma/README.md — name + import paths - morfo/README.md — file listing now flags morfo as PURE TS, points at soma/runtime.svelte.ts for the interpreter - sema/README.md — SomaRuntime references - README.md — root architecture diagram - CLAUDE.md — hand-off note Tests 218/218 green. npm run check holds at the 39-error baseline. 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	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	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	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	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	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	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	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	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	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	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	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	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	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	e4d131b58d	sema + morfo: per-event hold override (declarative in morfo) ... The hold of a component's event is now declared by the component itself, not buried in sema's family fallback table. Resolution precedence (in priority order): 1. signal.hold imperative, caller passes at emit time 2. morfo events[].hold declarative, component-level (this change) 3. sema family fallback 'emerge' → 'brief', 'alert' → 'noticed', ... Sema's family table becomes the technical fallback when neither caller nor morfo specifies. The numbers come from a single perceptual scale in sema/durations.ts (subliminal/glimpse/brief/noticed/insistent/persistent), so any change to the scale propagates to the family fallback automatically. Public surface: sema: SEMA_DURATIONS, SemaDurationLabel, SemaDurationSpec, resolveSemaDuration() — exported from $uix/sema. morfo: MorfoEvent.hold?: SemaDurationSpec — number or label. soma: MorfoRuntime.trigger() reads event.hold, resolves the label → ms via resolveSemaDuration(), passes it as signal.hold. Tests: - sema/durations.test.ts (4): scale values + resolver - soma runtime (3 new): hold-less event sends no signal.hold (sema falls back), numeric hold propagates, label hold resolves to ms. Verification: sema 44/44, soma runtime 25/25, smoke 68/68, morfo-check 66/66. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	3d9a834886	docs: align cross-layer docs with channel-based Sema ... Cleanup of stale references to the pre-refactor Sema model across architectural docs: - EngineSemantic → SemanticEngine (registry + dispatch) + VisualChannel (built-in materializer); engine no longer "depends on Dom" - "1 rAF + 1 hold frame (~13ms)" → perceptually-anchored hold (240ms emerge/commit/handle, 600ms alert/sustain, 120ms contact) - Promise semantics: sequential strict — cleanup BEFORE resolve, so structural commit lands AFTER perceptual feedback completes - Toast cadence trace updated: prewrite folded into VisualChannel.handle; CSS uses @keyframes (animation), not transition Touches: src/uix/README.md, src/uix/active_architecture.md, src/uix/sema/README.md, src/uix/eidos/README.md, src/uix/morfo/README.md, src/uix/soma/SOMA_ARCHITECTURE.md. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	5 months ago
dev	b4ceb1bb09	docs: SOMA_ARCHITECTURE — update sema timing reference after channel refactor ... The "data-event*" bullet still mentioned the old "~13ms" timing from before the perceptual anchoring fix and the channel refactor. Updated to reflect current behavior: VisualChannel writes the attrs for a configurable hold (240ms emerge/commit/handle, 600ms alert/sustain by default per family, configurable per signal or globally). No code changes — single doc fix.	6 months ago
dev	e664b59c96	sema: perceptually-anchored hold + sequential strict emit semantics ... Two architectural fixes surfaced by the eidos demo: 1. The previous default hold (1 rAF + 1 hold frame, ~30ms) was a technical timing decision — invisible to humans. Signals must be anchored to perceptual scales so they can actually be perceived. 2. The previous lifecycle resolved emit AFTER 1 rAF (caller's structural change ran in parallel with cleanup, ~30ms later). That's an implicit parallelism between event and state. The author has no way to say "wait for the announcement to be perceived before changing state". Sequential strict semantics (NEW) - emit writes the signal, awaits the full author-specified hold, cleans up, then resolves. State change happens AFTER cleanup — strictly sequential. - `signal.hold` is in milliseconds anchored to `SEMA_PERCEPTION` scales: subliminal 50ms below conscious threshold glimpse 120ms minimum perceptible without effort brief 240ms comfortable acknowledgement noticed 600ms sustained signal insistent 1200ms demands attention persistent 3000ms until acknowledged - Defaults per family in `SEMA_HOLD_DEFAULTS`: emerge: brief sustain: noticed contact: glimpse commit: brief alert: noticed handle: brief - Authors override per event via `SemanticSignal.hold` based on: - their CSS animation duration (so it completes before cleanup) - the perceptual scale they want - critical attention requirements (use insistent/persistent) Files - src/uix/sema/perception.ts (new) — SEMA_PERCEPTION + SEMA_HOLD_DEFAULTS + SEMA_OBSERVE_FRAME_MS constants with rationale anchored on Bloch's law, Material/Apple HIG motion guidelines, toast UX literature. - src/uix/sema/signal.ts — `hold` JSDoc updated to explain ms semantics + defaults + override pattern. - src/uix/sema/engine.ts — emit() refactored from rAF chain to setTimeout(holdMs); cleanup happens BEFORE resolve (sequential strict); `nextFrame()` helper removed; `resolveHoldMs(signal)` added with the 3-tier fallback (signal.hold → family default → SEMA_PERCEPTION.brief). - src/uix/sema/exports.ts — re-exports SEMA_PERCEPTION + SEMA_HOLD_DEFAULTS + SEMA_OBSERVE_FRAME_MS + SemaPerception type. - src/uix/sema/emit.test.ts — rewritten around fakeTimers + setTimeout (no more rAF queue); new test verifies cleanup runs BEFORE resolve. 7/7 tests green. - src/uix/sema/README.md — new "Duración del signal" section with the full perception scale + per-family defaults tables + override pattern. - src/uix/eidos/events.css — comment updated to explain the new hold windows; rule `[data-event^='dismiss']` etc. clarified. - src/uix/active_architecture.md — replaced "~13ms" prose with explicit perception-anchored scales; added explanation of "perceptual by design, not framerate". - src/uix/soma/components/toast/toast-provider.svelte.ts — new $effect that fires `present` + `announce` events when item ref attaches (one-shot guarded), so toasts emit signals on appear. The flash on /test/eidos is now visible thanks to (a) the perceptual hold and (b) the wired events. Channel parallelism note - Hold is the DOM channel duration only. - Future sound / vibra / motion engines subscribe to sema events independently; each owns its own timing relative to the event id. - Sema does not coordinate cross-channel sync — that's an integrator decision per app. Verification - 22/22 sema tests green. - 22/22 morfo runtime tests green. - 66/66 morfo-check + 68/68 smoke (verified before commit). - Probe shows announce signal on toast appear lasting ~600ms (alert family default) — visible in DevTools attribute panel. - svelte-check unchanged at 155. Pre-existing failure in src/uix/air/internal/canvas/layout.test.ts (`bun:test` import) is in the dead-branch air layer and unrelated.	6 months ago
dev	28f93ab089	docs: cross-layer articulation — eidos README + 2-of-3 rule across all layer docs ... Closes the documentation loop on the cross-layer extension pass: morfo now articulates between soma, sema, and (future) eidos. The "2-of-3 rule" formalizes when an extension to morfo is justified vs when it should stay as provider logic. src/uix/eidos/README.md (new) - Documents eidos's role and what it consumes from morfo + sema BEFORE any code exists, so the contract is preparedly clean when implementation starts. - Catalogs which morfo fields eidos reads (parts, archetype, states, data values, events, prewrite, focus, supportsNesting) and which it ignores (computed state, runtime internals, layers). - Documents the DOM-as-channel pattern: sema writes data-event* on emit; eidos reacts to selectors like `[data-event^="dismiss"]`. - Establishes the boundary with `air` (dead branch reference, not base). src/uix/README.md (top-level) - §8 Reglas de dependencia: adds the 2-of-3 rule table making the morfo-extension contract explicit, plus a list of canonical vocabularies (archetypes, verbs). - §10 Reading order: includes eidos README + lib/dom + clarifies which layers are dead branches. src/uix/morfo/README.md - New "Archetypes" section documenting the 24-verb vocabulary, the Provider-as-trigger vs Provider-as-container distinction, and the rule for adding new archetypes (≥2 components share the role). - New "The 2-of-3 rule" section with the same table as the top-level, listing which extensions did/didn't make it past the rule and why. - `parts[].archetype` mentioned in the "What morfo contains" list. src/uix/sema/README.md - New "Vocabulario canónico de verbs" section listing SEMA_VERBS by family and the `{verb}-{variant}` composite naming convention. - Documents `validateEventName()` as advisory tooling. src/uix/soma/SOMA_ARCHITECTURE.md - partProps documentation now mentions data-archetype emission. - New "Cross-layer hooks que soma emite por la regla 2-de-3" section listing the data-* attrs soma writes that sema and eidos consume. - Reading-order links updated. No code changes — all docs.	6 months ago
dev	aba18117ba	morfo: catalog `archetype` across 65 components (~265 part declarations) ... Bulk classification pass that gives every part a cross-component archetype where one applies. Done with `scripts/catalog-archetypes.ts` — a one-shot mechanical mapping based on a kebab → archetype table, plus three manual overrides for components where Provider IS the interactive element. Coverage - 440 part declarations examined. - ~265 received an archetype (provider, trigger, content, overlay, viewport, item, indicator, thumb, track, label, title, description, close, action, header, image, fallback, arrow, separator, group, input, segment). - ~175 left without one — genuinely component-specific (Slider.Range, PinInput.Segment internals, color-picker channel-slider, etc.). Manual overrides (Provider IS the trigger) - Toggle, Switch, Checkbox: their `Provider` part is a `<button>` that the user actually interacts with, not a root container. Archetype set to `'trigger'` instead of the default `'provider'` so eidos can style them alongside Dialog.Trigger / Popover.Trigger / etc. Script (scripts/catalog-archetypes.ts) - Walks every `*.ts` under `src/uix/morfo/components/`. - Inserts `archetype: '...'` directly after the matching `kebab:` line when a mapping exists. - Idempotent — skips parts that already declare an archetype. - Indent-aware — only operates on part kebabs (≥2 tabs), never the morfo root kebab. Bug discovered + fixed mid-pass when radio-group's root kebab `'radio-group'` matched the `'radio-group' → 'group'` alias and inserted at the wrong level (cleaned up by hand). - Reports per-file counts + the list of unmapped kebabs at the end so future passes can extend the mapping. Tests - Updated `omits data-archetype when not declared` test to use a tiny inline morfo (Toggle's Provider now has archetype 'trigger', so it can't be the "no archetype" fixture anymore). Verification - 22/22 runtime tests, full focused suite green. - 66/66 morfo-check (every component still validates against its DOM — archetype is additive, doesn't change emitted attrs apart from the new `data-archetype="..."` which morfo-check doesn't enforce yet). - 68/68 smoke routes. - svelte-check unchanged at 155.	6 months ago
dev	bf394873e0	morfo: add `archetype` field — cross-layer part categorization ... First step toward making morfo articulate the three layers (soma, sema, eidos) instead of just serving soma. Archetype is a small canonical vocabulary that lets a part declare its conceptual role beyond its component-specific kebab name. Articulation purpose: - Eidos can style transversally — `[data-archetype=trigger] { ... }` applies to every Trigger across all 60+ components without enumeration. - Sema can map archetypes to canonical action verbs (`trigger` may fire `activate`, `item` may fire `select`). - Docs can categorize parts cross-component for discovery. The "2-of-3 rule" justifies the extension: at least two layers consume it. Vocabulary 24 archetypes covering the common cross-component roles: provider, trigger, content, overlay, viewport, item, option, indicator, thumb, track, label, title, description, close, action, header, image, fallback, arrow, separator, group, input, segment, preview. Designed to stay small. New archetype only added when at least two existing components share the role. Genuinely-unique parts (Slider.Range, PinInput.Segment) omit the field. Implementation - `MorfoPart.archetype?: MorfoArchetype` — optional union type. - `ARCHETYPE_VOCABULARY` exported as `as const satisfies` array for enumeration tooling. - `partShallowSchema` (sium validator) gets `archetype: optional(union(...))`. - MorfoRuntime caches `partMeta` in PartRegistration so `partProps` can read `archetype` without re-walking the morfo tree per render. - `runtime.partProps(part)` emits `data-archetype="..."` when declared. Static identity (never mutates), so it ships through partProps not through `dom.apply` — Svelte renders it once on first paint. Tests 2 new tests: - partProps emits data-archetype when morfo declares one (inline test morfo to avoid coupling to catalog state). - partProps omits data-archetype when not declared (Toggle, pre-catalog). Verification - 22/22 runtime tests green. - svelte-check unchanged at 155. - No morfo currently declares archetype yet — catalog pass follows in the next commit. All existing morfos remain valid (field is optional).	6 months ago
dev	e7e32a8355	soma: Avatar migrated to runtime + V2 props bridge ... First component of the bulk migration phase (step 2 of the 1-3-2 plan). Pattern is now well-rehearsed across Toggle / Collapsible / Toast / Switch: - morfo: add `value` sources to data entries that were enum-only - provider: replace manual Opts interface with `OptsFromProps<...>`, create runtime in constructor, register parts, drop manual data-* / aria attrs from props (runtime emits via dom.apply) - wrapper: replace per-prop `readableActive(() => x)` list with one `bindProps({ ... })` call - keep manual: HTML primitives (style, src, etc.) and event handlers Avatar specifics - 3 parts (provider/image/fallback) all share `data-status` from the root's internal `status` State (idle/loading/loaded/error). morfo's `propRef('status')` reads from runtime sources where the root provider exposes it. - `status` is not a public Props field — it's an internal $state in the wrapper. Manually intersected into `AvatarOpts` rather than derived from AvatarProps. - Image's preload logic, src/crossorigin/referrerpolicy passthrough, and the style-based show/hide on each part stay in the provider's render — none of these are morfo-managed. - Wrapper cast uses `as unknown as Parameters<typeof X.create>[0]` for parts whose Opts have only `id`+`ref` (TS can't extract the specific fields from the generic `Record<string, Active<unknown>>` return of `bindProps`). Toggle/Switch don't need this because their richer Opts shape provides enough overlap. Bulk migration paused at this point — Progress / Meter need a design decision around `aria-label` priority logic (the legacy provider has "consumer-passed wins over translated default", which conflicts with the "dom.apply is the only writer of mutable attrs" rule). Either: (a) Drop aria-label from those morfos and keep provider-managed (legacy pattern preserved, morfo loses one declaration). (b) Extend the resolver with a priority chain (propRef → translationRef fallback) so the morfo can express "consumer wins, translation otherwise". Verification - 66/66 morfo-check (Avatar passes; all data-status emitted by runtime). - 68/68 smoke routes. - svelte-check unchanged at 155.	6 months ago
dev	55a5ad2647	soma: runtime.keydown() + Switch keyboard pilot ... V1.5 of MorfoRuntime — adds the keyboard dispatch piece and validates it against Switch (the simplest component with a real `morfo.keyboard` block). src/uix/soma/morfo/runtime.svelte.ts - New `runtime.keydown(part, event): boolean` walks `partMeta.keyboard`, matches `event.key` plus modifier flags against each entry's spec ("Enter", " ", "Shift+Tab", "Ctrl+A", …), and dispatches to the matching handler from `sources.actions[entry.action]`. Returns whether a handler ran. - New `sources.actions: Record<string, KeyboardActionHandler>` source map. Handlers receive the raw `KeyboardEvent` so they can `preventDefault()` selectively. The runtime never calls preventDefault on its own. - Modifier matching is exact: `Shift+Tab` does NOT match plain Tab; `Tab` does NOT match Shift+Tab. Each entry's `condition` (`prop-truthy` etc.) is also honored. - Key-spec parsing keeps the literal key untrimmed (the spacebar is `" "`, trimming would collapse it to empty). Modifier segments are trimmed individually. Toast pilot — keyboard wiring NOT included Toast Item declares `{ key: 'Escape', action: 'close' }` in morfo, but the legacy Toast doesn't actually wire Escape either. Out of scope for this commit; a follow-up can add `events.close` + the keydown listener on the Item element. Switch pilot — first consumer - `morfo/components/switch.ts`: added `value` sources to `data-state` / `data-disabled` (same pattern Toggle/Collapsible/Toast needed for the runtime to manage them). - `soma/components/switch/switch-provider.svelte.ts`: - Manual `interface SwitchOpts` (10 lines) replaced with `OptsFromProps< SwitchProps, ManagedKeys, 'checked'>` (5 lines). - The custom `onkeydown` block (`if (e.key === KEYS.ENTER) preventDefault; toggle()`) collapses to `(e) => this.runtime.keydown('provider', e)`. The morfo's `Enter` and ` ` (spacebar) both dispatch to action `'toggle'`, handled by `actions.toggle: (e) => { e.preventDefault(); this.toggle() }`. - props derivation uses `runtime.partProps('provider')` for identity, keeping only the HTML `disabled` attr and event handlers manual. - `soma/components/switch/components/switch.svelte`: 8 lines of `readableActive(() => x)` collapsed to a single `bindProps({ ... })` call (the V2 helper from commit eb0f128c). Tests - 7 new keydown unit tests covering: no-keyboard part returns false, single- key dispatch with original event passed through, multi-key for same action (Enter and Space → toggle), no-match returns false, modifier strictness (Tab vs Shift+Tab dispatch to different actions on dialog content), unhandled action returns false, runtime never preventDefaults on its own. Verification - 20/20 runtime tests, 111+ soma tests green. - 66/66 morfo-check (Switch passes; data-state and data-disabled now emitted by the runtime via the morfo's value sources). - 68/68 smoke routes. - svelte-check unchanged at 155.	6 months ago
dev	eb0f128c3e	soma: V2 props bridge (OptsFromProps + bindProps) — Toggle refactor ... Eliminates the triplication that every component used to suffer: 1. Props (autoral, in types.ts) — public consumer API 2. Opts (mechanical) — provider's reactive contract 3. wrapper's `readableActive(() => x)` list (mechanical) After V2 only (1) is hand-written. (2) is derived; (3) collapses to one `bindProps({ ... })` call. src/uix/soma/reactive/opts.ts (new) - `OptsFromProps<P, Managed, StateKey>` type maps a Props interface to the matching Opts: `id` + `ref` baked in; `Managed` selects which keys reach the provider (HTML passthroughs stay out); `StateKey` is the bindable subset (the rest become `Active`). `Exclude<P[K], undefined>` strips the optionality the wrapper resolves via Svelte destructure defaults. - `bindProps(config)` runtime helper: each entry is either a bare getter (→ `readableActive`) or a `{ get, set }` object (→ `writableActive`). Detection is structural (no marker function — avoids collision with Svelte's `$bindable` rune in `<script>` blocks). - `WritableSpec<T>` defaults to `unknown` for storage but `PropsConfigEntry<T>` defaults to `any` for variance — heterogeneous bag literals are bivariant under `any`, contravariant under `unknown`. Toggle migration as the proof - `morfo/components/toggle.ts`: rename `propRef('ariaLabel')` → `propRef('aria-label')` so the morfo and the public Props key match. Bracket notation in the provider handles the kebab-cased key. - `soma/components/toggle/toggle-provider.svelte.ts`: - `interface ToggleOpts { ... }` (15 lines hand-rolled) replaced by `type ToggleOpts = OptsFromProps<ToggleProps, ManagedKeys, 'pressed'>` (10 lines) - sources read `opts['aria-label'].current` - `soma/components/toggle/components/toggle.svelte`: - 11 lines of `name: readableActive(() => name)` collapsed to a single `bindProps({ ... })` call where each line is just `name: () => name` or `pressed: { get: () => pressed, set: (v) => (pressed = v) }` Tests - `opts.svelte.test.ts` — 4 unit tests verifying readable/writable detection, mixed configs, and kebab-keyed entries (`'aria-label'`). Verification - 111/111 soma tests green. - 66/66 morfo-check (Toggle's emitted DOM unchanged). - 68/68 smoke routes. - svelte-check unchanged at 155 (no new errors). Recipe for migrating other components: 1. List `Managed` keys (everything in Props that isn't HTML passthrough). 2. List `StateKey` subset (anything bindable in the wrapper). 3. Replace the manual Opts interface with `OptsFromProps<...>`. 4. Wrap the wrapper's prop forwarding in `bindProps({ ... })`.	6 months ago
dev	14aa218658	soma: Toast pilot — multi-instance runtime + trigger() integration ... Commit B of the Toast pilot. The runtime.trigger() contract from commit A now has its first real consumer: all three dismiss paths route through `runtime.trigger('dismiss')`, which emits the perceptual signal one frame before the toaster mutates state. Multi-instance architecture validated Toast is the first component with multiple per-instance subtrees: each toast in the queue is its own scope with its own children. Two runtime instances coexist per Toast tree: ToastProvider (root) └── runtime instance A — registers `viewport` only ToastItemProvider (one per active toast in queue) └── runtime instance B — registers `item` + its children (`title`, `description`, `action`, `close`) `partRef('item')` resolves to THIS toast's element because the lookup happens on THIS Item's runtime, not a shared one. `runtime.trigger('dismiss')` on Item-B targets Item-B's DOM element. Per-toast isolation by construction. dismiss wired through runtime.trigger Three call sites now go through the same path instead of calling `toaster.dismiss(id)` directly: - ToastCloseProvider.onclick (user clicks the × button) - ToastItemProvider startTimer setTimeout callback (auto-dismiss) - ToastItemProvider onpointerup (swipe gesture meets threshold) The runtime fires `data-event="dismiss"` on the item, awaits one rAF for CSS to observe it, then calls the dismiss handler that mutates `toast.dismissing = true`. The item's effect re-derives `data-state="closed"` from `isOpen = !dismissing` and writes it via dom.apply on the next tick. intent-driven role / aria-live still works The morfo's `mapRef(propRef('intent'), { neutral: 'status', risk: 'alert', … })` for `role` and `aria-live` is resolved by the runtime per-Item: each toast reads its own `intent` from `opts.toast.current.intent` via the per-Item runtime sources. Risk/threat toasts get `role=alert` + `aria-live=assertive`; the others get `role=status` + `aria-live=polite`. No code in the provider selects this — the morfo declares it, the resolver computes it. Per-part props Action's `altText` is per-instance per-action — passed to the runtime via `registerPart('action', { props: { altText: () => opts.altText.current } })`. Validates that the runtime's per-part source override (introduced in commit 8ede5353 but never exercised) works as designed. Translation lookup Close's `aria-label` resolves through `v.translationRef` against the Item runtime's `translate` source (`soma.langs.ts`). Confirms translationRef ergonomics through the runtime path. What this commit does NOT do (deferred) - `present` and `announce` events: declared in the morfo but not wired. Would fire on Item mount; needs a small effect at the right phase. - `runtime.keydown` for Item's `Escape` keyboard declaration: requires the V2 runtime API. - presence layer (data-starting-style/data-ending-style) still flows through Svelte render — not migrated to dom.apply. Mixed model is OK while the boundary is clearly between morfo-declared attrs (runtime) and layer-declared transitions (Svelte). Verification - 84/84 focused unit tests green. - 66/66 morfo-check (toast included). - 68/68 smoke routes 200 OK. - svelte-check unchanged at 155.	6 months ago
dev	2b39a2423d	soma + app: runtime.trigger() contract + Sema wired into App/Soma ... Commit A of the Toast pilot: introduce the trigger() contract end-to-end without migrating any provider yet. Toast's actual migration follows in a separate commit so that bugs (if any) can be attributed to one layer at a time. App layer - New `AppSemantic` contract in `$lib/ext/app/types`: a single-method interface (`emit(signal): Promise<void>`) implemented by SemanticEngine and accepted by the App constructor. - App now owns `app.semantic`, defaulting to a fresh SemanticEngine wired to `app.dom` when the consumer doesn't pass one. Fallback App also gets `fallbackSemantic` so context-less calls don't throw. - Soma re-exposes it as `soma.semantic` so providers reach it the same way they reach `soma.dom` / `soma.langs`. MorfoRuntime - New `runtime.trigger(eventName): Promise<void>` with the full sequence the architecture closed: 1. apply `prewrite` attrs imperatively (transient markers) 2. await `semantic.emit({ target, name, family, intent? })` — resolves the intent from `event.semantic.intent` (literal SemaIntent or SemaIntentBinding via `resolveSemaIntent`) 3. invoke the provider's handler from `sources.events[name]` 4. effects on the affected parts re-derive structural attrs and write them via `dom.apply` (automatic — not awaited here) - New optional `sources.semantic` and `sources.events` on the runtime. Without `semantic`, step 2 is skipped. Without an events handler for the name, step 3 is skipped. - `morfo.events.commits` is intentionally NOT executed by the runtime — it remains descriptive metadata documenting what an external observer will see (per the architecture's "state is the source of truth" rule). Tests - 8 new trigger unit tests using the toast and dialog morfos: - throws on undeclared event - throws when target part has no DOM - emits with intent resolved from prop (toastMorfo.announce) - falls back to declared default intent when prop missing - omits intent for transitional families (toastMorfo.present) - prewrite applied before semantic.emit (dialogMorfo.close-cancel) - handler invoked only after semantic.emit resolves - skips semantic.emit when no semantic source provided Verification - 84/84 focused unit tests green (full adom/sema/lib/dom/morfo/soma). - 66/66 morfo-check. - 68/68 smoke routes. - svelte-check unchanged at 155 (no new errors introduced). Next (commit B): migrate Toast to use the contract — wire close.onclick, swipe gesture, auto-timer, and Escape keydown to runtime.trigger().	6 months ago
dev	53d6539abe	soma: Collapsible pilot — multi-part runtime migration ... Second pilot of MorfoRuntime V1, validating the multi-part case left unproven by Toggle. Collapsible has three providers (provider/trigger/ content), shares root state across them, and uses partRef cross-references (`aria-controls` ↔ `aria-labelledby`). Note on scope The morfo doesn't declare `keyboard` — the Trigger is a `<button>` and relies on native Enter/Space via onclick. So this pilot does NOT exercise `runtime.keydown`; that's deferred to the next pilot with a real keyboard contract (Tabs, Accordion, Listbox). What this pilot validates - Single runtime instance shared across three part-providers, created at the root and accessed by children via the Provider context. - Cross-part state source: all three parts read `open` and `disabled` from the root provider's opts via `states` / `props` source maps. - Cross-part id resolution: `parts.trigger`/`parts.content` getters read from the root's reactive `triggerId`/`contentId` State; partRef on Trigger and Content resolves once the corresponding sibling registers. - Conditional emission with partRef: `aria-controls` (when Content present) and `aria-labelledby` (when Trigger present) toggle correctly as siblings mount/unmount. - Effect timing across multiple parts: each part's effect runs in its own component scope, cleans up on unmount. Morfo update Same fix as Toggle: data entries got explicit `value` sources. `data-state` references `stateRef('open')`; `data-disabled` references `propRef` with `prop-truthy` condition. Without this the runtime had no way to source the values (the legacy provider hard-coded them). Provider migration - CollapsibleProvider creates the runtime in its constructor with shared states/props/parts sources and registers the 'provider' part. - CollapsibleTriggerProvider and CollapsibleContentProvider call `provider.runtime.registerPart(...)` for their slot, and publish their id to the root's State so partRef resolves. - Each part's `props` derivation collapses from ~6 attrs (data-state, data-disabled, role, aria-*, type, etc.) to just `runtime.partProps()` + the few primitive attrs not in the morfo (`disabled`, `onclick`, `hidden`). Verification - 76/76 focused tests green. - 66/66 morfo-check (Collapsible's emitted DOM matches the morfo). - 68/68 smoke routes 200 OK. - svelte-check unchanged.	6 months ago
dev	62bcb1268f	soma/morfo: fix conditional attr cleanup in resolvePartAttrs ... Real bug surfaced by user testing the Toggle pilot: setting `invalid` to true emitted `data-invalid` and `aria-invalid` correctly, but flipping it back to false left the attrs on the DOM. The red border from CSS based on `[data-invalid]` stayed lit. Cause: `resolvePartAttrs` skipped declared attrs whose condition was falsy. The map handed to `dom.apply` lacked the key, so dom.apply (which only iterates the keys it receives) had no instruction to remove the attr from the previous tick. The function's JSDoc claimed it emitted `undefined` for non-matching attrs. The implementation didn't match. Now it does: - Conditional attrs with falsy condition are emitted as `undefined` → `dom.apply` removes them from the DOM and Svelte ignores them at render. - Data entries without a `value` source are still skipped entirely (they are documentation in the morfo, not runtime-managed attrs). Same fix covers all conditional attrs: data-disabled, data-readonly, data-required, data-invalid, aria-disabled, aria-readonly, aria-required, aria-invalid, aria-label — all toggled on/off cleanly now. Regression test added covering the invalid true→false→true cycle. Verification: 5/5 runtime tests, 76/76 focused suite, 66/66 morfo-check, 68/68 smoke.	6 months ago
dev	8ede535305	soma: MorfoRuntime V1 + Toggle pilot ... First piloted slice of the closed architecture: a runtime that interprets the morfo declaration and writes mutable attrs to the DOM via dom.apply, removing the need for the provider to hand-roll resolveMorfoProps bindings on every part. src/uix/soma/morfo/ - resolver.ts — pure morfo → attrs resolver, extracted from Provider so both legacy Provider (still in place) and the new runtime can share it - runtime.svelte.ts — `createMorfoRuntime(morfo, sources)` with V1 surface: - registerPart(part, opts) — registers per-instance id/ref/sources and sets up a $effect that reapplies attrs whenever sources change - partProps(part) — returns ONLY identity (id + marker + ref attachment), never mutable attrs (those go through dom.apply) - runtime.svelte.test.ts — 4 tests verifying initial application, reactive reapplication, and unknown-part rejection ARIA stateRef refinement The shared resolver now stringifies ARIA stateRef values to 'true'/'false'. Boolean false on aria-* must mean "explicitly unpressed/unexpanded", not "attribute absent" — the previous boolean return wired into dom.apply's `false → removeAttribute` semantics, which is correct for data-* presence flags but wrong for ARIA. Distinct contracts; resolver decides at the boundary, not dom.apply. Toggle morfo Added explicit `value` sources to all data entries. The legacy provider hard-coded data-state etc.; the runtime needs the morfo to declare where each attr's value comes from. Now data-state references stateRef('on') and data-disabled / data-readonly / data-required / data-invalid reference their corresponding propRef with prop-truthy conditions. Toggle provider migration - ToggleProvider creates a MorfoRuntime in its constructor with Soma's dom. - registerPart('provider', { id, ref }) wires the runtime to the button. - props derivation now returns only: - runtime.partProps('provider') — id + data-toggle + ref attachment - disabled (HTML attr; not in morfo by design — primitive button concern) - onclick handler - All morfo-declared attrs (data-state, aria-pressed, data-disabled, aria-disabled, aria-label, etc.) are written by the runtime's effect via dom.apply. Verification - Unit tests: 4/4 morfo runtime + full focused suite green. - morfo:check: 66/66 — Toggle's emitted DOM matches the morfo declaration end-to-end now that data-* sources are pinned. - smoke: 68/68 routes 200 OK. - svelte-check: no new errors. V2 (deferred — not part of this pilot): - runtime.keydown(part, event) for morfo.keyboard dispatch. - runtime.trigger(eventName) — prewrite + semantic.emit + handler chain (Toast will be the first component to exercise this). - OptsFromProps + bindProps helper to absorb the props bridge boilerplate.	6 months ago
dev	13caaf215f	docs: closed architecture (Morfo + MorfoRuntime + Provider + Effects + Sema + Dom) ... Reflect the architectural decisions reached on 2026-04-25 across the layer-level READMEs: - src/uix/README.md - rewrite ADom section: no longer a "broker semántico"; only DOM mutation surface - rewrite Sema section: vocabulary + EngineSemantic with Promise-returning emit - new §2.bis "Cómo se ejecuta un componente": six-piece chain with disjoint responsibilities (Morfo declares, Runtime transcribes, Provider supplies, Effects sync, Semantic emits, Dom applies) - update §8 dependency rules to match the closed design - new one-line summary in §9 - src/uix/morfo/README.md - new "How morfo gets executed" section: maps each morfo field to its runtime executor; documents trigger() sequence and provider responsibilities - src/uix/sema/README.md - rewrite around the Promise contract: emit() resolves after 1 rAF - document lifecycle (id → write signal → wait frame → resolve → hold → cleanup) - error policy and the three composition scenarios with dom.apply - src/uix/soma/SOMA_ARCHITECTURE.md - new §3.bis "Arquitectura cerrada" introducing MorfoRuntime as the missing piece between Morfo (declaration) and Provider (execution) - documents API V1, three commit operations, trigger() sequence, operational rules, and pilot order (Toggle → Collapsible → Toast → Dialog) No code changes; this commit pins the architecture before implementation.	6 months ago
dev	a0a1485b9f	Refactor sema and add shared dom runtime	6 months ago