# STRVCT — Full Documentation Site build: STRVCT · 2026-11-15 · f6dbae65 You write the domain model. STRVCT does the rest while the app runs: it presents your objects in a user interface on desktop and phone, stores them locally, syncs them to the cloud, imports and exports them as JSON, and lets AI agents read and edit them. Nothing is generated ahead of time: views are created from the live objects as the user navigates, and they update when the objects change. Add a property, annotate it, and every part picks it up. There is no separate form, storage mapping, or tool schema to write. See also: /llms.txt (curated index) and /sitemap.xml. --- Source: / Write the domain model. Get the application. **You write the domain model. STRVCT does the rest while the app runs:** it presents your objects in a user interface on desktop and phone, stores them locally, syncs them to the cloud, imports and exports them as JSON, and lets AI agents read and edit them. Nothing is generated ahead of time: views are created from the live objects as the user navigates, and they update when the objects change. Add a property, annotate it, and every part picks it up. There is no separate form, storage mapping, or tool schema to write. **Why this hasn't worked before.** The idea is old; it's called *Naked Objects*. Its weakness was that generated interfaces looked like database forms, so real applications ended up hand-building their screens anyway. **What's different here.** STRVCT starts from an observation: nearly every screen in an information app comes down to a few decisions about the data. What is visible? Does each item open beside its parent, as a column or tab, or sit inside it, as a section of a document? How are lists arranged? The framework handles the mechanics, including navigation and adapting to screen size. You state your choices as small hints on the model. So changing how something looks means changing a hint, not rewriting a screen. [**Read the paper →**](docs/Naked%20Objects/index.html) - docs/Naked Objects - docs/Getting Started - Example App - docs/Comparing to React - docs - [GitHub Repository](https://github.com/stevedekorte/strvct.net) — Source code, issues, and contributions. --- Source: /docs/ # Documentation Guides, architecture, and API reference. - Naked Objects - Technical Overview - Implementation Overview - Nodes - Slots - Getting Started - Lifecycle - Notifications - Views - Persistence - Events and Gestures - Inspectors and Debugging - Accessibility - Internationalization - Services - Programming Idioms - Reference - Comparing to React - Inspirations - Plans - Diagrams --- Source: /docs/Accessibility/ # Accessibility Automatic, framework-level ARIA support, keyboard navigation, and preference adaptation derived from slot metadata annotations and view classes. ## Overview STRVCT provides built-in accessibility support that works automatically for every application built on the framework. Because the UI is derived from model nodes through a small set of view classes, accessibility metadata is emitted at the framework level -- developers don't need to add ARIA attributes to individual components. This is a direct consequence of the naked objects architecture. In a conventional web framework, accessibility is a per-component concern: every button, list, and form field needs manual ARIA attributes, and the cost scales linearly ($O(N)$) with the number of components. In STRVCT, the same $\sim$15 view classes render every application's UI, so fixing accessibility in those classes fixes it everywhere. Slot Metadata Annotations Declared once in initPrototypeSlots() slot.description() slot.isReadOnly() slot.isRequired() slot.minimum() / slot.maximum() Framework ARIA Emitted Emitted by ~15 shared view classes aria-description="Current character hit points" aria-readonly="true" aria-required="true" aria-valuemin="0" · aria-valuemax="999" One declaration drives field validation, AI JSON tool schemas, and screen reader ARIA attributes. --- ## Why the Naked Objects Pattern Helps Most frameworks require developers to manually add accessibility attributes to each component. STRVCT's architecture inverts this: since the framework generates views from the model, it can also generate accessibility metadata from the model -- automatically, in one place, for all applications. - **The slot system already describes the data:** Slot metadata maps almost directly to ARIA attributes (`description()` $\rightarrow$ `aria-description`, `isReadOnly()` $\rightarrow$ `aria-readonly`, `isRequired()` $\rightarrow$ `aria-required`). - **JSON Schema annotations serve double duty:** The same annotations that generate JSON Schema for AI tool calls also drive accessibility attributes. A slot configured with `setMinimum(0)` and `setMaximum(100)` emits both JSON Schema constraints for AI and `aria-valuemin="0"` / `aria-valuemax="100"` for screen readers. The investment in richer slot annotations directly improves both AI integration and accessibility. - **The node hierarchy maps to ARIA patterns:** The tile/stack navigation model (drill in, drill out, select with arrows) maps naturally to ARIA roles (`SvTilesView` $\rightarrow$ `list`, `SvTile` $\rightarrow$ `link`, `SvFieldTile` $\rightarrow$ `group`, selected tile $\rightarrow$ `aria-current`). --- ## Implementation Details ### ARIA Roles Each core view class emits an appropriate ARIA role: | View Class | Role | Purpose | |---|---|---| | `SvTilesView` | `list` | Container for navigable tile items | | `SvTile` | `link` | Individual navigation item in a list | | `SvFieldTile` | `group` | Key-value field with label and value | | `SvBooleanFieldTile` | `checkbox` | Toggle field with checked/unchecked state | | `SvActionFieldTile` | `button` | Clickable action | | `SvOptionsNodeTile` | `listbox` | Container for selectable options | | `SvOptionNodeTile` | `option` | Individual selectable option | | `SvStackView` | `navigation` | Top-level navigation landmark | | `SvNavView` | `region` | Named content region | | `SvBreadCrumbsTile` | `navigation` | Breadcrumb navigation with `aria-label="Breadcrumb"` | --- ## Labels and Descriptions View classes derive ARIA labels from node metadata: | Source | ARIA Usage | Rationale | |---|---|---| | `node.nodeAriaLabel()` | `aria-label` | `title()` by default; domain objects can override to provide a descriptive label for screen readers | | `node.subtitle()` | `aria-description` | Subtitle text available on demand | | `slot.description()` | `aria-description` | Detailed field-level description | | Key view text | `aria-label` | Label on field tiles | --- ## Node-Level ARIA Overrides (`SvTitledNode`) `SvTitledNode` provides methods that domain objects can override to customize accessibility behavior without modifying view code: | Method | Default | Purpose | |---|---|---| | `nodeAriaLabel()` | `title()` | Label announced by screen readers | | `nodeAriaRole()` | `null` (view's default) | Override the view class's default ARIA role | | `nodeAriaIsReadOnly()` | `null` (from slot editability) | Override read-only state | | `nodeAriaIsRequired()` | `null` (from slot `isRequired()`) | Override required state | | `nodeAriaLive()` | `null` | Returns `"polite"` or `"assertive"` for dynamic live regions | Returning `null` defers to the view's default behavior. Returning a value overrides it. This follows the same pattern as `setNodeViewClass()` -- the framework provides sensible defaults, and the domain object overrides when it knows better. --- ## State Tracking ARIA states are updated dynamically through the framework's notification system: - **`aria-current`** -- Set to `"true"` on the selected tile, removed when deselected. The selected tile also receives focus. - **`aria-checked`** -- Updated on `SvBooleanFieldTile` when the boolean value changes. - **`aria-selected`** -- Updated on `SvOptionNodeTile` based on `isPicked()` state. - **`aria-disabled`** -- Set on `SvActionFieldTile` when the action's node is not enabled. - **`aria-readonly`** -- Set on `SvFieldTile` when the field is not editable. --- ## Slot Metadata to ARIA Mapping (`syncAriaFromSlotMetadata`) `SvFieldTile` includes a `syncAriaFromSlotMetadata()` method that reads slot annotations and emits corresponding ARIA attributes: ```javascript { const slot = this.newSlot("hitPoints", 0); slot.setSlotType("Number"); slot.setIsRequired(true); slot.setAnnotation("minimum", 0); slot.setAnnotation("maximum", 999); slot.setDescription("Current character hit points"); } ``` Produces a field tile with `aria-required="true"`, `aria-valuemin="0"`, `aria-valuemax="999"`, and `aria-description="Current character hit points"` -- with no accessibility-specific code from the developer. --- ## Live Regions - **Opt-in via nodes:** Any node can declare itself as a live region by implementing `nodeAriaLive()` returning `"polite"` or `"assertive"`. When `SvTilesView` syncs from a node with this method, it sets `aria-live` on the container. - **Direct on chat:** `SvChatMessageTile` sets `aria-live="polite"` directly, so new chat messages and AI responses are announced to screen readers as they arrive. --- ## Focus Management & Keyboard Navigation - **Tiles are programmatically focusable** via `tabindex="-1"`. This makes them reachable by the framework's focus management without adding them to the Tab order. - **Focus indicators** use `:focus-visible` styling (2px solid cornflower blue outline) that appears only for keyboard navigation, not mouse clicks. - **High contrast mode** (`prefers-contrast: more`) increases the focus outline to 3px solid white for maximum visibility. - **Focus follows selection** -- when a tile is selected, it receives both `aria-current="true"` and DOM focus, ensuring screen readers announce the newly selected item. --- ## Visual Accessibility & Motion Preferences - **Reduced Motion (`prefers-reduced-motion: reduce`):** All animations and transitions are reduced to 0.01ms duration, iteration counts set to 1, and scroll behavior set to auto (instant). - **High Contrast (`prefers-contrast: more`):** Focus indicators enhanced to 3px solid white with tighter offset. --- ## ARIA Landmarks Landmark roles provide structural navigation for screen readers: - `SvStackView` is marked as `navigation` -- the top-level navigation structure - `SvNavView` is marked as `region` with an `aria-label` derived from the current node's title - `SvBreadCrumbsTile` is marked as `navigation` with `aria-label="Breadcrumb"` --- ## WCAG 2.2 Compliance Matrix | WCAG Criterion | How Addressed | |---|---| | **1.3.1 Info & Relationships** | ARIA roles and landmarks convey structure | | **1.3.2 Meaningful Sequence** | DOM order matches visual order (flexbox layout) | | **2.1.1 Keyboard** | Arrow keys, Enter, Escape for full navigation | | **2.3.3 Animation from Interactions** | `prefers-reduced-motion` media query | | **2.4.1 Bypass Blocks** | Landmark roles enable skip navigation | | **2.4.6 Headings & Labels** | `aria-label` from node `title()` | | **2.4.7 Focus Visible** | `:focus-visible` outline styling | | **3.2.1 On Focus** | No context changes on focus | | **4.1.2 Name, Role, Value** | ARIA roles, labels, and states on all interactive elements | --- ## Files Modifying Accessibility | File | Responsibilities | |---|---| | `_css.css` | `:focus-visible` styling, `prefers-reduced-motion`, `prefers-contrast` | | `SvTilesView.js` | `role="list"`, `aria-label`, opt-in `aria-live` | | `SvTile.js` | `role="link"`, `tabindex="-1"`, `aria-label`, `aria-description`, `aria-current` | | `SvFieldTile.js` | `role="group"`, `aria-label`, `aria-readonly`, `syncAriaFromSlotMetadata()` | | `SvBooleanFieldTile.js` | `role="checkbox"`, `aria-checked` | | `SvActionFieldTile.js` | `role="button"`, `aria-label`, `aria-disabled` | | `SvOptionsNodeTile.js` | `role="listbox"` | | `SvOptionNodeTile.js` | `role="option"`, `aria-selected` | | `SvChatMessageTile.js` | `aria-live="polite"` | | `SvStackView.js` | `role="navigation"` | | `SvNavView.js` | `role="region"`, `aria-label` | | `SvBreadCrumbsTile.js` | `role="navigation"`, `aria-label="Breadcrumb"`, `aria-current="location"` | --- ## Related Guides - [Nodes](../Nodes/index.html): Core `SvNode` domain abstraction. - [Slots](../Slots/index.html): Complete guide to slot metadata and declarations. --- Source: /docs/Comparing%20to%20React/ # Comparing to React A guide to Strvct for developers who know React. ## The Short Version React and Strvct start from opposite ends. React starts from the view: you write the screens, and the model, storage, and sync are yours to connect. Strvct starts from the model: you write the domain objects, and the screens, storage, and sync are derived from them. React is a view library. You write the screens as components, and you choose and connect the rest yourself: state stores, forms, routing, persistence, and any tools you give an AI agent. Strvct is a model-first framework. You write the domain model as classes with annotated properties (**slots**). The framework builds the rest from that model: the screens, navigation, local storage, cloud sync, JSON import and export, and an interface agents can use to read and edit the data. In a typical React stack, adding one field to a record touches about five places: a database migration, an ORM model, an API schema, a state store, and a form component. In Strvct, you add one slot declaration. --- ## One Record, Both Ways ### React ```jsx // ContactForm.jsx function ContactForm({ contactId, onSave }) { const [name, setName] = useState(""); const [email, setEmail] = useState(""); useEffect(() => { api.getContact(contactId).then(data => { setName(data.name); setEmail(data.email); }); }, [contactId]); const handleSubmit = async (e) => { e.preventDefault(); await api.updateContact(contactId, { name, email }); onSave(); }; return (
); } ``` This is just the form. The API endpoints, the database schema, the route that reaches this screen, and the list screen that links to it are all separate. ### Strvct ```javascript // Contact.js (class Contact extends SvStorableNode { initPrototypeSlots () { { const slot = this.newSlot("name", ""); slot.setSlotType("String"); slot.setShouldStoreSlot(true); // saved locally, synced to the cloud slot.setSyncsToView(true); // the UI updates when it changes slot.setCanEditInspection(true); // shown as an editable field } { const slot = this.newSlot("email", ""); slot.setSlotType("String"); slot.setShouldStoreSlot(true); slot.setSyncsToView(true); slot.setCanEditInspection(true); } } initPrototype () { this.setTitle("Contact"); this.setShouldStore(true); } }.initThisClass()); ``` This is the whole thing. A `Contacts` collection holding these objects gets a list, a detail view with editable fields, navigation between them, storage, and sync. There is no save button, because every edit is committed at the end of the event loop. --- ## Concept Map | In React | In Strvct | The difference | |---|---|---| | Component (JSX) | A view derived from the node, or a custom view class | Views are created at runtime, as the user navigates, from the node and its slots. | | `useState` | A slot, read with `name()` and set with `setName(v)` | State lives on model objects, not in components. | | Context, Redux, Zustand | The object graph itself | There is one model. Views observe it, and nothing copies it into a store. | | `useEffect` | A notification observation, or a `didUpdateSlot()` method | Declaring `didUpdateSlotEmail()` is the subscription. Observations are weak, so there is nothing to unsubscribe. | | React Router | The navigation path through the object graph | A screen is a path of nodes, so there is no route table to maintain. | | TanStack Query, REST, an ORM | Object pools in IndexedDB, synced to the cloud | Changed objects are marked dirty and committed in a batch. | | TypeScript, PropTypes | Slot types, checked at runtime | The same type information validates setters, imported JSON, and agent patches. | | Tool definitions for an LLM | A generic schema-and-patch interface | Agents read a class's schema and send JSON patches. Adding a class adds no tools. | --- ## How Screens Are Decided In React you design each screen. In Strvct, a screen comes from a few decisions about the model, which you state as hints on the node class: - **Beside or inside.** When you open a child, does it get its own column or tab beside its parent, or is it drawn inside the parent as a section of a document? The default is a column. `nodeChildrenLayout()` returning `"inline"` shows the next levels in place as a document, and `nodeSubnodesAreAnchoredTabs()` shows children as tabs that open side by side when there is room. - **What shows.** A node can present a different node in its place with `nodePresentedNode()`. For example, a character can present a readable character sheet built from its data. - **How items look.** Hints such as `nodeTileLayout()` and `nodeChildrenTileWidth()` name a role, like `"status"` or `"roster"`, and the theme decides what that role looks like. The framework takes care of the mechanics: the navigation path, collapsing columns into a stack on a phone, turning side-by-side panes into tabs when space runs out, editing in place, and keyboard and screen-reader support. A layout change is usually a one-line hint, not a new screen. --- ## How State Flows **React:** A state change re-renders the component subtree. React diffs the new virtual DOM against the old one and patches the real DOM. To persist the change, you add an effect, a mutation hook, or a sync layer. **Strvct:** A view calls a setter on the model. The setter updates the slot, marks the object dirty for storage, and posts a notification. At the end of the event loop, the sync scheduler merges duplicate updates, and each observing view reads the new values from its node. Nothing is diffed, and persistence is part of the same step. The model never refers to views. Because of this, the same model code runs under Node.js with no browser, so domain tests don't need jsdom or a headless browser. --- ## When the Generated UI Isn't Enough Everyone asks this first: what happens when I need a kanban board, a canvas, or a layout that doesn't follow the object hierarchy? The answer comes in steps, from least code to most: 1. **Use an existing hint.** Many "custom" layouts turn out to be an inline document, a set of anchored tabs, or a presented node. 2. **Add a new hint.** If a look is missing, add a hint that names the role and teach the generic view to read it. Every node can use it after that, and it follows the theme. 3. **Write a custom view.** For genuinely custom drawing, such as a canvas, a map, or a board, write a view class. Views are found by name: a `Contact` node uses a `ContactView` if one exists. You can also name the class with `nodeViewClassName()`. The view observes the node and calls its methods, and everything else in the app stays generated. A custom view is simpler to write here than a React component, and simpler for a coding agent to write too. The data contract already exists: the node's slots, their types, and its notifications. The view doesn't fetch, cache, or store anything. It reads the node, draws, and calls methods on the node. Its scope is limited to the one node it replaces, and it can still hand that node's children back to the generated views. The cost is real, though. A custom view is UI that is no longer derived from the model, so it doesn't follow theme changes automatically and you maintain it by hand. That is why it is the last step, not the first. --- ## Trade-offs **What you give up with Strvct:** - **The ecosystem.** Strvct doesn't use npm in the browser or React component libraries. Third-party code is vendored as source. You won't find a shadcn/ui or MUI equivalent. - **Control over every screen.** You shape screens through the model and hints. If your product is mainly a sequence of designed screens, such as a landing page, a storefront, or a branded onboarding flow, you will be working against the framework. - **SEO.** There is no server-side rendering. The UI is built in the browser. - **The style.** Strvct uses classes, mutable objects, and declared slots. If you are used to functional components and hooks, it will take some adjustment. **What you get:** - One model drives the UI, storage, sync, exchange, and agent access, so they can't drift apart. - Local-first by default: the app works offline and syncs when it can. - An AI interface that doesn't grow with the model. Agents read schemas and send patches, and a rejected patch can return the slot's schema so the agent can correct itself. - Domain tests that run under plain Node.js. **Strvct fits** structured-information apps: CRMs, project and issue trackers, editors for structured documents, settings panels, admin tools, game tools, and apps where people and AI agents work on the same data. **React fits** apps where the screens are the product: marketing sites, storefronts, media-heavy pages, and anything that depends on SEO or on a specific component library. --- Source: /docs/Diagrams/ # Diagrams Architectural sketches of the Strvct framework. Working drafts; not yet placed in their final locations within the docs. - Layers - Annotations - Sync Flow - View Resolution - Persistence Pipeline - Conventions --- Source: /docs/Diagrams/Annotations/ # Annotations One slot declaration carries metadata that independent framework layers read without coordinating. Adding a new layer leaves existing layers unchanged. Single Slot Declaration (SvSlot) const slot = this.newSlot("name", ""); slot.setSlotType("String"); slot.setShouldStoreSlot(true); slot.setSyncsToView(true); slot.setCanEditInspection(true); slot.setIsSubnodeField(true); slot.setFinalInitProto(Inventory); UI Layer Type, edit, & nav Storage Layer IndexedDB rows Sync Engine Deferred notifications AI Tool Surface schema-fetch & patch i18n Engine Translation context No inter-layer coordination; each consumer reads only its relevant slot metadata annotations. --- Source: /docs/Diagrams/Conventions/ # Diagram Conventions Style and layout rules for the SVG diagrams used throughout the Strvct docs. ## Why a Convention The docs use ~30 inline SVG diagrams to visualize architecture, flows, and relationships. Without a shared style they drift apart, become harder to scan, and require per-page mental re-orientation. The rules below let any diagram be authored, edited, or scripted against the same set of expectations. ## Style Block Every diagram opens with the same ` ``` - **`.b`** — bold text (titles, labels) - **`.dim`** — secondary text (descriptions, captions); color `#666` - **`.box`** — outline rectangle, no fill; used for outer containers - **`.fill`** — cream-filled rectangle (`#f0ede5`); used for inner content blocks - **`.flow`** — solid line for direct references / calls / direct data flow - **`.flow-dashed`** — dashed line (`4 3`) for indirect notifications, observers, no-direct-reference relationships ## Arrowhead Markers A single arrowhead marker is defined per diagram in ``, with a unique id (e.g., `ato`, `aio`, `anc`): ```svg ``` Lines reference it via `marker-end="url(#xxx)"`. ## ViewBox - **Width**: 820 (matches the docs column width) - **Height**: tight to content with ~20px bottom margin below the last element ## Layout Rules ### Inside fill rects Content is **left-top justified** with consistent padding: - **Text x** = `fill.x + 15` (15px left padding) - **First text baseline y** = `fill.y + 20` - **Subsequent lines** spaced 18px apart - **Bottom padding** = 11px (cap-top above first baseline matches descender-bottom below last baseline). Concretely: `fill.h = (last_text_y - fill.y) + 14`. ### Stacking fill rects Vertically adjacent fill rects in the same column should sit **15px apart** when they're sibling rows in a list. Larger gaps (~30px) are appropriate when an arrow + label lives between them. For centered stacks (rects whose horizontal centers align around `viewBox.width / 2`), give all rects the same width — use the maximum needed by any row's content, centered. ### Inside .box containers Containers wrap one or more `.fill` rects plus optional title/subtitle text and caption text below the fills. - **Container title (b)** at `container.x + 15`, `container.y + 22` - **Container subtitle (dim)** at `container.x + 15`, `container.y + 42` (when present) - **Inner fills** at `container.x + 15`, `container.y + 60+` (with 15px horizontal padding from container edges) - **Captions below last fill** are left-justified at `container.x + 15`, starting at `last_fill_bottom + 24`, with 18px line spacing - **Container bottom padding** = 15px below the lowest content element ### Multi-column layouts For 2- and 3-column comparisons, each column's containers should be the same width and aligned at the top (`y=20`). Container heights should match (use the tallest column's height). Captions inside columns are still left-justified to their column. ## Lines and Arrows - **Solid line** (`.flow`) — direct reference or call (e.g., a UI view calling getter/setter on its model node) - **Dashed line** (`.flow-dashed`) — indirect notification or observation (e.g., the model posts a notification, observers pick it up without holding a reference) - **Arrow direction** points to the *recipient* of the action For the Model ↔ UI ↔ Storage triple, mutation notifications from Model outward are **dashed** (Model holds no references); UI/Storage calls into Model are **solid** (they hold direct references). ## Two-line Arrow Labels When labeling a line in a tight gap: - **For label above the line**: two text elements at `arrow_y - 22` and `arrow_y - 7` - **For label below the line**: two text elements at `arrow_y + 13` and `arrow_y + 28` - All centered with `text-anchor="middle"` at the gap midpoint x ## Captions and Footnotes The summary line below a diagram is **left-justified** at the same x as the leftmost container (when there is one) or `container.x + 15`. Do not center such lines. ## When to Break the Conventions The conventions exist to keep diagrams scannable, not to be rigid. Acceptable deviations: - A diagram showing a state machine or a network graph won't use stacked fills at all - A side-by-side comparison may need asymmetric heights when content lengths differ enough that padding the shorter side would look strange - Inline annotations (e.g., a small "(weak ref)" label between two boxes) can sit at any x When in doubt, prefer consistency with adjacent diagrams in the same page or section. --- Source: /docs/Diagrams/Layers/ # Layers Application code sits on the Strvct framework, which sits on the platform. Inside Strvct, the slot system is the shared metadata layer that independent consumers read. Application Code UoCharacter, UoCampaign, UoSession, Custom Domain Classes STRVCT Framework Domain Model SvNode object graph View Layer SvNodeView hierarchy & Miller tiles Slot Annotation Metadata Bridge Persistence shouldStoreSlot Sync Engine syncsToView AI Tool Surface schema-fetch/patch i18n Engine translationContext JSON Schema type validation Web Browser / Electron Platform IndexedDB · DOM API · Web Fetch Node.js Headless Platform LevelDB · Browser API Shims --- Source: /docs/Diagrams/Persistence%20Pipeline/ # Persistence Pipeline Drilling into Local Storage. The object pool persists slot mutations through the synchronous track on the left. The blob pool stores content-addressable binaries asynchronously on the right. Garbage collection bridges them: the object pool walks reachable nodes, collects referenced hashes, and the blob pool removes any blob not in that set. Object Pool & Record Store (Synchronous) SvNode Setter Mutates Slot Slot setter invokes didMutate() addDirtyObject(self) Schedules deferred commit in SvObjectPool End of Event Loop Commit SvPersistentAtomicMap begins transaction SvRecordRow Written to IndexedDB Row payload keyed by (poolId + objectId) Mark & Sweep GC Traces reachable nodes & collects referenced SHA-256 binary hash strings SHA-256 Blob Store (Asynchronous CAS) asyncStoreBlob(ArrayBuffer) Triggered from app code or media upload sha256(ArrayBuffer) -> Hash Digest Computes content-addressable key Write Hash -> Data + Metadata Stores raw binary in IndexedDB SvBlobPool Domain Node Stores Hash String Slot holds hash ref string ("hash:...") Orphan Blob Purge Deletes binary blobs not in GC referenced hash set --- Source: /docs/Diagrams/Sync%20Flow/ # View ↔ Model ↔ Storage Syncing A user or agent mutation is validated by the setter, then broadcast through the notification center. View and storage layers schedule their work end-of-event-loop. User Event / Agent Patch Input SvNodeView Action Handler Processes UI gesture & calls model setter SvNode Setter Validates type & updates private slot state Rejection Response Returns slot schema SvNotificationCenter Posts "didChangeSlot" to observing targets Observing Views Schedules syncFromNode() in SvSyncScheduler Coalesced View Re-Render Pass SvObjectPool Persistence Hook addDirtyObject(self) queues record commit Atomic IndexedDB Commit Coalesced once per event loop. Bidirectional synchronization halts automatically when setter values converge. --- Source: /docs/Diagrams/View%20Resolution/ # View Resolution When a node becomes visible, the framework finds a view class by climbing the node's inheritance chain. Custom views are an override; the default is always available. Navigate to Node N (Instance of Class C) C Declares nodeViewClass() Override? Use Declared Class Look Up Class Name: C.name + "View" Found Matching View Class in Scope? Instantiate View Class Climb to Superclass Reaching the prototype root without a match falls back to SvNodeView (framework default view). --- Source: /docs/Events%20and%20Gestures/ # Events and Gestures Event flow, listeners, gesture recognizers, timers, keyboard handling, and drag-and-drop. STRVCT provides two layers for handling user interaction: **event listeners** that wrap native DOM events and forward them to handler methods on views, and **gesture recognizers** that interpret sequences of events as higher-level gestures like taps, pans, and pinches. A managed **timer system** supports deferred work with both strong and GC-friendly weak timeouts. Most application code uses gesture recognizers rather than raw event listeners. The gesture system unifies mouse and touch input, handles multi-touch emulation on desktop, and coordinates competing gestures through a global `SvGestureManager`. text { font-family: 'Inter', system-ui, -apple-system, sans-serif; font-size: 12px; fill: #111; } .b { font-weight: 600; } .dim { fill: #666; } .box { fill: none; stroke: #111; stroke-width: 1; } .fill { fill: #f0ede5; stroke: #111; stroke-width: 1; } .flow { stroke: #111; stroke-width: 1; fill: none; } Browser DOM Event mousedown, touchstart, keydown, drop, ... - SvEventListener wraps a DOM event; calls a named method on the delegate view (e.g. onMouseDown) - if a gesture recognizer is attached SvGestureRecognizer · optional layer state machine consumes raw events; SvGestureManager arbitrates competing gestures; sends onGestureBegin / Move / Complete to view - View Handler application logic runs For raw events without gestures, the listener calls the view's handler method directly, skipping the gesture layer. - Event Flow - Event Listeners - Gesture Recognizers - Timers - Keyboard and Focus - Drag and Drop --- Source: /docs/Events%20and%20Gestures/Drag%20and%20Drop/ # Drag and Drop Browser drag-and-drop support for views and nodes, covering drop targets, drag sources, and MIME-type dispatch. ## Overview The browser's native HTML5 drag-and-drop API is low-level and inconsistent—you must manually parse `DataTransfer` objects, handle files versus text strings differently, prevent default browser navigation on dropped files, and manage empty-space drops that bypass child elements. STRVCT wraps this into a clean, declarative protocol: - **Drop Targets:** Views register to accept dropped content (`setIsRegisteredForBrowserDrop(true)`). Dropped data arrives pre-parsed, typed by MIME, and dispatched directly to a handler method named by convention. - **Drag Sources:** Views register as draggable sources (`setIsRegisteredForBrowserDrag(true)`), populating `DataTransfer` payloads when a drag initiates. 1. Browser DOM Drop Event DataTransfer with files, text, HTML, or JSON 2. SvDropListener Target Check dragenter / dragover / dragleave / drop; Checks view.acceptsDrop(event) 3. MIME-Type Convention Dispatch text/plain → onBrowserDropTextPlain(dataChunk) text/html → onBrowserDropTextHtml(dataChunk) image/png → onBrowserDropImagePng(dataChunk) app/json → onBrowserDropApplicationJson(chunk) 4. View or Model Node Handler Runs Application processes typed data chunk; unhandled MIME types are silently ignored Register drop support via setIsRegisteredForBrowserDrop(true) and implement one handler method per accepted MIME type. --- ## Key Framework Classes | File / Class Name | Purpose & Responsibilities | |---|---| | `SvDomView_browserDragAndDrop.js` | Category on `SvDomView` implementing drop/drag target APIs. | | `SvDropListener.js` | Manages element drop event listeners (`dragenter`, `dragover`, `dragleave`, `drop`). | | `SvDragListener.js` | Manages element drag source event listeners (`dragstart`, `dragend`). | | `SvDocumentBody.js` | Global drop prevention on `document.body` to stop browser file navigation. | --- ## Drop Targets API ### 1. Registering a View for Drops ```javascript init () { super.init(); this.setIsRegisteredForBrowserDrop(true); // Attaches SvDropListener return this; } ``` ### 2. Accepting or Rejecting Drops Override `acceptsDrop(event)` to inspect incoming transfer types: ```javascript acceptsDrop (event) { // Inspect event.dataTransfer.types return event.dataTransfer.types.includes("text/plain"); } ``` ### 3. MIME Type Method Dispatch (`dropMethodForMimeType`) | MIME Type | Convention Handler Method Name | |---|---| | `text/plain` | `onBrowserDropTextPlain(dataChunk)` | | `text/html` | `onBrowserDropTextHtml(dataChunk)` | | `image/png` | `onBrowserDropImagePng(dataChunk)` | | `image/jpeg` | `onBrowserDropImageJpeg(dataChunk)` | | `application/json` | `onBrowserDropApplicationJson(dataChunk)` | ### 4. Data Chunk Object (`SvDataUrl`) Dropped payloads are wrapped in an `SvDataUrl` instance (`dataChunk`): - `dataChunk.mimeType()`: Returns the MIME type string. - `dataChunk.decodedData()`: Returns the decoded string or JSON content. - `dataChunk.setDataUrlString(url)`: Contains the data URL string for dropped files. ### 5. Visual Drag Highlighting Override styling hooks for hover feedback: ```javascript dragHighlight () { this.setBorder("2px dashed cornflowerblue"); } dragUnhighlight () { this.setBorder("none"); } ``` --- ## Drag Sources API To make a view draggable: ```javascript init () { super.init(); this.setIsRegisteredForBrowserDrag(true); return this; } // Populate transfer payload on drag start onBrowserDragStart (event) { const dt = event.dataTransfer; dt.setData("text/plain", this.node().title()); dt.setData("application/json", JSON.stringify(this.node().asJson())); } ``` --- ## Related Guides - [Gesture Recognizers](../Gesture%20Recognizers/index.html): Touch and mouse gesture state machines. - [Keyboard and Focus](../Keyboard%20and%20Focus/index.html): Modifier-aware key routing. --- Source: /docs/Events%20and%20Gestures/Event%20Flow/ # Event Flow The end-to-end path from a browser event to an application handler. ## Overview Raw DOM events are too low-level for most application code. Distinguishing a tap from a long-press from a pan requires tracking timing, movement thresholds, and finger counts — and when multiple gestures compete on the same element, the browser offers no arbitration. STRVCT's event pipeline absorbs this complexity: raw events feed into gesture recognizer state machines, a central SvGestureManager resolves conflicts (so a tap and a long-press on the same view don't both fire), and the application only sees clean, high-level callbacks like `onTapComplete` or `onPanMove`. Views that don't need gestures can still handle raw events directly — the gesture layer is additive, not mandatory. 1. Browser DOM Event mouse, touch, keyboard, drop, ... 2. SvEventListener calls named method on delegate view; returning false stops propagation if a gesture recognizer is attached 3. Recognizer state machine updates tracks finger count, timing, movement; requests activation when conditions are met 4. SvGestureManager arbitrates resolves competing gestures across views; if accepted, sends delegate messages 5. View handler executes onGestureBegin / Move / Complete / Cancelled, or raw onMouseDown, etc., for non-gesture events For raw event listeners (no gesture), steps 3 and 4 are skipped; the listener calls the view handler directly at step 2. For raw event listeners (without gestures), the handler is called directly on the view at step 2, skipping the gesture layer. ## Detailed Steps 1. **Browser fires a native DOM event** (mouse, touch, keyboard, etc.) on a DOM element. 2. **An `SvEventListener` receives it.** The listener was registered on the view's element via `addEventListener()`. It calls the corresponding method on its delegate — typically the view itself. For example, a `mousedown` event calls `onMouseDown(event)` on the view. 3. **Returning `false` stops propagation.** If the handler returns `false`, `event.stopPropagation()` is called, preventing the event from bubbling to ancestor elements. 4. **Gesture recognizers observe the event.** If the view has gesture recognizers attached, they receive the raw event and update their internal state machines. For example, a `SvTapGestureRecognizer` tracks mousedown/mouseup timing and position. 5. **The recognizer requests activation.** When the gesture's conditions are met (correct finger count, sufficient movement, hold duration, etc.), it calls `SvGestureManager.requestActiveGesture()`. 6. **SvGestureManager arbitrates.** The singleton manager checks whether another gesture is already active, considers the view hierarchy, and decides whether to accept or reject the request. Competing gestures on the same or ancestor views are cancelled. 7. **The recognizer sends delegate messages.** If accepted, the recognizer calls phase methods on the view: `onGestureBegin`, `onGestureMove`, `onGestureComplete`, or `onGestureCancelled`. 8. **The view executes application logic.** The handler method runs whatever the application needs — updating model state, triggering animations, navigating, etc. ## Special Cases - **Keyboard events** route through `SvKeyboard`, which generates modifier-aware method names (e.g., `onShiftAKeyDown`). - **Drag-and-drop events** route through `SvDropListener`/`SvDragListener` and the MIME dispatch chain in `SvDomView_browserDragAndDrop`. - **Focus events** interact with the responder chain in `SvResponderDomView`. --- Source: /docs/Events%20and%20Gestures/Event%20Listeners/ # Event Listeners Thin wrappers around native DOM events that forward to handler methods on views. ## Architecture Calling `addEventListener` directly ties views to specific DOM event names and requires manual bookkeeping — tracking which listeners are registered, removing them at the right time, and ensuring handlers exist before registering. Event listeners centralize this: they register lazily on first use, group related events (e.g., all mouse events) into a single toggle, dispatch to named methods on the view, and clean up automatically when the view is retired. This keeps views focused on handling events rather than managing listener lifecycle. Event listening is built on two base classes: - **`SvEventListener`** — Wraps a single DOM event. Registers with a target element, and when the event fires, calls a named method on its delegate (typically the view). - **`SvEventSetListener`** — Groups related `SvEventListener` instances. Subclasses define which events they cover via `setupListeners()`. Views manage their listeners through `SvListenerDomView`, which maintains a map of listener class names to listener instances. Listeners are created lazily on first access and cleaned up when the view is removed. SvListenerDomView manages a map of listeners; lazy creation, automatic cleanup SvMouseListener mousedown, mouseup, mouseover, mouseleave, click, dblclick, contextmenu SvKeyboardListener keydown, keyup, input SvTouchListener touchstart, touchmove, touchend, touchcancel view.onMouseDown(event) view.onClick(event), ... view.onKeyDown(event) view.onKeyUp(event) view.onTouchStart(event) view.onTouchMove(event) Each listener registers lazily on first use and cleans up automatically when the view is removed. ## Available Listeners | Listener | Events | |----------|--------| | `SvMouseListener` | mousedown, mouseup, mouseover, mouseleave, click, dblclick, contextmenu | | `SvMouseMoveListener` | mousemove (separate to avoid overhead when not needed) | | `SvTouchListener` | touchstart, touchmove, touchcancel, touchend | | `SvTouchMoveListener` | touchmove (separate for same reason) | | `SvKeyboardListener` | keydown, keyup, input | | `SvFocusListener` | focus, blur, focusin, focusout | | `SvDragListener` | dragstart, drag, dragend | | `SvDropListener` | dragenter, dragover, dragleave, drop | | `SvScrollListener` | scroll | | `SvWheelListener` | wheel | | `SvClipboardListener` | copy, cut, paste | | `SvSelectListener` | select | | `SvWindowListener` | resize | | `SvAnimationListener` | animationstart, animationend, animationiteration | | `SvTransitionListener` | transitionend | | `SvGamePadListener` | gamepadconnected, gamepaddisconnected | ## Registering for Events Views provide convenience methods for common event families: ```javascript view.setIsRegisteredForMouse(true); // onMouseDown, onMouseUp, etc. view.setIsRegisteredForKeyboard(true); // onKeyDown, onKeyUp view.setIsRegisteredForFocus(true); // onFocus, onBlur view.setIsRegisteredForClicks(true); // uses a SvTapGestureRecognizer internally view.setIsRegisteredForWindowResize(true); view.setIsRegisteredForBrowserDrop(true); ``` Event handler methods are called by name on the view. Returning `false` from a handler calls `event.stopPropagation()` to prevent the event from bubbling. ## Listener Lifecycle Listeners are created lazily when first accessed via `SvListenerDomView.listenerNamed()`: ```javascript listenerNamed (className) { const map = this.eventListenersMap(); if (!map.has(className)) { const instance = Object.getClassNamed(className).clone() .setListenTarget(this.element()) .setDelegate(this); map.set(className, instance); } return map.get(className); } ``` The listener target is the view's DOM element. The delegate is the view itself. `SvEventSetListener.start()` iterates its child `SvEventListener` instances, each of which: 1. Checks `delegateCanRespond()` — verifies the delegate has the handler method 2. Calls `addEventListener()` on the target element with the configured options `stop()` removes all event listeners. `setIsListening(bool)` toggles between started and stopped states. If the listen target, delegate, or capture mode changes while listening, the listener automatically stops, updates its configuration, and restarts via `resync()`. ## Cleanup Listeners are automatically removed when a view is retired from the hierarchy. The view's `prepareToRetire()` calls `removeAllListeners()`, which stops every registered `SvEventSetListener` and clears the listener map. No manual cleanup is needed for views that follow normal lifecycle patterns. --- Source: /docs/Events%20and%20Gestures/Gesture%20Recognizers/ # Gesture Recognizers Higher-level state machines that interpret sequences of events as meaningful gestures. ## Unified Input Architecture The browser provides two separate event families for pointing—mouse events on desktop and touch events on mobile—with different semantics, coordinate systems, and lifecycle patterns. Without an abstraction layer, every interactive view needs parallel code paths for both input types, plus logic to prevent ghost clicks and handle edge cases where both fire simultaneously. Gesture recognizers eliminate this complexity: - They consume raw mouse and touch events internally and present a single, input-agnostic interface to the view. - A `SvPanGestureRecognizer` works identically whether driven by a mouse drag or a finger swipe—the view implements `onPanBegin` once and it works on every device. - New interaction features are automatically cross-platform from the first line of code, with no per-device testing or branching required. Mouse input naturally supports single-finger gestures (tap, pan, long-press, slide). Multi-finger gestures (pinch, rotation) require touch input or desktop Shift-click multi-touch emulation. 1. Raw Mouse / Touch Input Stream Unified input abstraction 2. SvGestureRecognizer State Machine Tracks finger count, timing, movement, hold; Tap, Pan, Pinch, Rotation, LongPress, Slide 3. SvGestureManager Singleton Arbitration Arbitrates competing gestures; Cancels conflicts across view hierarchy 4. Delegate Phase Messages Sent to View onGestureBegin → onGestureMove → onGestureComplete (or onGestureCancelled if interrupted) 5. Application Handler Executes --- ## How Gestures Work A gesture recognizer is a state machine attached to a view via `addGestureRecognizer()`. When gesture conditions are met, the recognizer sends delegate messages to the view: ``` acceptsGestureType(gesture) — Optional: can the view accept this gesture? onGestureTypeBegin(gesture) — Gesture recognized and started onGestureTypeMove(gesture) — Gesture in progress onGestureTypeComplete(gesture) — Gesture completed successfully onGestureTypeCancelled(gesture) — Gesture interrupted or cancelled ``` --- ## Complete Gesture Recognizers Suite | Recognizer Class | Detects | Primary Configuration Settors | |---|---|---| | **`SvTapGestureRecognizer`** | Single or multi-tap | `setNumberOfTapsRequired()`, `setNumberOfFingersRequired()`, `setMaxHoldPeriod()` | | **`SvPanGestureRecognizer`** | Click-and-drag panning | `setMinNumberOfFingersRequired()`, `setMaxNumberOfFingersAllowed()` | | **`SvPinchGestureRecognizer`** | Two-finger pinch/zoom | Fixed to 2 fingers | | **`SvRotationGestureRecognizer`** | Two-finger rotation | Fixed to 2 fingers | | **`SvLongPressGestureRecognizer`** | Press-and-hold gesture | `setTimePeriod()` (default 500ms) | | **`SvSlideGestureRecognizer`** | Directional slide | `setDirection("left"|"right"|"up"|"down")`, `setMaxPerpendicularDistToBegin()` | | **`SvEdgePanGestureRecognizer`** | Pan starting at view edge | Subclasses for left, right, top, bottom edges | | **`SvScreenEdgePan`** | Pan starting at screen boundary | Subclasses for left, right, top, bottom screen boundaries | --- ## Adding Gestures & Convenience API ```javascript // Convenience methods on SvDomView view.addDefaultTapGesture(); // Single tap view.addDefaultDoubleTapGesture(); // Double tap view.addDefaultPanGesture(); // Drag panning // Custom recognizer configuration const gesture = SvLongPressGestureRecognizer.clone(); gesture.setTimePeriod(800); // 800ms hold requirement view.addGestureRecognizer(gesture); // View implements callback handler onLongPressComplete (gesture) { this.openContextMenu(); } ``` --- ## Global Arbitration (`SvGestureManager`) `SvGestureManager` is a singleton that coordinates competing gestures globally across the entire view tree: - **Priority & Hierarchy:** Child views can steal control from parent views. - **Active Lock:** Once a gesture is accepted, competing gestures on the same or ancestor views are automatically cancelled. - **Explicit Cancellation:** Views can cancel gestures programmatically: `view.cancelAllGesturesExcept(panGesture)`. --- ## Cleanup, Teardown & Memory Safety When a view is retired and unmounted from the DOM hierarchy, `prepareToRetire()` executes a 3-step cleanup pipeline: 1. **`removeAllGestureRecognizers()`:** Stops each recognizer, removes DOM listeners, and clears the view target. 2. **`removeAllListeners()`:** Unbinds all element-level DOM event listeners. 3. **`cancelAllTimeouts()`:** Clears any pending gesture hold timers. ### Weak Reference Timers: Gesture recognizers use **`addWeakTimeout()`** for internal hold delays. `addWeakTimeout()` holds only a `WeakRef` to the view target, enabling unmounted views to be reclaimed cleanly by JavaScript's garbage collector without timer leaks. --- ## Multi-Touch Desktop Emulation On desktop browsers, holding **Shift** while clicking simulates a second touch point. This allows testing multi-finger pinch, zoom, and rotation gestures using a standard mouse. --- ## Related Guides - [Drag and Drop](../Drag%20and%20Drop/index.html): HTML5 drag-and-drop MIME dispatch. - [Keyboard and Focus](../Keyboard%20and%20Focus/index.html): Modifier-aware key routing. --- Source: /docs/Events%20and%20Gestures/Keyboard%20and%20Focus/ # Keyboard and Focus Keyboard state tracking, modifier-aware key dispatch, and the responder chain for focus management. ## Overview The browser's native keyboard handling has two critical gaps: 1. `keydown` and `keyup` events tell you which key was pressed, but not which other keys are currently held. 2. DOM `focus` is element-level without a concept of a view hierarchy responder chain or tab-order routing between custom view containers. STRVCT addresses both: - **`SvKeyboard` Singleton:** Tracks global keyboard state and generates **modifier-aware method names** (e.g. `onShiftAKeyDown`, `onAlternate_D_KeyDown`). - **`SvResponderDomView`:** Layers a responder chain on top of DOM focus to manage focus acquisition, loss, and Tab-key navigation through the view tree. 1. Raw keydown Event key: "A", modifiers: Shift held 2. SvKeyboard Singleton Tracks currently pressed keys & modifiers; Builds method name: "onShiftAKeyDown" 3. Responder Chain (SvResponderDomView) First responder (focused view) receives event; nextKeyView controls Tab-order routing 4. view.onShiftAKeyDown(event) Runs View-specific key handler executes Views handle specific key combinations by implementing named methods; no modifier-flag parsing required. --- ## Modifier-Aware Method Naming Pattern When a key event fires, `SvKeyboard` generates a method name following the pattern: ``` on[Modifiers][KeyName]Key[Down|Up] ``` ### Examples: - Pressing **A** with **Shift**: `onShiftAKeyDown(event)` - Pressing **D** with **Option/Alt** and **Shift**: `onAlternate_D_KeyDown(event)` (toggles Developer Mode) - Pressing **Enter**: `onEnterKeyDown(event)` - Pressing **Escape**: `onEscapeKeyDown(event)` --- ## Platform Modifier Mappings - **macOS:** Command key maps to `MetaLeft` / `MetaRight` (`onMetaKey...`). Option key maps to `Alternate` (`onAlternateKey...`). - **Windows / Linux:** Control key maps to `Control` (`onControlKey...`). Alt key maps to `Alternate` (`onAlternateKey...`). --- ## Responder Chain (`SvResponderDomView`) `SvResponderDomView` provides focus management methods across the view tree: - **`acceptsFirstResponder()`:** Returns `true` if the view can receive keyboard focus. - **`becomeFirstResponder()`:** Acquires focus, updates styling, and calls `willBecomeFirstResponder()`. - **`releaseFirstResponder()`:** Releases focus and calls `willReleaseFirstResponder()`. - **`nextKeyView`:** References the next view in the tab order, enabling Tab key navigation across view inputs. --- ## Related Guides - [Gesture Recognizers](../Gesture%20Recognizers/index.html): Touch and mouse gesture state machines. - [Drag and Drop](../Drag%20and%20Drop/index.html): HTML5 drag-and-drop MIME dispatch. --- Source: /docs/Events%20and%20Gestures/Timers/ # Timers Managed timeout system for scheduling deferred work, with support for weak references to avoid preventing garbage collection. ## Object_timeouts All objects in STRVCT inherit timeout management through the `Object_timeouts` category on `Object`. This provides named, trackable timeouts that can be cancelled individually or in bulk — replacing direct `setTimeout` calls throughout the framework. Direct `setTimeout` calls are fire-and-forget: there is no built-in way to cancel them by name, deduplicate them, or cancel all pending timers on an object at once. Worse, because the browser's timer queue holds a strong reference to the callback closure — which typically captures `this` — the target object cannot be garbage collected until every pending timer fires, even if nothing else references it. `Object_timeouts` solves both problems: named timeouts with automatic deduplication prevent timer accumulation, and the `addWeakTimeout` variant breaks the strong reference chain so that unreachable objects can be collected without waiting for their timers. ### Basic Usage ```javascript // Fire after a delay this.addTimeout(() => this.doSomething(), 1000); // Named timeout (replaces any existing timeout with the same name) this.addTimeout(() => this.poll(), 5000, "pollTimer"); // Cancel a named timeout this.clearTimeoutNamed("pollTimer"); // Cancel all timeouts on this object this.cancelAllTimeouts(); ``` ### Strong vs Weak Timeouts The framework provides two timeout methods with different garbage collection behavior: **`addTimeout(func, delay, name)`** — The standard timeout. The browser's timer queue holds a strong reference to the callback closure, which typically captures `this`. This **prevents the object from being garbage collected** until the timer fires. Use this when the work must happen regardless of the object's lifecycle — network retries, resource cleanup, message delivery guarantees. **`addWeakTimeout(func, delay, name)`** — A GC-friendly timeout. Stores the callback on the object itself and uses only a `WeakRef` in the `setTimeout` closure. If the object becomes unreachable before the timer fires, it can be collected and the timer silently becomes a no-op. Use this for work that only matters while the object is alive — UI updates, animations, gesture state management. ```javascript // Strong: retry must happen even if no one holds a reference to this request this.addTimeout(() => this.retryRequest(), 5000); // Weak: animation only matters if the view still exists this.addWeakTimeout(() => this.fadeOut(), 300); ``` addTimeout · strong closure pins the object alive Browser timer queue held by the JS engine strong ref Callback closure captures the object directly strong ref Object pinned; cannot be collected addWeakTimeout · GC-friendly weak link breaks the chain Browser timer queue held by the JS engine strong ref Closure holds only WeakRef + Symbol weak ref Object collectable; timer becomes no-op The weak link between closure and object breaks the reference chain that would otherwise pin the object alive. ### How Weak Timeouts Work A regular `setTimeout` closure captures `this`, creating a strong reference chain from the browser's timer queue to the object. This prevents garbage collection even if nothing else references the object. `addWeakTimeout` breaks this chain: 1. The callback is stored on the object in a `weakTimeoutCallbackMap` (keyed by Symbol) 2. The `setTimeout` closure captures only a `WeakRef` to the object and the Symbol key 3. When the timer fires, it calls `deref()` on the `WeakRef` 4. If the object was collected, `deref()` returns `undefined` and the timer is a no-op 5. If the object is still alive, the callback is retrieved from the map and executed The callback itself may capture `this` via a closure (e.g., `() => this.doSomething()`), but since it is stored *on the object*, this creates a reference cycle rather than a rooted chain. The cycle is collectible by the mark-and-sweep GC when no external root references the object. ### When to Use Which | Scenario | Method | Reason | |----------|--------|--------| | Network request retry | `addTimeout` | Retry must fire to avoid silent failures | | Polling for external state | `addTimeout` | External operation continues regardless | | Resource cleanup (e.g., revoking blob URLs) | `addTimeout` | Leak prevention must happen | | Peer connection heartbeat | `addTimeout` | Connection health requires it | | View animation timing | `addWeakTimeout` | No view = nothing to animate | | Gesture deactivation delay | `addWeakTimeout` | No gesture = nothing to deactivate | | UI scroll/focus scheduling | `addWeakTimeout` | No view = nothing to scroll or focus | | Coach mark display delay | `addWeakTimeout` | No view = nothing to display | ### Naming and Deduplication When a name is provided, `addTimeout` and `addWeakTimeout` both cancel any existing timeout with the same name before scheduling the new one. This prevents accumulation of duplicate timers: ```javascript // Each call replaces the previous "autoSave" timer this.addTimeout(() => this.save(), 5000, "autoSave"); ``` ### Bulk Cancellation `cancelAllTimeouts()` cancels every pending timeout (both strong and weak) on the object. This is called by `prepareToRetire()` during view teardown, but can also be called manually when resetting an object's state. ## Integration with Views Gesture recognizers and views use `addWeakTimeout` for their internal timers: - **`SvGestureRecognizer.didFinish()`** — Deferred deactivation after gesture completes - **`SvLongPressGestureRecognizer`** — Long-press detection timer - **`SvTapGestureRecognizer`** — Maximum hold period before cancellation - **`SvDomView_animations`** — CSS transition timing and sequencing - **`SvResponderDomView`** — Deferred focus management These timers do not prevent their views from being garbage collected if the view is removed from the hierarchy. --- Source: /docs/Getting%20Started/ # Getting Started Setup, integration, directory conventions, build pipeline, and running your first Strvct application. ## Overview Strvct is designed to be integrated directly into your application codebase as a **Git submodule**. It runs as a client-side single-page application in the browser and requires no compile-step template transforms, virtual DOM bundlers, or complex build toolchains. ### Quick Workflow Overview: 1. **Add Submodule:** Link Strvct as a git submodule in your repository. 2. **Declare Imports:** List application source files in `_imports.json`. 3. **Run Build:** Generate CAM catalog artifacts (`_index.json` and `_cam.json.zip`). 4. **Start Server:** Launch `CliWebServer.js` locally. 5. **Create Nodes:** Author annotated domain models inheriting from `SvStorableNode`. 6. **Debug:** Inspect live state and set breakpoints in Chrome DevTools or Cursor/VSCode. --- ## Prerequisites Before starting, ensure you have the following installed: - **Git** (with submodule support) - **Node.js** (v18+ recommended) - **Cursor / VSCode** (for Chrome DevTools debugging support) --- ## Adding Strvct to Your Project From your project's root directory, add Strvct as a Git submodule: ```bash git submodule add https://github.com/stevedekorte/strvct.net.git strvct ``` If deploying your application to GitHub Pages or static hosts that run Jekyll by default, create a `.nojekyll` file in your root folder: ```bash touch .nojekyll ``` --- ## Directory Structure & Conventions A standard Strvct application uses the following directory layout: ``` your-project/ ├── strvct/ # Framework submodule ├── app/ # Application domain models & source code │ ├── _imports.json # Declares app source files │ └── Character.js # Your domain classes ├── resources/ # Binary assets (icons, images, sounds) ├── build/ # Generated CAM artifacts (git-ignored) │ ├── _index.json # Resource metadata catalog with SHA-256 hashes │ └── _cam.json.zip # Zip bundle of hashed assets ├── _imports.json # Root imports file (links strvct + app) ├── index.html # HTML entry point └── .nojekyll # Prevents GitHub Pages Jekyll processing ``` --- ## Declaring Imports (`_imports.json`) Strvct uses `_imports.json` files to discover source files and manage dependency order instead of standard ES module imports. Every folder containing JavaScript or CSS resources specifies an `_imports.json` array: ```json [ "_css.css", "strvct/_imports.json", "app/_imports.json" ] ``` ### Import Rules: - Paths are relative to the directory containing the `_imports.json` file. - Direct file paths (e.g., `"Character.js"`, `"_css.css"`) are included in order. - Nested `_imports.json` paths (e.g., `"app/_imports.json"`) are resolved recursively. --- ## The Build Pipeline (Content-Addressable Memory) Strvct uses a **Content-Addressable Memory (CAM)** build system. The build process scans the root `_imports.json` tree and generates runtime resource bundles in the `build/` directory. _imports.json Tree Root & nested source imports ImportsIndexer Scans paths & SHA-256 hashes build/ Catalog _index.json & _cam.json.zip Browser Runtime SvResourceManager & HashCache ### Running the Build Command: To run the source code indexer manually: ```bash node ./strvct/source/boot/index-builder/ImportsIndexer.js ``` To index non-code media resources (icons, audio): ```bash node ./strvct/source/boot/index-builder/SvResourceIndexer.js ./resources/icons ./resources/sounds ``` If your project includes a `justfile`, you can run: ```bash just build ``` --- ## Running Locally Strvct includes a lightweight local HTTP/HTTPS web server (`CliWebServer.js`). Start the development server: ```bash node ./strvct/webserver/CliWebServer.js --port 8000 --secure false ``` ### Command Flags: - `--port `: Sets the local server port (default: `8000`). - `--secure `: Enables HTTPS with self-signed certificates or HTTP mode. - `--config `: Optional server configuration file path. Open `http://localhost:8000` in your browser to load the application. --- ## Chrome DevTools & Debugging Because Strvct evaluates source files dynamically via the CAM loader, it appends `sourceURL` annotations to evaluated scripts. This enables full native browser debugging in Chrome DevTools or Cursor/VSCode: - **Breakpoints:** Set breakpoints directly in your source JavaScript files in Chrome DevTools Sources tab. - **Call Stacks:** Complete stack traces map directly back to original file paths and line numbers. ### Cursor / VSCode `launch.json` Configuration: ```json { "version": "0.2.0", "configurations": [ { "type": "chrome", "request": "launch", "name": "Debug Strvct App", "url": "http://localhost:8000", "webRoot": "${workspaceFolder}" } ] } ``` --- ## Creating Your First Annotated Node Create your first domain model class inheriting from `SvStorableNode`: ```javascript // app/Task.js (class Task extends SvStorableNode { initPrototypeSlots () { { const slot = this.newSlot("title", "New Task"); slot.setSlotType("String"); slot.setShouldStoreSlot(true); // Persists to IndexedDB slot.setSyncsToView(true); // Live UI updates slot.setCanEditInspection(true); // Editable in Property Inspector } { const slot = this.newSlot("isCompleted", false); slot.setSlotType("Boolean"); slot.setShouldStoreSlot(true); slot.setSyncsToView(true); slot.setCanEditInspection(true); } } initPrototype () { this.setTitle("Task"); this.setShouldStore(true); } }.initThisClass()); ``` Add `"app/Task.js"` to your `app/_imports.json`, run `just build`, and reload your browser. Strvct will automatically generate editable form tiles, handle local persistence, and make your task node navigable in the Miller column browser! --- ## Related Guides - [Technical Overview](../Technical%20Overview/index.html): High-level architecture and design philosophy. - [Nodes](../Nodes/index.html): Deep dive into `SvNode` inheritance and subnode management. - [Slots](../Slots/index.html): Complete guide to property declaration and metadata annotations. --- Source: /docs/Implementation%20Overview/ # Implementation Overview Deep technical specifications for class lifecycle, slots, views, persistence, notifications, and build infrastructure. ## Introduction This document provides a detailed engineering specification of the Strvct framework implementation. It builds directly on the high-level concepts described in the [Technical Overview](../Technical%20Overview/) and the architectural foundations in [Naked Objects](../Naked%20Objects/). Strvct applications are composed of three primary layers: **Model**, **UI**, and **Storage**. The framework eliminates manual "glue" code by embedding structural metadata directly into model objects via **Slots** and **Slot Annotations**. SvApp Top-level coordinator; holds model + userInterface SvWebUserInterface · SvCliUserInterface · SvHeadlessUserInterface UI Layer SvUserInterface Root SvNodeView Tree Lazy Miller views; Observes node slots; Responds to user events; No DOM leaks to model Model Layer SvModel : SvStorableNode Domain SvNode Graph Root of persistent state; Slots define properties; Subnodes define children; Runs headlessly in Node.js Storage Layer SvPersistentObjectPool IndexedDB & Cloud Monitors mutations; Batches dirty nodes; SHA-256 blob store; Garbage collects pools mutation notification getter, setter, & action calls mutation notification loads & stores Model is the authoritative source of truth. Views and Storage hold weak references to Model nodes; Model holds zero references to Views or Storage in return. Slot annotations carry enough information for UI generation, persistence, and synchronization to be handled automatically. --- ## The Object & Class System Strvct implements a structured class initialization pattern built on top of standard ES6 class syntax. ### Class Lifecycle & Registration Classes are defined inside an IIFE (Immediately Invoked Function Expression) and self-register using `.initThisClass()`: ```javascript (class Character extends SvStorableNode { initPrototypeSlots () { // Declare instance slots (properties + metadata) } initPrototype () { // Configure class-wide prototype settings } init () { super.init(); // Basic instance initialization } finalInit () { super.finalInit(); // Relationship resolution & post-deserialization setup } }.initThisClass()); ``` #### Initialization Execution Sequence: 1. **`initPrototypeSlots()`**: Invoked automatically during class registration. Defines slots and annotations on the class prototype. *Must never call `super`.* 2. **`initPrototype()`**: Sets up prototype-wide default properties (e.g., `this.setShouldStore(true)`). *Must never call `super`.* 3. **`init()`**: Called when an object is instantiated (`new Class()`). Performs basic property initialization. Always calls `super.init()`. 4. **`finalInit()`**: Called after an object is fully instantiated or deserialized from IndexedDB. Sets up complex object references and child subnodes. Always calls `super.finalInit()`. ### Slots & Slot Annotations Slots are Strvct's property system. Instead of raw instance fields, properties are declared in `initPrototypeSlots()`: ```javascript initPrototypeSlots () { { const slot = this.newSlot("name", "Default Name"); slot.setSlotType("String"); slot.setShouldStoreSlot(true); // Persists to IndexedDB slot.setSyncsToView(true); // Emits view update notifications slot.setCanEditInspection(true); // Editable in Property Inspector } { const slot = this.newSlot("inventory", null); slot.setFinalInitProto(InventoryNode); // Auto-creates default instance slot.setIsSubnodeField(true); // Navigable tile in inspector } } ``` #### Key Slot Annotations: - `setSlotType(typeName)`: Declares expected type (`String`, `Number`, `Boolean`, `Array`, `Object`, `ClassName`). Enforces runtime type checks on setters. - `setShouldStoreSlot(boolean)`: Controls whether the slot value is included in serialized JSON records. - `setSyncsToView(boolean)`: Triggers change notifications to observing views upon mutation. - `setCanEditInspection(boolean)`: Exposes property in the modifier-click (Option+Click) live Property Inspector. - `setIsSubnode(boolean)`: Adds slot value directly to the parent's `subnodes` array. - `setIsSubnodeField(boolean)`: Generates a navigable field tile in the inspector hierarchy. - `setFinalInitProto(Class)`: Auto-instantiates default child objects during `finalInit()` if no record was loaded from storage. ### Categories & Protocols - **Categories (`initThisCategory()`):** Extend existing classes across multiple files without modifying the base definition file (e.g., `SvJsonGroup_patches.js` adding `applyJsonPatches()` to `SvJsonGroup`). - **Protocols (`NameProtocol`):** Define required interface method stubs inheriting from `Protocol` to enable runtime interface compliance checks. --- ## Model Layer Engineering ### Node Hierarchy The domain model is an object graph inheriting from `SvNode`. Every node contains: - `subnodes`: An ordered, unique collection of child `SvNode` objects. - `parentNode`: Reference to the parent `SvNode`. - `title` / `subtitle`: String properties displayed in summary tiles. - `puuid`: Persistent unique identifier string. ### Subnode Patterns 1. **Stored Subnodes (`setIsSubnode(true)`):** Permanent parent-child ownership relationships where child nodes are stored directly inside the parent's `subnodes` array and persisted together. 2. **Subnode Fields (`setIsSubnodeField(true)`):** Properties where value state remains in a slot on the parent node, but a navigable field tile (`SvField`) is generated in the UI for inspecting child subnodes. --- ## View Layer Architecture ### Layered Class Hierarchy The view system uses a deep, single-inheritance hierarchy where each layer adds a isolated capability: ``` SvElementDomView (Wraps DOM element, enables alternative render backends) └─ SvCssDomView (Manages inline CSS styles and class list) └─ SvSubviewsDomView (Manages child view hierarchy) └─ SvListenerDomView (Event listener attachment) └─ SvVisibleDomView (Viewport visibility tracking) └─ SvGesturableDomView (Gesture recognizers: tap, pan, swipe, long-press) └─ SvResponderDomView (Focus management & keyboard navigation) └─ SvControlDomView (Target/Action pattern for control triggers) └─ SvStyledDomView (State-based style states: selected, active, disabled) └─ SvNodeView (Binds model SvNode to DOM presentation) ``` ### Navigation Primitives (Miller Columns) The UI is rendered using nested Miller Column container views: 1. **`SvStackView`**: Core navigation container. Contains a `SvNavView` (master column) and `otherView` (detail area). Automatically collapses on mobile viewports into a push/pop stack with breadcrumbs. 2. **`SvBrowserView`**: Top-level application shell extending `SvStackView` with header breadcrumb navigation. 3. **`SvNavView`**: Single navigation column containing header, scrollable `SvTilesView`, and footer. 4. **`SvTilesView`**: Scrollable container for `SvTile` items. Handles keyboard cursor selection, drag-and-drop, and reordering gestures. 5. **`SvTile`**: Visual presentation of a single model node or property slot. SvBrowserView Breadcrumb Header: Workspace > Projects > Task SvNavView (Master Column) SvTilesView • SummaryTile: Project Alpha • SummaryTile: Project Beta [*] • SummaryTile: Project Gamma SvStackView (Detail Area) SvNavView (Detail Column) • PropertyTile: Name ("Project Beta") • PropertyTile: Status ("Active") • PropertyTile: Priority ("High") --- ## Storage Layer Engineering ### Persistent Object Pools (`SvPersistentObjectPool`) Application data is stored locally in IndexedDB as object pools (one pool per document): - **Row Key Format:** `poolId` + `puuid` (Persistent UUID). - **In-Pool References:** `{ "*": puuid }` (near references within the same document pool). - **Cross-Pool References:** `{ "**": poolId }` (far references to external document roots, loaded asynchronously). ### Transactional Persistence Lifecycle 1. **Mutation Tracking:** Modifying a slot marked `setShouldStoreSlot(true)` invokes `didMutate()`, marking the node dirty. 2. **Event Loop Commit:** At the end of the current browser event loop, all dirty nodes are bundled into a single atomic IndexedDB transaction. 3. **Deserialization Pipeline:** On load, `instanceFromRecordInStore()` instantiates a blank object, invokes `init()`, populates slot state via `loadFromRecord()`, and executes `finalInit()` to reconnect object references. 4. **Garbage Collection:** Traces the stored graph from the pool root. Unreachable records are automatically deleted. 5. **SHA-256 Blob Pool (`SvBlobPool`):** Large binary assets (images, audio, files) are stored in a content-addressable store keyed by SHA-256 hash. Records store hash references rather than binary payloads. --- ## Synchronization Infrastructure Strvct provides loose coupling across layers using three notification utilities: 1. **`SvNotificationCenter`**: Asynchronous notification dispatch. Nodes post named notifications; observing views register to handle them. 2. **`SvSyncScheduler`**: Coalesces multiple notification method invocations in one event loop into a single UI sync pass. 3. **`SvBroadcaster`**: Immediate, synchronous event broadcast for high-frequency internal events. Model Node Slot Setter character.setName("Thorin") Slot setter updates value SvNotificationCenter postNotification("didChange") Dispatches to observers SvSyncScheduler & View scheduleTargetAndMethod() Coalesced view.syncFromNode() --- ## Content-Addressable Build System (CAM) Strvct avoids standard ES module imports and Webpack/Vite bundlers, using a custom **Content-Addressable Memory (CAM)** build system: 1. **`ImportsIndexer` (Build Time):** Recursively walks `_imports.json` files to discover source files and dependency order. Outputs: - `_index.json`: Metadata catalog mapping resource paths to SHA-256 content hashes. - `_cam.json.zip`: Zip-compressed content bundle keyed by SHA-256 hash. 2. **`SvResourceManager` & `SvHashCache` (Runtime):** - Fetches `_index.json` on app boot. - Scans missing hashes against IndexedDB `SvHashCache`. - If missing ratio $> 30\%$, downloads `_cam.json.zip` in one HTTP request. - If missing ratio $\le 30\%$, fetches individual missing files on demand. - Evaluates source files in dependency order via `eval()` with embedded `sourceURL` comments for complete DevTools debugging support. --- ## Related Guides - [Technical Overview](../Technical%20Overview/index.html): High-level architecture and design philosophy. - [Naked Objects](../Naked%20Objects/index.html): Theoretical foundations and production case studies. - [Comparing to React](../Comparing%20to%20React/index.html): Guide for React developers exploring Strvct. --- Source: /docs/Inspectors%20and%20Debugging/ # Inspectors and Debugging Built-in tools for live Property Inspection, Developer Mode graph toggles, and Chrome DevTools source debugging. ## Overview Because STRVCT generates user interfaces from annotated model nodes, the framework can automatically derive an **alternate Property Inspector view** for any domain object. - **Option-Click (Alt-Click):** Option-clicking any tile opens its **Property Inspector** in the next column—a dynamically generated field tile stack displaying declared property slots, values, types, and editability flags. - **Option-Shift-D (Alt-Shift-D):** Toggles **Developer Mode** globally (`SvApp.shared().developerMode()`), revealing hidden diagnostic subnodes, raw state inspectors, and AI message logs. User Gesture Trigger Option-Click Tile justAlternateTap() on tile Option-Shift-D Toggles developerMode() Chrome DevTools sourceURL breakpoint debugging SvInspectableNode Engine setupInspectorFromSlots() Walks allSlotsMap() on prototype nodeInspector() Generates field stack on demand onAppDeveloperModeNote Posts global toggle notification Live Runtime Presentation Field Tile Column Opens editable slot controls Hidden Subnodes Revealed Toggles setIsVisible() on subnodes Write-Through Sync Edits update live object pool --- ## Option-Click: Property Inspector Holding **Option** while clicking any tile opens an inspector view in the next column instead of navigating to the node's standard subnodes. ### Mechanism & Implementation (`SvInspectableNode`): 1. **Gesture Interception:** The tile gesture handler (`SvTile.justAlternateTap()`) catches the Option-Click gesture and sets `isInspecting = true` on the tile. 2. **Inspector Generation:** `SvInspectableNode.nodeInspector()` clones an inspector node and populates it via `setupInspectorFromSlots()`. 3. **Slot Map Inspection:** `setupInspectorFromSlots()` walks `allSlotsMap()` down the node's class inheritance chain, instantiating an `SvFieldTile` for every slot where `slot.canInspect()` returns `true`. 4. **Live Write-Through:** Edits made inside the inspector write directly through to the live object node, automatically triggering IndexedDB persistence and view change notifications. ### Inspector Slot Annotations: - `slot.setCanEditInspection(true)`: Controls whether the slot value is editable in place inside the inspector. - `slot.setInspectorPath("Section/Subsection")`: Groups slots into collapsible inspector section headers. --- ## Option-Shift-D: Developer Mode Pressing **Option+Shift+D** anywhere in `SvBrowserView` toggles `SvApp.shared().developerMode()`. The app posts an `onAppDeveloperModeChangedNote` notification when toggled. ### Opt-In Subnode Visibility Code Pattern: Domain nodes register to observe the notification and show or hide diagnostic subnodes: ```javascript (class Character extends SvStorableNode { init () { super.init(); this.watchForNote("onAppDeveloperModeChangedNote"); } onAppDeveloperModeChangedNote (/*aNote*/) { const devMode = this.app().developerMode(); this.diagnosticsNode().setIsVisible(devMode); this.rawStateNode().setIsVisible(devMode); this.aiMessageHistory().setIsVisible(devMode); } }.initThisClass()); ``` --- ## Related Guides - [Nodes](../Nodes/index.html): Core `SvNode` domain abstraction. - [Slots](../Slots/index.html): Complete guide to slot metadata and declarations. - [Getting Started](../Getting%20Started/index.html): DevTools configuration and debugging launch configs. --- Source: /docs/Inspirations/ # Inspirations Frameworks and ideas that shaped STRVCT's design. ## Miller Columns The default navigation pattern — a horizontal stack of nested tile lists — draws from Miller columns, created by Mark S. Miller in 1980 and closely related to the class hierarchy browser in Smalltalk-76. The pattern appeared in the Macintosh Finder, the NeXTSTEP File Viewer, and later macOS's column view. The NeXTSTEP implementation was the primary inspiration — its combination of columnar navigation with an object-oriented framework made the pattern feel natural for browsing object hierarchies, not just file systems. This provides spatial context as users navigate deeper into a node hierarchy, with each level visible alongside its parent. STRVCT extends the classic Miller column pattern by allowing each level in the stack to independently choose its layout direction — vertical or horizontal — controlled by the node via `setNodeIsVertical()`. This recursive variant means a horizontal stack can contain a column whose subnodes lay out vertically, which in turn contains a row whose subnodes lay out horizontally, and so on. The alternating directions let the same navigation model serve both hierarchical browsing (vertical lists) and detail views (horizontal field layouts) without switching interaction paradigms. ## Smalltalk, Self, and Objective-C STRVCT's object model draws from the Smalltalk tradition. Naming follows Smalltalk conventions — camelCase with `_ivar` / `ivar()` / `setIvar()` accessors. Objects are created via `clone()` rather than constructors, reflecting Self's prototype-based model. The category system, which extends classes without modifying their source files, comes directly from Objective-C (and before that, Smalltalk). The slot system for declaring instance variables echoes Smalltalk's explicit ivar declarations, and the notification center pattern traces back to Smalltalk's change/update mechanism. ## Cocoa and UIKit The application framework layer is heavily influenced by Apple's Cocoa and UIKit: - **Notification center** — `SvNotificationCenter` with observations mirrors `NSNotificationCenter` closely, providing publish/subscribe communication between loosely coupled components. - **Responder chain** — `SvResponderDomView` implements `becomeFirstResponder()`, `releaseFirstResponder()`, `acceptsFirstResponder`, and `nextKeyView`, mapping directly to Cocoa's `NSResponder` / UIKit's `UIResponder` model for keyboard focus and event routing. - **Gesture recognizers** — `SvTapGestureRecognizer`, `SvPanGestureRecognizer`, `SvPinchGestureRecognizer`, and `SvLongPressGestureRecognizer` follow the UIKit `UIGestureRecognizer` pattern, including centralized arbitration of competing gestures via `SvGestureManager`. - **Delegate pattern** — Used throughout for communication between views, listeners, and gesture recognizers, following Cocoa's preference for delegation over subclassing. --- Source: /docs/Internationalization/ # Internationalization AI-powered translation of UI text with per-language IndexedDB persistence, batched requests, and content filtering. ## Overview STRVCT includes a built-in internationalization (i18n) system that translates UI strings on the fly using AI language models. Rather than maintaining static, hand-edited translation files for each language, the framework sends batched translation requests to an AI service and caches the results persistently in per-language IndexedDB databases. This approach is uniquely enabled by the naked objects pattern. Because the framework generates the UI from model slot annotations, there is a single point—the **model-to-view boundary**—where all display text passes through. Translation is injected at that boundary, making every model class translatable by default with no per-component wiring. In a bespoke-view framework, every component would need explicit `t()` calls and separate translation key files. The system is designed around three core principles: - **Non-blocking:** Translations happen asynchronously. The UI displays English text immediately and swaps in the translated version when it arrives, with no visible delay on subsequent visits thanks to persistent caching. - **Smart filtering:** Numbers, currency amounts, codes, URLs, emails, and other non-linguistic content are detected and skipped automatically, avoiding unnecessary API calls. - **Batched and deduplicated:** Individual translation requests are debounced, grouped by context, and sent as a single batch to minimize API usage. Model Display Text title, subtitle, slot labels Model-to-View Boundary Single point where all UI text passes through; translation hook applies automatically SvTranslationFilter & Tier 0 Map Filters non-linguistic content (URLs, numbers); checks per-node translationMap (sync O(1)) SvI18nCache (Per-Language IndexedDB) In-memory Map loaded at boot on language select; returns immediately on cache hit SvI18nService AI Translation Groups requests by context, debounces 200ms, sends single batch call; stores result UI shows source English text immediately, then swaps in translated string when promise resolves. --- ## Core Architecture & Classes The i18n system consists of five core classes in `source/library/i18n/`: | Class | Role | |---|---| | `SvI18n` | Singleton coordinator. Manages dedicated per-language IndexedDBs, language state, deduplicates pending promises, and exposes computed status getters (`queuedCount`, `completedCount`) for admin UI. | | `SvI18nCache` | Eager in-memory cache. Owns `i18nTranslations/cache/{lang}` IndexedDB. Loads all language entries into a `Map` on language selection. Handles seed entries (permanent) and runtime additions with FIFO eviction. | | `SvI18nStore` | Async IndexedDB bridge (`i18nTranslations/store/{lang}`). Purely an async read/write interface to IndexedDB with no in-memory state; promotes hits to `SvI18nCache`. | | `SvI18nService` | Batched request service. Accumulates requests for 200ms, groups by context, sends JSON templates to AI chat models, and stores results. | | `SvTranslationFilter` | Pluggable filter with named regex functions in a Map. Determines whether a string contains translatable linguistic content. | | `SvTranslatableNode` | Base class for translatable domain nodes (`SvNode` hierarchy). Holds per-node Tier 0 `translationMap`. | --- ## The 4-Tier Lookup Pipeline When a view calls `node.translatedValueOfSlotNamed("slotName")`: 1. **Request & Filter Verification:** `SvTranslatableNode` checks whether translation is needed: - System is enabled and language is not English (`SvI18n.shared().currentLanguage() !== "en"`). - Text is 20 words or fewer for slot values. - `SvTranslationFilter.shared().shouldTranslate(text)` confirms text contains linguistic content (not numbers, URLs, codes, or emails). 2. **Tier 0: Node Map (Sync $O(1)$):** Checks `node.translationMap` (per-node FIFO `Map` capped at 10 items). Auto-clears lazily if language has changed since last access. On hit, returns immediately with no UI flicker. 3. **Tier 1: SvI18nCache Map (Sync $O(1)$):** Checks `SvI18n.cachedTranslate(text, context)`. On hit, promotes result to Tier 0 map and returns. 4. **Tier 2: SvI18nStore IndexedDB (Async):** Calls `SvI18n.asyncTranslate(text, context)`. On hit in `i18nTranslations/store/{lang}`, promotes result to Tier 1 cache and Tier 0 map, then resolves promise. 5. **Tier 3: AI Batch Translation:** On complete miss, enqueues text in `SvI18nService`: - Returns English source text as immediate fallback. - Deduplicates: if key is pending, caller promise chains onto existing request. - Accumulates requests for 200ms (configurable `debounceMs`), groups by context, and sends 1 AI batch JSON request. - Stores response in Tier 1 cache and Tier 2 store, resolves pending promises, and calls `didUpdateNode()` to swap UI text cleanly without flicker. --- ## Smart Non-Linguistic Filtering (`SvTranslationFilter`) `SvTranslationFilter` uses a pluggable Map of named filter functions to skip unnecessary API calls: | Filter Name | Pattern Examples Skipped | |---|---| | `noAlphabetical` | `17 (+3)`, `+5 / +3 / +2`, `---` | | `numericAndCurrency` | `42`, `$9.99`, `€100`, `$70.16 USD`, `100%` | | `alphanumericCodes` | `23A`, `#7`, `3d6`, `+5`, `10/20` | | `ordinals` | `1st`, `2nd`, `3rd` | | `labeledNumeric` | `HP: 45`, `AC: 18`, `XP: 1,200` | | `emailAddresses` | `user@example.com` | | `phoneNumbers` | `+1 (555) 123-4567` | | `urlsAndIps` | `https://example.com`, `192.168.1.1` | Custom domain filters can be registered dynamically: ```javascript SvTranslationFilter.shared().addFilter("diceNotation", s => /^\d*d\d+(\s*[+-]\s*\d+)?$/i.test(s)); ``` --- ## Seed Generation & Cloud Storage Workflow Seed files provide instant, cold-start translations. They group entries by context: ```json { "meta": { "language": "es", "entryCount": 150 }, "entries": { "ui-label": { "Hit Points": "Puntos de Golpe" }, "game-mechanic": { "Saving Throw": "Tirada de Salvacion" } } } ``` ### 3-Phase Seed Generation Pipeline (Admin UI): 1. **Phase 1 — Introspection (Init Seed):** - Clears cache for current language. - Walks all `SvNode` subclass prototypes via introspection. - Collects labels, placeholders, valid values, and default strings for slots with `shouldTranslate() === true`. - Filters collected strings through `SvTranslationFilter` and enqueues them for AI batch translation. 2. **Phase 2 — Runtime Accumulation:** - Developers browse the UI to trigger translations for dynamic strings not discoverable via static introspection (computed titles, subtitles, dynamic action labels). 3. **Phase 3 — Cloud Upload (Store Current Seed):** - Exports all cache entries for the language, strips timestamps (marking entries as permanent seed entries), and uploads the JSON seed file to Firebase Storage. --- ## Configuration & Tuning Parameters ```javascript // Change active language (ISO 639-1) SvI18n.shared().setCurrentLanguage("es"); // Enable or disable translation system SvI18n.shared().setIsEnabled(true); ``` ### `SvI18nService` Tuning Parameters: - `debounceMs`: Milliseconds to accumulate requests before sending batch (default: `200`). - `maxBatchSize`: Maximum strings per API request (default: `50`). - `maxConcurrent`: Maximum simultaneous API requests (default: `3`). --- ## View Integration Details - **Field Tiles (`SvFieldTile`):** Calls `node.translatedValueOfSlotNamed()` in `visibleKey()`, automatically displaying translated field labels. - **Breadcrumb Navigation (`SvBreadCrumbsTile`):** Observes `"svI18nLanguageChanged"` notification, rebuilding breadcrumb path segments in the new language. - **Custom Views:** Any view can observe `"svI18nLanguageChanged"` to trigger a UI refresh when the active language changes. --- ## Related Guides - [Nodes](../Nodes/index.html): Core `SvNode` domain abstraction. - [Slots](../Slots/index.html): Complete guide to slot metadata annotations. - [AI Services](../Services/AI%20Services/index.html): AI service provider infrastructure. --- Source: /docs/Lifecycle/ # Lifecycle Boot sequence, node initialization, view synchronization, and persistence cycles. The core design challenge is that the same object must work whether it is freshly created or loaded from storage. A single-phase constructor can't handle both cases — if it creates default child objects, it will overwrite data that was just deserialized. STRVCT solves this with a three-phase sequence: `init()` sets up primitives and slot defaults, `finalInit()` creates complex child objects only if they weren't already loaded from the store, and `afterInit()` runs once the full object graph is ready. This separation means persistence is transparent — a class doesn't need different code paths for "new" vs. "loaded." text { font-family: 'Inter', system-ui, -apple-system, sans-serif; font-size: 12px; fill: #111; } .b { font-weight: 600; } .dim { fill: #666; } .box { fill: none; stroke: #111; stroke-width: 1; } .fill { fill: #f0ede5; stroke: #111; stroke-width: 1; } .flow { stroke: #111; stroke-width: 1; fill: none; } ProtoClass.clone() or load from store - 1. init() primitive values, slot defaults; no object relationships yet - 2. finalInit() creates child objects via setFinalInitProto only if not already loaded from store - 3. afterInit() runs once the full object graph is in place - Boot Sequence - App Lifecycle - Node Lifecycle - View Synchronization - Persistence Lifecycle - Headless Execution --- Source: /docs/Lifecycle/App%20Lifecycle/ # App Lifecycle `SvApp` singleton initialization sequence, extension points, runtime environment hooks, user alert routing, and UI readiness promises. ## Overview `SvApp` is the application singleton. It owns the persistent object pool, root model object graph, and top-level user interface (`SvUserInterface`). Subclasses override a small set of hook methods to initialize application models and user interfaces in a clean, predictable order. 1. setupModel() Store open, root object exists 2. setupUi() Model ready; UI instantiated 3. appDidInit() Posts "appDidInit" note 4. afterAppUiDidInit() UI visible; processes URL params Model initialization is fully separated from UI rendering; app runs identically in browser or headless Node.js. --- ## Extension Point Hook Methods | Hook Method | When Executed | Purpose & Usage | |---|---|---| | `setupModel()` | Object pool store is open; root model exists. | Initialize application data models; create or fetch top-level subnodes. | | `setupUi()` | Model object graph is ready. | Customize top-level UI presentation and window settings. | | `appDidInit()` | Everything is wired up and live. | Post-initialization tasks; posts `"appDidInit"` notification. | | `afterAppUiDidInit()` | UI elements are mounted and visible. | Parse URL search parameters via `handleSearchParams(params)`. | | `handleSearchParams(params)` | Called automatically from `afterAppUiDidInit()`. | Process URL query parameters for deep-linking. | ### Top-Level Root Subnode Persistence (`rootSubnodeWithTitleForProto`): To instantiate top-level application root nodes safely across reloads: ```javascript setupModel () { super.setupModel(); // Creates on first run; reuses from storage on subsequent loads this._tasksNode = this.rootSubnodeWithTitleForProto("Tasks", TaskManagerNode); } ``` --- ## Waiting for Initialization & UI Readiness ### 1. App Initialization Promise (`didInitPromise`) Code that needs to wait for complete application setup awaits `didInitPromise()`: ```javascript await SvApp.shared().didInitPromise(); // App is now fully initialized and live ``` ### 2. UI Readiness Promise (`promiseUserInterfaceReady`) UI-dependent code (e.g. sending navigation selection requests) awaits `promiseUserInterfaceReady()`: ```javascript const ui = await SvApp.shared().promiseUserInterfaceReady(); if (ui.providesNavigation()) { // Safe to send navigation requests this.postNoteNamed("onRequestSelectNodePath", { path: ["Workspace", "Tasks"] }); } ``` --- ## Runtime Environment Event Hooks `SvApp` captures environment lifecycle signals and translates them into environment-agnostic hooks on `SvModel`: | Model Hook Method (`SvModel`) | Browser Signal Event | Headless Signal Event | Purpose & Action | |---|---|---|---| | `onAppDidGoOnline()` | `online` event | — | Network connectivity restored | | `onAppDidGoOffline()` | `offline` event | — | Network connectivity lost | | `onAppWillSuspend()` | `visibilitychange` (hidden) | — | App backgrounded; flush volatile state | | `onAppWillTerminate()` | `beforeunload` (sync) | `SIGTERM` / `SIGINT` | Shutdown/unload cleanup. Return `true` to block unload. | --- ## Model User Alerts (`onRequestUserAlert`) Domain models request user notifications without referencing UI or DOM classes: ```javascript this.postNoteNamed("onRequestUserAlert", { name: "syncFailure", title: "Sync Error", message: "Failed to sync changes with cloud store.", level: "error" // "info" | "warning" | "error" }); ``` `SvUserInterface` observes `onRequestUserAlert`. In the browser (`SvWebUserInterface`), it opens an `SvPanelView` overlay; in headless Node.js, it logs the alert to console. --- ## Related Guides - [Headless Execution](../Headless%20Execution/index.html): Running applications under Node.js. - [Boot Sequence](../Boot%20Sequence/index.html): CAM resource loading and script evaluation. --- Source: /docs/Lifecycle/Boot%20Sequence/ # Boot Sequence How the application loads from first script tag to a running app. ## Overview The boot process has three phases: load the boot loader, load all resources via the content-addressable memory system, then create and run the app. Each phase completes fully before the next begins, so by the time application code runs, every class and resource is available. 1. Initial Bootstrap Browser loads boot loader single script tag entry point Core boot files Object, Promise, IndexedDB, HashCache, ResourceManager 2. Resource Loading ResourceManager.shared().setupAndRun() Load _index.json: resource metadata + content hashes Check HashCache: skip downloads for unchanged content Download _cam.json.zip (compressed bundle) on cache miss Evaluate CSS sequentially, then JS in dependency order; filter env-inappropriate files 3. App Creation SvApp.loadAndRunShared() Open persistent store; load root object from store Pause schedulers; setupModel(); setupUi() appDidInit fires: post notification, unhide root view, handle URL params Resume schedulers Each phase completes before the next; application code runs only after every class and resource is available. ## 1. Initial Bootstrap The browser loads the boot loader script. Core boot files are loaded in parallel and evaluated sequentially. These include: Object extensions, Promise extensions, IndexedDB support, HashCache, and ResourceManager. ## 2. Resource Loading `ResourceManager.shared().setupAndRun()` drives this phase: 1. Loads `_index.json` containing resource metadata and content hashes. 2. Checks `HashCache` for cached resources — unchanged content is never re-downloaded. 3. Downloads `_cam.json.zip` (compressed content bundle) on cache miss. 4. Evaluates CSS resources sequentially (cascade order matters). 5. Filters out environment-inappropriate resources (e.g., `browser-only/` files in Node.js) via `StrvctFile.canUseInCurrentEnv()`. 6. Evaluates JavaScript resources in dependency order. After this phase, all classes are defined and available globally. See [Headless Execution](../Headless%20Execution/) for details on how the boot sequence adapts to Node.js. ## 3. App Creation `SvApp.loadAndRunShared()` creates the app singleton and opens the persistent store: ``` SvApp.loadAndRunShared() ├── setStore(defaultStore()) ├── loadFromStore() │ ├── store.promiseOpen() │ └── store.rootOrIfAbsentFromClosure() └── run() └── setup() ├── pauseSchedulers() ├── setupModel() ├── setupUi() ├── appDidInit() │ ├── setHasDoneAppInit(true) │ ├── postNoteNamed("appDidInit") │ ├── unhideRootView() │ └── afterAppUiDidInit() │ ├── handleSearchParams() │ └── didInitPromise.resolve() └── resumeSchedulers() ``` Schedulers are paused during setup so that model and UI initialization don't trigger premature sync cycles. They resume once everything is wired up. --- Source: /docs/Lifecycle/Headless%20Execution/ # Headless Execution Running STRVCT applications natively in Node.js without DOM or browser dependencies. ## Overview STRVCT's domain model layer, persistence engine, and boot sequence execute natively in Node.js. The same application domain classes that run in the browser run headlessly under Node.js—with identical storage behavior, slot metadata annotations, and object lifecycles—just without DOM or view classes. This enables ultra-fast unit/integration testing, server-side processing, batch simulations, and CLI tools. Shared Domain Model SvStorableNode subclasses Environment Filtering server-only / browser-only LevelDB Storage Backend classic-level via SvIndexedDbFolder Model code holds zero DOM references; views observe the model, but the model is completely unaware of views. --- ## Environment Detection (`SvPlatform`) ```javascript // Environment checks if (SvPlatform.isNodePlatform()) { // Node.js specific code } else if (SvPlatform.isBrowserPlatform()) { // Browser specific code } ``` --- ## Directory Filtering Conventions (`browser-only` & `server-only`) During boot resource discovery, `StrvctFile.canUseInCurrentEnv()` inspects path segments: - In **Node.js**: Files in `browser-only/` paths are skipped. - In **Browser**: Files in `server-only/` paths are skipped. ### The Same-Name Class Pattern: This convention provides environment-specific implementations of the exact same class interface: ``` source/boot/browser-only/SvIndexedDbFolder.js # Uses native IndexedDB source/boot/server-only/SvIndexedDbFolder.js # Uses LevelDB via classic-level ``` --- ## Browser API Shims for Node.js (`server-only`) In `source/library/ideal/categories/server-only/`: | Shim File | Browser API Polyfilled | Node.js Implementation | |---|---|---| | `XMLHttpRequestShim.js` | `XMLHttpRequest` | Wraps `xhr2` package | | `FileReaderShim.js` | `FileReader` | Reads ArrayBuffer and text from Blobs | | `ImageShim.js` | `Image`, `HTMLCanvasElement` | Wraps `canvas` package | | `FontFaceShim.js` | `FontFace` | Stub accepting font declarations | --- ## Storage Engine Parity Storage works identically in both environments through `SvIndexedDbFolder`: - **Browser:** Writes to native IndexedDB. - **Node.js:** Writes to LevelDB (`classic-level`) in `./data/leveldb/`. --- ## Related Guides - [App Lifecycle](../App%20Lifecycle/index.html): `SvApp` startup and readiness promises. - [Local Object Pools](../../Persistence/Local%20Object%20Pools/index.html): Persistent object pools. --- Source: /docs/Lifecycle/Node%20Lifecycle/ # Node Lifecycle Creation, three-phase initialization, parent-child relationships, and update notifications. ## Class Hierarchy ``` Object → ProtoClass → SvNode → SvViewableNode → SvStyledNode → SvStorableNode ``` ## Three-Phase Initialization Every node goes through the same sequence, whether freshly created or loaded from storage: ### 1. `init()` — Primitives and slots - Calls `super.init()` - Initializes slots via `initializeSlots()` - Sets up notification observers - Configures mutation watching Only set primitive values and simple defaults here. Don't create child objects — they may be about to arrive from the store. ### 2. `finalInit()` — Complex objects and relationships - Calls `super.finalInit()` - Creates objects for slots with `setFinalInitProto()` — but only if the slot wasn't already populated from storage - Establishes object relationships This is where you detect whether the object is new or loaded: ```javascript finalInit () { super.finalInit(); if (!this.hasStoredData()) { this.randomizeValues(); } } ``` ### 3. `afterInit()` → `didInit()` — Post-initialization - Sets `_hasDoneInit = true` - Triggers initial notifications - Can be scheduled for end of event loop By this point the full object graph is ready and it's safe to interact with other objects. ## Creating Instances Always use `ProtoClass.clone()` rather than `new`. `clone()` runs the full three-phase sequence automatically. ## Parent-Child Relationships **Adding subnodes:** - `addSubnode(node)` — Add to end - `addSubnodeAt(node, index)` — Add at specific position - Automatically sets `parentNode` - Triggers `didChangeSubnodeList()` **Removing subnodes:** - `removeSubnode(node)` — Remove specific node - Clears `parentNode` reference - Triggers `didChangeSubnodeList()` ## Update Notifications When a slot value changes, the framework fires a notification chain: ``` setSlotValue(newValue) └── didUpdateSlot(slot, oldValue, newValue) ├── didUpdateSlot[SlotName](oldValue, newValue) └── didMutate() [for storable nodes] ``` Additional update methods: - `didUpdateNode()` — Manual update trigger - `didUpdateNodeIfInitialized()` — Only fires if `hasDoneInit()` is true, preventing spurious notifications during setup - `didChangeSubnodeList()` — Fired when the subnodes array changes ## Conditional Updates A common pattern is to guard update logic so it only runs after initialization is complete: ```javascript didUpdateSlotFoo (oldValue, newValue) { if (this.hasDoneInit()) { this.didUpdateNode(); } } ``` --- Source: /docs/Lifecycle/Persistence%20Lifecycle/ # Persistence Lifecycle How objects are stored, loaded, and kept in sync with the local record store and the cloud. ## Overview Persistence in STRVCT is automatic. Objects marked as storable are tracked for changes, serialized at the end of each event loop, and written as rows of their pool in the local record store (IndexedDB). A pool that is a cloud document later commits the rows that changed to the cloud. On reload, they're deserialized and re-initialized through the same three-phase lifecycle as new objects. The goal is transparency — a class shouldn't need different code paths for "new" and "loaded." ## Storing Objects ### Marking Dirty When a storable slot changes, the framework automatically marks the object as dirty: 1. `didMutate()` is called from the slot's `didUpdateSlot()` hook. 2. The object is added to the store's dirty set. 3. At the end of the event loop, all dirty objects are auto-committed. ### Serialization ``` recordForStore(store) ├── Serialize slots marked with setShouldStoreSlot(true) ├── Convert object references to { "*": puuid } (or { "**": poolId } across pools) └── Return JSON-compatible record ``` Only slots explicitly marked with `setShouldStoreSlot(true)` are persisted. Object references are stored as persistent unique IDs (puuids) rather than direct pointers, so the full object graph can be reconstructed on load. ## Loading Objects Loading reverses the process in three steps: ### 1. Instance Creation ``` instanceFromRecordInStore(record, store) ├── Create blank instance ├── Call init() └── Return for population ``` ### 2. Data Population ``` loadFromRecord(record, store) ├── Restore slot values ├── Resolve object references via puuids └── Skip slots with setFinalInitProto() (they'll be handled next) ``` ### 3. Relationship Restoration `finalInit()` re-establishes complex relationships. Slots configured with `setFinalInitProto()` only create default instances if the slot wasn't already populated from the store — this is the key mechanism that makes the three-phase lifecycle work for both new and loaded objects. ## Persistence-Aware Initialization When you need initialization logic that only runs for newly created objects (not loaded ones): ```javascript finalInit () { super.finalInit(); if (!this.hasStoredData()) { this.randomizeValues(); } } ``` ## Store Events - `didLoadFromStore(store)` — Called after all objects have been loaded and initialized. Safe to access the full object graph. - `willStore()` — Called just before serialization. Optional hook for pre-save cleanup. ## Clean Shutdown ```javascript shutdown () { this.stopWatchingNode(); this.subnodes().forEach(node => node.shutdown()); this.removeFromParent(); } ``` --- Source: /docs/Lifecycle/View%20Synchronization/ # View Synchronization How views discover nodes, synchronize state, and batch updates efficiently. ## View Discovery The framework creates views automatically when a node needs to be displayed: 1. The node calls `nodeViewClass()`. 2. The framework searches for `NodeClassNameView` or `NodeClassNameTile`. 3. Falls back up the inheritance chain until a match is found. 4. Creates an instance via `clone()` and associates it via `setNode()`. ``` SvNodeView.newSubviewForSubnode(node) ├── Determine view class ├── Create instance via clone() └── Associate via setNode() ``` ## Model to View When a node property marked with `setSyncsToView(true)` changes: 1. The node's `didUpdateSlot()` fires. 2. An `onUpdatedNode` notification is posted. 3. The observing view schedules `syncFromNode()` via `SvSyncScheduler` at priority 2. 4. At the end of the event loop, the view updates its DOM and subviews. ## View to Model When the user interacts with a view: 1. The view calls an action method on the node. 2. The node updates its internal state. 3. This triggers a model-to-view sync, completing the cycle. View-to-model syncs run at priority 0 (higher than model-to-view), ensuring user edits are applied before any reactive updates. ## The Sync Scheduler `SvSyncScheduler` is central to performance: - **Batching** — Multiple slot changes in the same event loop produce a single sync call, not one per change. - **Coalescing** — Duplicate sync requests for the same view are collapsed. - **Loop detection** — The scheduler detects and breaks infinite sync cycles. - **Pausing** — Schedulers can be paused during bulk operations (e.g. app startup) and resumed afterward. ```javascript // Multiple updates, single sync cycle this.scheduleSyncToView(); this.otherProperty().scheduleSyncToView(); // Both handled in one pass ``` ## View Lifecycle Events - `willAddSubview(subview)` — Before adding a child view - `willRemoveSubview(subview)` — Before removing a child view - `willRemove()` — Before this view is removed from its parent - `onVisibility()` — Element becomes visible (via IntersectionObserver) - `didChangeNode()` — The node reference changed ## Performance - **Lazy creation** — Views are only created when their node becomes visible in the navigation. - **Visibility tracking** — `IntersectionObserver` integration means off-screen views can skip expensive updates. - **Batched updates** — The sync scheduler ensures that rapid state changes don't cause redundant DOM work. --- Source: /docs/Naked%20Objects/ # Naked Objects From Domain Models to Complete Applications ## Abstract This document proposes a conjecture about user interfaces for structured information: that nearly every screen in such an application can be described by three decisions—which part of the object graph is **visible**, whether each visible child is **layered** beside its parent or **inlined** within it, and how sibling collections are **arranged**. We call a screen described this way a **lens** over the model. If the conjecture holds, a framework can own the mechanics of those decisions (navigation, collapse, responsive switching, editing, persistence) while the developer states only the policy, as hints on the model. Strvct is an implementation of this idea in the **Naked Objects** tradition, which derives user interfaces from domain objects and their declared behavior. It adds a compositional interaction grammar—recursive master-detail navigation, inline documents, and responsive anchored tabs—and reuses the same model metadata for persistence, exchange, and agent interfaces. A production application, **undreamedof.ai**, shows the approach is feasible at scale; the argument for its generality rests on the reader's own experience of the interfaces they already know. A [PDF of the earlier revision](compiled/Closing_the_Usability_Gap_in_Naked_Objects.pdf) is also available; it has not yet been updated to match this page.

Production example: undreamedof.ai.

An undreamedof.ai game session built with Strvct: narration, a character's spells, and the scene map side by side
--- ## 1. Introduction A note on what kind of document this is. We do not offer a controlled evaluation or a measured productivity comparison. What follows is a design conjecture, an implementation that makes it concrete, and a deployed application that shows it is feasible. The evidence we ask the reader to weigh is their own: test the three-decision grammar of §3 against the information applications you know—mail clients, settings panels, issue trackers, CRMs—and see whether any screen needs a decision it cannot express. The strongest case against the conjecture would be a common, non-graphical information screen that does; we would like to hear of one. The hedges that remain in later sections mark where implementation lags the conjecture, not uncertainty about the conjecture itself. Applications often repeat domain structure across model declarations, input controls, validation, persistence mappings, navigation, and integration schemas. A new property can require coordinated changes in several places. Shared components and schema-driven tools reduce this duplication, but application authors still commonly maintain a separate presentation structure. **Naked Objects**, described by Pawson and Matthews [1], offers another approach: expose domain objects and actions through generated interfaces. Strvct retains that model-first architecture while exploring a richer set of reusable navigation and layout mechanisms. ``` ┌──► UI (Navigation, Fields, Documents & Tabs) ├──► Storage (Local Pools & Cloud Sync) Annotated Model ─┼──► Exchange (JSON Import, Export & Patches) ├──► Agent Interface (Schema & Patch Operations) └──► Headless Domain Execution ``` The contribution is a compositional account of those UI mechanisms and an implementation that reuses model metadata across subsystems. The division of labor matters: the framework does not infer layouts, as early Naked Objects systems did; it implements the mechanics, and the developer states intent. Domain design, presentation decisions, and testing the resulting experience remain the developer's work—but as policy, not as separately authored screens. --- ## 2. The Usability Problem Addressed Here Generating fields and collections is only part of generating a useful application. Users also need to retain context while traversing relationships, see related information together, and navigate on small screens. This paper focuses on three design requirements: 1. **Visible hierarchy:** Distinguish ownership, containment, and cross-references. 2. **Context-preserving navigation:** Keep the selected path legible as users move between related objects. 3. **Reusable responsive behavior:** Adapt the same navigation structure to different viewport sizes. Forms and tables remain useful arrangements; the question is how they compose with other views. Existing model-driven systems also support customization: Apache Causeway, for example, documents UI extensions for maps and calendars [2]. Strvct's focus here is recursive composition of layered and inline views, rather than a claim that prior systems can render only forms and tables. --- ## 3. The Model as a Graph, the Screen as a Lens This section states the conjecture from the Abstract precisely. Before describing the grammar in detail, it helps to picture what a generated interface is actually showing. Imagine the domain model as a graph: a tree of ownership, with symbolic links for the references that cross it. Now imagine drawing all of it at once—every object, every property, every collection, fully expanded. This drawing is the model's complete **UI projection**. This is a conceptual projection of the UI-exposed model, not a drawing that the runtime must materialize; internal or hidden properties need not be exposed. Every screen the user sees is a **lens** over that drawing. At first order, a lens makes only two decisions: 1. **Visibility:** Which nodes to collapse. Typically everything off the current navigation path is collapsed, leaving the path itself and the immediate children of the nodes along it. 2. **Placement:** For each visible parent→child edge, whether the child is **layered** (given its own plane beside or in front of its parent, as in Miller columns, push stacks, and tabs) or **inlined** (drawn within its parent's extent, as in documents, grouped sections, and side-by-side panes).
One Projection, Three Lenses
[Lens Placement Diagram]
Layering and inlining are not modes of the whole interface but choices made edge by edge, and they compose freely. A layered column may hold an inlined document whose link opens another layer; a document section may itself be a set of anchored tabs. The mixed lens above inlines _Project_'s sections in one column and layers _Task 2_ into the next, and even the pure inlining lens layers its link to _Person_. Because the choice lives on each edge rather than on each screen, it can change without touching the model—set by a developer's hint, or switched by the framework as space changes. At second order, a lens decides **arrangement**: how siblings within a layer or an inlined run are laid out—their orientation, whether their properties align across siblings into a table, or whether a value maps to position, as on a timeline (§4.1). Visibility, placement, and arrangement are the three decisions of the conjecture. This framing reduces an apparently unbounded space of screens to something tractable. Within this grammar, a screen is described by a navigation path, placements for visible edges, and arrangements for visible collections. That is a small, regular decision space—small enough for the framework to own its mechanics (the path, collapse, layering, inlining, and responsive switching) while the developer states intent through hints on the model: which edges inline, which layer, how collections arrange. The decisions are the developer's; their implementation is the framework's. It also explains behaviors that would otherwise have to be built screen by screen: - **Navigation** is moving the lens. Traversing a relationship changes the path, not the model. - **Responsive collapse** is the lens switching edges from inlined to layered as space runs out, within the bounds the hints allow. Miller columns that collapse into a push stack are still layered—in depth rather than side by side. Side-by-side panes that degrade to tabs are the same edge moving from inlined to layered. - **Links** normally open another layer, making a cross-reference explicit. Recursive inlining also needs depth or cycle limits; layering alone does not bound the length of a navigation history. None of these decisions is new to the literature. Furnas's fisheye views [5] formalize visibility as a degree-of-interest function over a tree; overview+detail and focus+context interfaces [6] separate or blend levels of detail much as layering and inlining do; and tree visualization distinguishes children drawn _within_ their parents (inclusion) from children drawn _beside_ them (adjacency) [7]. Inlining a linked target is what Nelson called transclusion [8]. Systems such as Furnas's, APT [9], and SUPPLE [4] go further and compute the presentation—by interest score, by search, or by optimization. Strvct deliberately does not. It owns the mechanism and supplies the defaults; the developer states intent through hints, much as a projectional editor lets a language designer declare the notation through which a model is edited [10]. Our use of _lens_ differs from the Magic Lenses of HCI [11], which filter a local region of the screen. It shares the editable-view intuition of bidirectional programming [12], because edits flow back to the model; this analogy does not assert the formal round-trip laws of a bidirectional lens. The UI projection is not the only one. The same graph is projected into records in object pools (the **storage projection**), into JSON for import, export, and patching (the **exchange projection**), and into a schema-and-patch tool interface for AI agents (the **agent projection**, §7.1). Each reads the same annotated model, while requiring its own framework implementation and application configuration. --- ## 4. A Narrow Design Space for Information Apps The conjecture's scope is structured-information applications: CRMs, project management tools, mail clients, issue trackers, settings panels, and the like. The claim is that their screens can be expressed through relationship traversal, property editing, domain actions, and semantic collection arrangements. Readers can check this against interfaces they use: a mail client is a layered column of mailboxes, a layered column of messages, and an inlined message body; a settings panel is a vertical master-detail with inlined groups; an issue page is an inlined document whose cross-references layer. A modal is a layered edge drawn in front rather than beside; a search result is a derived collection; a dashboard is a set of inlined siblings with quantitative arrangement. What the grammar does not supply is the task-specific workflow—the triage sequence, the bulk edit, the pipeline report. Those remain application design, stated as domain actions and policies (§6.2) rather than as screens; the framework owns the interaction mechanics beneath them. ### 4.1 Relationship Traversal vs. Collection Arrangement In terms of the lens (§3), we divide the user interface grammar into two distinct layers: - **Relationship Traversal:** Moving the lens along links in the object graph (e.g., from a _Project_ to its _Tasks_, then to a specific _Task_). - **Collection Arrangement:** Displaying a set of related objects in a specific semantic layout (e.g., viewing _Tasks_ as an ordered list, a Kanban board grouped by status, a table, or a timeline). | Mechanism | Semantic Mapping | Examples | Implementation Scope | | --------------------------- | -------------------------------------------------------- | --------------------------------------------------------- | ---------------------------------------------------------------------------------------------- | | **Recursive Composition** | Parent-child relationships and presentation subtrees | Master-detail navigation, inline documents, anchored tabs | Implemented; arbitrary presets such as Kanban need their own grouping and interaction policies | | **Cross-Sibling Alignment** | Equivalent property slots aligned across items | Tables, spreadsheets, pivot matrices | Proposed framework extension | | **Value-to-Space Mapping** | Temporal or spatial values mapped to position and extent | Timelines, Gantt charts, calendars, maps | Part of the design space; no general generated arrangement established here | | **Quantitative Encoding** | Numeric values mapped to marks or axes | Line charts, bar plots, heatmaps | Part of the design space; specialized renderers required unless supplied by the framework | ### 4.2 The Boundary of Automatic Generation Generation covers the arrangements and controls the framework implements. A developer selects those mechanisms through metadata or node methods. A new arrangement or specialized interaction may require a new renderer; once implemented generically, that renderer can potentially serve multiple domain models. Spatial meaning alone does not determine this boundary: both calendars and battle maps encode meaningful positions. The practical distinction is whether an existing renderer supports the required semantics and interactions. Creative canvases, code editors, 3D viewports, medical imaging, and specialized scientific plots often require additional rendering and interaction code. An application can combine generated navigation, properties, and actions with such specialized surfaces. The amount of custom work depends on its tasks, not just its domain category. Historically, the cost of that boundary was paid in human effort against the framework's view internals. Because a specialized renderer works against a fixed contract (a node's typed slots, notifications and actions) rather than wiring its own data access, it is a well-bounded task for a coding agent. Whether this narrows the boundary in practice is untested. --- ## 5. Architecture & UI Mechanics in Strvct Strvct implements this grammar using client-side JavaScript: traversal (visibility and placement) through master-detail views and inline layouts, and arrangement through the collection views they contain. Master-detail views are its layering lens (§5.2); inline layouts are its inlining lens (§5.3). The core visual building blocks are **Tiles**, **Tile Stacks**, and **Master-Detail Views**. ### 5.1 Tiles and Tile Stacks The fundamental primitive in Strvct is the **Tile**: - **Summary Tile:** Displays a domain object with a title, subtitle, icon, and contextual actions. Selecting a summary tile opens its details in an adjacent column.
Summary Tile
[Summary Tile Diagram]
- **Property Tile:** Displays an individual object property (key-value pair) with direct inline editing (text inputs, numbers, toggles, date pickers) and validation feedback.
Property Tile
[Property Tile Diagram]
A **Tile Stack** is a scrollable, ordered list or grid of tiles. Stacks support drag-and-drop reordering, slide-to-delete, and direct data import/export.
Tile Stack
[Tile Stack Diagram]
### 5.2 Recursive Master-Detail Navigation A **Master-Detail View** pairs a master tile stack with a detail pane showing the selected object's contents. Each selection layers the chosen child in a new pane. Because detail panes can themselves contain child master-detail views, navigation composes recursively to arbitrary depth.
Master-Detail View
[Master-Detail Diagram]
Key characteristics of Strvct's master-detail engine: - **Flexible Orientation:** Each level can layout horizontally (like macOS Miller column file browsers [3]) or vertically (like nested accordion lists or settings panels).
Flexible Master-Detail Orientations
[Orientations Diagram]
- **Automatic Mobile Collapse:** When viewport space is constrained, earlier columns automatically collapse into a mobile push/pop stack equipped with interactive breadcrumbs—the same layers, stacked in depth rather than side by side. The shared navigation engine handles this collapse; application-specific content still needs responsive verification.
Expanded Viewport (Desktop)
[Expanded Viewport Diagram]

Collapsed Viewport (Mobile with Breadcrumbs)
[Collapsed Viewport Diagram]
- **Compositional Diversity:** Combining vertical, horizontal, and hybrid orientations expresses Miller column browsers, email clients, settings panels, chat rooms, and inspectors within a single uniform primitive.
Vertical
[Vertical Diagram]
Horizontal
[Horizontal Diagram]
Hybrid
[Hybrid Diagram]
### 5.3 Advanced Inline Layouts While column traversal is the default, certain complex screens require rendering child views directly inside parent tiles rather than pushing new columns. These children are inlined rather than layered. Strvct provides two inline layout mechanisms and a presentation-delegation hook:
Comparison of Subtree Layouts
[Layouts Compared Diagram]
1. **Anchored Tabs:** Renders selected children as interactive side-by-side panes or tab bars. Width arbitration automatically fits as many panes as space permits on wide desktop monitors while gracefully degrading to standard tabs on mobile.
Anchored Tabs (Wide Screen)
[Anchored Tabs Wide Diagram]

Anchored Tabs (Narrow Screen)
[Anchored Tabs Narrow Diagram]
2. **Document Inlining:** Renders a nested subtree as a continuous multi-column document with flowing sections, headers, and fields. Fields edit in place without triggering navigation transitions.
Inline Document Flow
[Inline Document Diagram]
3. **Presented Nodes (Presentation Delegation):** Allows an object to delegate its presentation to a derived node (e.g., displaying a structured RPG character sheet instead of raw property slots), providing bespoke reading views without custom component templates.
Presented Node Pattern
[Presented Node Diagram]
--- ## 6. Model Declarations & The Annotation Bridge Developers define domain models as JavaScript classes inheriting from `SvStorableNode`. Properties are declared as **slots** enriched with metadata annotations: ```javascript (class Character extends SvStorableNode { initPrototypeSlots () { // Name slot: String property, persisted, synced to view, editable { const slot = this.newSlot("name", ""); slot.setSlotType("String"); slot.setShouldStoreSlot(true); slot.setSyncsToView(true); slot.setCanInspect(true); slot.setIsSubnodeField(true); slot.setCanEditInspection(true); } // Level slot: Number property { const slot = this.newSlot("level", 1); slot.setSlotType("Number"); slot.setShouldStoreSlot(true); slot.setSyncsToView(true); slot.setCanInspect(true); slot.setIsSubnodeField(true); } // Inventory relationship: Navigable child object { const slot = this.newSlot("inventory", null); slot.setSlotType("Inventory"); slot.setShouldStoreSlot(true); slot.setFinalInitProto(Inventory); slot.setIsSubnodeField(true); } } initPrototype () { this.setShouldStore(true); this.setShouldStoreSubnodes(false); // fields are UI, not stored children } title () { return this.name() || "Unnamed Character"; } subtitle () { return "Level " + this.level(); } }.initThisClass()); ``` ### 6.1 Worked Example: From a Model to a Lens The `Character` declaration assumes an application-defined `Inventory` node class. `isSubnodeField` exposes each property as a field in the node's contents; `canInspect` also exposes it in the developer inspector. Neither persistence nor view synchronization alone makes a property visible. With the default `nodeChildrenLayout()` value of `"column"`, selecting a character opens its fields and Inventory relationship in the next pane. Selecting Inventory traverses that relationship. On a narrow viewport, earlier navigation panes collapse and breadcrumbs retain access to the path. To show the same contents as a document, the class can override an existing presentation hook: ```javascript // Methods inside Character; the stored properties remain the same. nodeChildrenLayout () { return "inline"; } nodeInlineDepth () { return 1; } ``` If Inventory is large and should remain a navigable summary within that document, its class can override `nodeIsInlined()` to return `false`. A container that should show its children as responsive anchored tabs instead overrides `nodeSubnodesAreAnchoredTabs()` to return `true`. These are node-level policies interpreted by shared views, rather than separately authored screens. Adding a `species` slot with the same type, visibility, persistence, and synchronization annotations as `name` makes it available to the shared field renderer and storage serializer. Labels, constraints, and presentation order still need deliberate choices. This illustrates the maintenance benefit: reuse of the field machinery rather than the elimination of presentation design. ### 6.2 Actions and Workflows Domain behavior must also be exposed deliberately. An action slot names a model method, and an optional `ActionInfo()` method supplies presentation state. For example, these members can be added to `Character`: ```javascript // Inside initPrototypeSlots(): { const slot = this.newSlot("advanceLevelAction", null); slot.setSlotType("Action"); slot.setIsSubnodeField(true); slot.setActionMethodName("advanceLevel"); } // Methods on Character: advanceLevel () { if (this.level() >= 20) { throw new Error("Character is already at the maximum level"); } this.setLevel(this.level() + 1); } advanceLevelActionInfo () { return { title: "Advance Level", isEnabled: this.level() < 20, isVisible: true }; } ``` The shared action field reads availability from the model and invokes the method; domain checks remain necessary for callers outside the UI. Slot constraints support field validation, while cross-property rules and failed operations need useful application feedback. Bulk operations and multi-step workflows require explicit domain methods and state; they do not follow automatically from navigation relationships. ### 6.3 The Multi-Reader Annotation Architecture Slot annotations serve as a decoupling bridge. Each framework subsystem reads slot metadata independently without cross-system dependencies: - **UI Layer (UI Projection):** Reads `slotType`, `canEditInspection`, and `isSubnodeField` to instantiate Property Tiles and navigate child subnodes. - **Persistence Layer (Storage Projection):** Reads `shouldStoreSlot` to serialize records into local storage (IndexedDB) and cloud object pools. - **Sync Scheduler:** Reads `syncsToView` to observe slot updates and post coalesced, deferred notifications to active views. - **Agent Projection:** Reads property types and constraints to auto-generate JSON validation schemas and patch tools. - **Localization Engine:** Reads property names and translation contexts to auto-translate labels. ``` ┌──► UI Rendering Layer (Property Tiles & Controls) ├──► Persistence Engine (IndexedDB & Cloud Commit) Slot Metadata ────┼──► Sync Scheduler (Weak Observer Notifications) ├──► AI Agent Infrastructure (Patch Schemas & Verification) └──► Internationalization Engine (Label Translation) ``` --- ## 7. Shared Architectural Capabilities Shared metadata lets framework subsystems reuse declarations. These capabilities require framework implementation, application configuration, and testing; their benefit is that much of that work is shared across generated views: ### 7.1 Natively AI-Operable Model The agent projection uses slot metadata for a schema-and-patch interface, described here by two generic operation types: 1. `schema-fetch`: Retrieves the slot schema for any domain class or object instance. 2. `apply-patch`: Applies a JSON patch payload to update properties or mutate child relationships. The number of operation types can remain constant as classes are added; schema volume, discovery work, and agent context do not. Invalid patches can return schema information for a correction attempt. A usable deployment must also define the exposed root objects, traversal and access rules, and how domain actions are invoked. A small tool vocabulary alone does not establish task success or low reasoning cost. ### 7.2 Headless Domain Execution and Testing Domain classes that keep browser dependencies in the view and service layers can run under Node.js. Tests can instantiate model graphs, invoke methods, and assert slot states without browser automation. This makes domain testing cheaper; layout, focus, gestures, and browser integration still require UI tests. ### 7.3 Transparent Persistence and Cloud Sync Strvct divides persistence into two unified strategies: - **Local Object Pools:** In-memory access to loaded domain objects, with asynchronous IndexedDB persistence. - **Content-Addressable Blob Store:** Asynchronous SHA-256 keyed storage for large binary assets (images, audio, files). Cloud synchronization sends versioned atomic commits containing only the modified slot records. Conflicts are detected deterministically per document pool. ### 7.4 Shared Accessibility and Localization Accessibility and localization are properties of the UI projection rather than projections of their own, and both are handled at the framework primitive level: translation is applied at the model-to-view boundary, as labels leave the model. Shared view primitives centralize ARIA roles, focus management, keyboard navigation, and translation hooks. Fixes in a primitive can benefit every view that uses it. Application-specific labels, reading order, custom renderers, assistive-technology behavior, and translation quality still need validation. ### 7.5 Live Inspector & Developer Mode Every tile supports modifier-clicking (Option + Click) to reveal a live Property Inspector displaying all declared slots, storage flags, and validation states. Developers can toggle Developer Mode to inspect hidden internal subnodes without writing custom debugging views. --- ## 8. A Deployed Application: undreamedof.ai Strvct was used to build **undreamedof.ai**, a commercial AI-powered virtual tabletop application for tabletop roleplaying games (D&D 5e). ### Reported Application Inventory | Subsystem | Estimated Domain Classes | Reported Specialized Custom Views | | -------------------------- | -----------------------: | --------------------------------- | | **Character System** | ~30 | None | | **Campaign Hierarchy** | ~20 | None | | **Session & Gameplay** | ~25 | 3D dice, battle map, combat and theatre stage, chat input, roll and choice request messages (7) | | **AI Integration & Tools** | ~15 | None | | **Printing, Account & Sync** | — | Book and miniature print previews, credit purchase, sync status indicator (4) | | **Total** | **~90** | **11** | The application uses framework views for character sheets, inventory managers, spellbooks, campaign trees, settings, chat logs, and inspectors. Its specialized surfaces are mostly graphical or highly interactive: a 3D WebGL dice roller, a tactical battle map, the session's chat stage, and print previews. The class counts are the author's estimates. The custom-view count comes from the source tree, counting the application's view and tile classes as of November 2026. Class counts are not screen counts, and the inventory is offered as an existence proof that the grammar covers a substantial application, not as a coverage ratio. The more informative evidence would be a worked example of one screen whose presentation hint grew into a presented node or a new renderer under product pressure, so a reader can see what "policy-sized" looks like in practice; that is planned for a future revision, along with a reproducible comparison of representative tasks on completion rate, time, navigation errors, and mobile usability. --- ## 9. Comparison with Related Paradigms | Dimension | Component Frameworks | Low-Code / Visual Builders | Strvct | | --------------------------------- | ------------------------------------------------- | ------------------------------------------------------- | ------------------------------------------------------------------------------------- | | **Primary Presentation Artifact** | Components and application composition | Visual layouts and bindings | Annotated nodes and presentation policies | | **Reuse Mechanism** | Shared components, libraries, schema-driven tools | Platform widgets, templates, connectors | Shared views interpreting node and slot metadata | | **Presentation Decisions** | Usually expressed in components | Usually expressed in visual configuration | Expressed in model metadata, node methods, and presentation nodes | | **Maintenance Tradeoff** | App authors maintain composition and integration | App authors maintain layouts and platform configuration | Shared mechanics reduce repeated view code; metadata and domain complexity still grow | | **Agent Integration** | Application- or library-defined APIs and tools | Platform- or application-defined connectors | Schema-and-patch operations derived from exposed metadata | | **Persistence** | Chosen and integrated by the application | Platform-dependent | Framework object pools and cloud synchronization | These categories overlap: component applications can derive forms from schemas, and low-code platforms can infer interfaces from data. Strvct's distinguishing commitment is to use the annotated object graph as the primary source for navigation, editing, and several non-UI subsystems. This table describes architectural defaults, not measured productivity differences. --- ## 10. Limitations & Future Work Several limitations and questions remain: 1. **Renderer Coverage:** Canvas editing, CAD, video sequencing, and 3D gaming typically need specialized renderers and interaction policies. The generation boundary depends on the controls and arrangements available in the framework (§4.2). 2. **Ecosystem Isolation:** To support content-addressable bundling and zero-build client loading, Strvct uses a custom resource loader rather than standard npm/Webpack/Vite tooling. 3. **Aligned Grid Arrangements (Tables & Spreadsheets):** While inline document flow and anchored tabs are production-proven, cross-sibling column alignment (making row tiles align into full spreadsheets) is currently a proposed framework extension. 4. **Extreme Collection Scaling:** Lazy view instantiation keeps rendering lightweight, but virtualized viewport scrolling for mega-collections (100,000 or more items) remains an active area of optimization. 5. **Evaluation and Workflows:** As stated in §1, comparative usability, accessibility, and development effort have not been measured, and complex multi-step workflows are stated as domain actions rather than derived from the grammar. The planned follow-up is described in §8. 6. **User-Chosen Lenses:** Because placement and arrangement are per-edge hints rather than authored screens, users could in principle reshape their own lenses—inlining a section they always want open, or layering one they rarely need. This is possible today through the live inspectors (§7.5), but not every hint is persisted; a supported, persistent user-facing control is future work. Engelbart's NLS gave users _viewspecs_—how many levels to show, how many lines per item—for much the same purpose [13]. --- ## 11. Conclusion Strvct demonstrates a model-first approach in which shared views interpret an annotated object graph. Its implemented navigation grammar combines recursive master-detail panes, inline documents, responsive anchored tabs, and presentation delegation. The lens model explains how these mechanisms can compose without a separately authored component tree for every screen. The deployed application shows the grammar covers a substantial product; quantitative coverage, development cost, and comparative usability remain open, and the conjecture itself is offered for the reader to test against the interfaces they know. Tables with cross-sibling alignment and other semantic arrangements remain extensions rather than established capabilities of this implementation. The practical promise is reduced duplication: developers maintain domain behavior and presentation intent, while the framework shares the machinery for rendering, synchronization, storage, and agent access. ### Continue with the Framework - [Getting Started](../Getting%20Started/index.html): set up and run an application. - [Slots](../Slots/index.html): declare types, storage flags, visibility, and editing metadata. - [Views](../Views/index.html): understand shared views and customization. - [Nodes](../Nodes/index.html): work with the domain object hierarchy. --- ## References [1] Pawson, R., & Matthews, R. (2002). _Naked Objects._ Wiley. [2] Apache Software Foundation. [_Apache Causeway_](https://causeway.apache.org/) (formerly Apache Isis), including its description of UI extensions. Accessed October 28, 2026. [3] Miller Columns. _Wikipedia._ https://en.wikipedia.org/wiki/Miller_columns (NeXTSTEP navigation pattern). [4] Gajos, K., & Weld, D. S. (2004). SUPPLE: Automatically Generating User Interfaces. _IUI '04._ [5] Furnas, G. W. (1986). Generalized Fisheye Views. _CHI '86_, 16–23. [6] Cockburn, A., Karlson, A., & Bederson, B. B. (2008). A Review of Overview+Detail, Zooming, and Focus+Context Interfaces. _ACM Computing Surveys_, 41(1). [7] Schulz, H.-J., Hadlak, S., & Schumann, H. (2011). The Design Space of Implicit Hierarchy Visualization: A Survey. _IEEE Transactions on Visualization and Computer Graphics_, 17(4), 393–411. [8] Nelson, T. H. (1981). _Literary Machines._ Mindful Press. [9] Mackinlay, J. (1986). Automating the Design of Graphical Presentations of Relational Information. _ACM Transactions on Graphics_, 5(2), 110–141. [10] Voelter, M., Siegmund, J., Berger, T., & Kolb, B. (2014). Towards User-Friendly Projectional Editors. _SLE 2014_, 41–61. [11] Bier, E. A., Stone, M. C., Pier, K., Buxton, W., & DeRose, T. D. (1993). Toolglass and Magic Lenses: The See-Through Interface. _SIGGRAPH '93._ [12] Foster, J. N., Greenwald, M. B., Moore, J. T., Pierce, B. C., & Schmitt, A. (2007). Combinators for Bidirectional Tree Transformations: A Linguistic Approach to the View-Update Problem. _ACM Transactions on Programming Languages and Systems_, 29(3). [13] Engelbart, D. C., & English, W. K. (1968). A Research Center for Augmenting Human Intellect. _AFIPS Fall Joint Computer Conference._ --- Source: /docs/Naked%20Objects%20Old/ # Naked Objects From Domain Models to Complete Applications ## Abstract Also available as a [PDF](compiled/Closing_the_Usability_Gap_in_Naked_Objects.pdf). The naked objects pattern promised to derive applications directly from domain models. Instead of maintaining a model, component tree, form schema, persistence mapping, API schema, navigation graph, and agent tool surface as separate descriptions of approximately the same facts, the developer would describe the domain once and let the runtime project it into each required form. That promise was technically demonstrated but rarely made attractive. Earlier naked-objects systems typically rendered objects as forms and collections as tables, producing complete administrative interfaces without producing a convincing general interaction model. The problem was not derivation. It was the limited grammar into which the model was derived. This paper proposes a stronger account of that grammar. Most structured-information interfaces consist primarily of two operations: 1. **traversing relationships among domain objects**, and 2. **projecting collections along a small number of semantic dimensions**. Strvct implements the first operation through recursively composed, orientation-flexible master-detail views generated from the object graph. Tiles and tile stacks provide a uniform summary, editing, and navigation surface; Miller-column-style recursion preserves context at arbitrary depth and collapses automatically on narrow viewports. They already cover recursive hierarchy, ordered lists, and feed-like rich-item sequences. We argue that inline detail composition, per-context child ordering, and cross-sibling alignment may extend the same recursion to trees, grouped lists, kanban boards, tables, and basic spreadsheets. This leaves value-to-space mapping—the placement or extent of objects according to numeric, temporal, or spatial values—as the clearest distinct projection family. The resulting boundary is sharper than “generated UI versus custom UI.” Ordinary information management belongs in the generated grammar. A custom view is appropriate when spatial representation itself carries irreducible domain meaning: a code editor, map, chart, waveform, canvas, 3D scene, or game surface. We present Strvct, an open-source JavaScript framework built on this model-first architecture. Centralizing the model-to-view pipeline also yields capabilities that component frameworks usually pay for repeatedly: automatic responsive behavior, headless execution, annotation-driven persistence, cloud synchronization, inspection, accessibility hooks, internationalization, and AI operation. The same annotations that generate the human interface expose a constant-size agent tool surface that does not grow with the number of domain classes. A production application, undreamedof.ai, comprises roughly 90 domain classes with about 90% framework-generated views; its remaining custom views are inherently graphical. ## 1. Introduction Most application frameworks treat the user interface as a separate engineering problem from the domain model. Each screen is designed, implemented, and maintained as its own artifact. Every new entity or property can propagate into component code, form layouts, validation, serialization, navigation, responsive rules, accessibility metadata, localization, and agent tools. The duplication is structural, not incidental, and its coordination cost grows with the model. Naked objects [1] proposed a different path: expose domain objects directly to users and generate the interface automatically. Developers write only the domain model; the UI follows. Consistency is guaranteed, because there is no separate representation to fall out of sync — the interface always reflects the model's actual state and shape. Pawson and Matthews described the pattern in 2002 [1]. Several frameworks have implemented it, most notably Apache Isis (now Apache Causeway) for Java [2]. These implementations proved the core thesis: automatic UI generation from domain models is feasible and produces functionally complete interfaces. Yet adoption stayed confined to internal tools, administrative interfaces, and prototypes. The failure was not merely visual polish. Earlier systems had no sufficiently expressive interaction grammar. Generic forms answer “what properties does this object have?” but not “where am I in the domain?”, “what is this object related to?”, or “how should I understand this collection?” A table is suitable for a ledger and poor for a media library; a list is suitable for search results and poor for a project pipeline. Treating every collection alike discards semantics the model often already contains. Component frameworks (React, Vue, Svelte) attack the same cost from the opposite direction: rather than eliminating view code, they make it cheaper to write. Component libraries push that further. But the view tree still exists, must be authored, and must be kept in sync with the model. Adding a property still touches a form, a validator, a serializer, and a translation file. Naked objects, done well, eliminates the view tree as an authored artifact. The view is derived. No component library closes that gap. This paper describes how to close that gap without returning to hand-authored screens. We argue that the design space for structured-information applications is narrow in a specific sense: most interaction is object-graph traversal plus collection projection. The vocabulary is richer than forms and tables, but much smaller and more semantic than a general component library. The contributions are: 1. A **two-part grammar for structured-information UI**: relationship traversal through the domain graph, and semantic projection of collections. 2. The **recursive, orientation-flexible, generated master-detail view** as the implemented traversal primitive. Miller columns have navigated hierarchies since NeXTSTEP; Strvct makes them recursive, orientation-flexible, auto-collapsing, and generated by default. 3. A **recursive collection-composition hypothesis** in which familiar forms reduce to placement policies over the existing object graph. Inline versus next-column detail, per-level orientation, dynamic child selection and ordering, and shared alignment may cover trees, grouped lists, kanban boards, tables, and basic spreadsheets without peer widget classes. 4. An annotation system in which independent framework layers—UI, persistence, synchronization, AI, accessibility, and internationalization—read metadata from the same slot declarations without coordinating. 5. A **natively AI-operable domain model** as a demonstrated consequence of that annotation system: a single pair of tools covers every editable class, so the agent-facing tool surface is constant in the size of the model rather than growing linearly with it. 6. A working framework and production application demonstrating the feasibility of the implemented traversal grammar, while identifying inline composition, runtime node-built objects, and value-to-space projection as testable directions rather than completed results. ## 2. The Usability Gap Prior naked objects implementations present each object as a form of property fields and each collection as a table or list, with navigation through menus, links, or search. This is functionally sufficient but creates four specific problems. **Lack of spatial hierarchy.** Users expect spatial relationships to carry meaning: hierarchy top-to-bottom, navigation depth left-to-right, containment for ownership. Generic forms and tables flatten these relationships. Users must navigate menus instead of perceiving structure. **No viewport adaptation.** Modern applications invest heavily in responsive design: collapsing navigation, stacking layouts, hiding secondary content. Form-based interfaces either ignore the viewport or bolt on ad-hoc responsive behavior that does not generalize across the model. **Inconsistent navigation depth.** As users go deeper into an object hierarchy, form-based interfaces either replace the current view (losing context) or open new windows (fragmenting it). Neither tells users where they are in the larger structure. **No visual continuity.** Without a consistent spatial model, users cannot build a mental map. Each navigation action feels like arriving at a new, disconnected screen rather than moving within a coherent space. These problems are not inherent to naked objects. They are artifacts of one UI strategy — generic forms and tables — that prior implementations chose because it was simple and sufficient for internal tools. The question is whether a different strategy can keep automatic generation while meeting the expectations set by modern hand-crafted applications. ## 3. A Narrow Design Space The narrow-design-space claim is often misunderstood as “all applications look like forms.” The stronger and more useful claim is this: > **Most interaction in structured-information applications consists of traversing relationships among domain objects and projecting collections of those objects along a small number of semantic dimensions.** This describes CRM, project management, accounting, ecommerce administration, healthcare records, knowledge management, messaging, social software, media libraries, and much of calendaring. Their visual styles differ, but their structural operations repeat. ### 3.1 Relationship Traversal An application domain is an object graph: ```text Workspace ├─ Projects │ └─ Project │ ├─ Tasks │ ├─ People │ └─ Milestones ├─ Customers └─ Documents ``` Users select a collection, select an object, follow a relationship, inspect or edit the next object, and continue. Recursive master-detail navigation makes this traversal spatially legible because earlier context remains visible. On a narrow viewport the same chain becomes push/pop navigation with breadcrumbs. This operation is already central to Strvct. It covers object discovery, inspection, editing, settings, and movement through nested ownership and relationships. ### 3.2 Collection Projection Traversal alone does not answer how a collection should be understood. The same objects may need several presentations: ```text Tasks ├─ List ordered by priority ├─ Table showing status, assignee, and due date ├─ Kanban grouped by status └─ Timeline positioned by start and end date ``` These are not four unrelated application features. They are four projections of one collection whose semantics already live in the model. Several familiar interface forms reduce to behavior Strvct already provides or to layout variants of it: - **Feed** is an ordered tile stack with temporal or ranked ordering and rich item tiles. - **Tree** is the existing recursive relationship topology. An inline expanded tree changes where levels appear, not the underlying navigation semantics. - **Gallery/grid** is a wrapped arrangement of tiles rather than a new semantic family. - **Table** is a vertical stack of object rows whose children are shown inline horizontally and whose equivalent child widths are aligned across rows. This collapse suggests that most named collection views are configurations of recursive composition rather than independent projection families: | Mechanism | Semantic mapping | Familiar forms | | --- | --- | --- | | Recursive composition | relationships or derived groups → nested child views | tree, grouped list, kanban | | Cross-sibling alignment | equivalent child identity → shared width and position | table, basic spreadsheet, pivot | | Value-to-space mapping | numeric, temporal, or spatial value → position or extent | timeline, Gantt, calendar, map | | Quantitative encoding (open) | values → marks, axes, color, or area | chart, plot, heatmap | A matrix need not require a separate renderer. A table row is an object tile whose selected children are embedded inline; stacking rows and regularizing equivalent child widths produces columns. A spreadsheet adds range selection, keyboard traversal, formulas, fill operations, and recalculation, but these are interaction and computation policies over the same recursive geometry. A pivot can introduce derived group and aggregate nodes before applying it. The hypothesis is therefore stronger than shared matrix geometry: much of the geometry may already exist in tile/browser composition. The projection algebra consists of orthogonal choices: - **Placement:** next column or inline, with horizontal, vertical, or wrapped child layout - **Semantic mapping:** which slots determine order, group, axis position, or extent - **Child resolution:** which semantic children appear, in what order, for this object and context - **Alignment:** whether equivalent children share size and position across siblings - **Item presentation:** compact field row, summary tile, rich tile, or bounded custom renderer - **Interaction mapping:** reorder, drag-to-change-property, inline edit, or range selection - **Hierarchy mode:** traverse levels across browser columns or expand descendants inline Under that account, familiar UI names are presets rather than framework primitives. A feed is a linear stack with temporal or ranked ordering and rich tiles. A kanban board is a grouped node graph with horizontal groups, inline vertical children, and a rule that dragging changes the grouping slot. A table is inline horizontal detail plus shared alignment. A timeline still requires a continuous time axis plus start and end mappings because domain values, rather than graph topology, determine geometry. ### 3.3 Why Semantics Matter A component library names implementation conventions: tabs, modals, accordions, drawers, cards, toolbars. Those names describe rectangles and interaction mechanics. They say little about the domain. A semantic projection says something stronger: - A kanban board groups objects by state and may change that state when an object moves. - A timeline maps domain dates or intervals onto time. - A table compares selected properties across objects. - An inline tree exposes several levels of the already-recursive relationship topology at once. Because the mapping has domain meaning, the framework can derive behavior as well as appearance. Dragging a deal between kanban columns can set `deal.stage`. Selecting a table row can resume ordinary object traversal. Moving an event can change its start and end slots. The projection is not a dead-end widget; it remains attached to the same live model. ### 3.4 Why This Space Appears Narrow Users build spatial mental models of systems (Norman, 1988; Gentner & Stevens, 1983). They use location, containment, proximity, hierarchy, and sequence to reason about digital information. Gestalt principles explain why proximity, similarity, and enclosure make repeated structures coherent (Wertheimer, 1923; Koffka, 1935). Consistency is therefore not merely visual neatness; it reduces the number of interaction rules a user must learn. The narrowness also comes from the domain. Structured-information applications are primarily about named objects, typed properties, relationships, collections, and actions. Once those facts are explicit, the plausible ways to lay them out are constrained. The industry has created enormous surface variation on top of a much smaller structural vocabulary. This yields three separate coverage questions: | Question | Expected coverage | | --- | --- | | Can the domain be represented as an annotated object graph? | Broadest | | Can application navigation follow that graph? | Slightly narrower | | Can every primary viewport be generated from standard projections? | Narrowest | These questions must not be collapsed into one percentage. An IDE can have a natural object model and generated project shell while still requiring a bespoke code editor. A medical system can generate patient navigation and records while retaining a specialized imaging viewer. Custom presentation does not erase the value of a shared model. ### Scope and Counterexamples The clean boundary is not “business software versus consumer software.” It is closer to **managing structured information versus manipulating a specialized medium**. The residual custom surfaces fall into four coherent families: - **Creative surfaces:** rich-text and code editors, drawing canvases, CAD, video editing, and music sequencing. - **Scientific or domain visualization:** medical images, waveforms, maps, 3D scenes, network graphs, and molecule viewers. - **Quantitative visualization:** charts, plots, and heatmaps. These may admit their own future semantic grammar, but are not implied by object traversal alone. Pivots fit the matrix family described above even when their cells later receive quantitative encodings. - **Immersive or real-time surfaces:** games, video calls, simulations, and virtual worlds. In these cases geometry itself carries domain meaning. A map cannot be replaced by an inspector because position is part of the information. A code editor cannot be replaced by a property list because editing text with syntax, selection, and spatial context is the task. The useful question is therefore not whether a residue exists, but whether it is the product or the periphery. For a CRM, the generated grammar may cover nearly the entire product. For an IDE, it can cover the shell while the editor remains central. For a game, the custom surface is the product and generated UI is supporting infrastructure. This is a deliberate trade-off. Refusing arbitrary layouts buys consistency, responsive behavior, accessibility leverage, headless testability, agent interoperability, and low view-layer maintenance. Applications dominated by specialized media should use custom views extensively or choose a different framework. Applications dominated by structured information stand to gain the most. ## 4. Approach: Graph Navigation and Semantic Projection Strvct's UI approach has two layers. The first is implemented today: tiles, tile stacks, and recursive master-detail views derive navigation, inspection, ordered collections, and feed-like rich-item sequences from the model graph. The second is a disciplined direction for expansion: let the same detail browser render inline, resolve its children dynamically for the current context, and align equivalent children across siblings. Value-to-space mapping remains a separate proposed layer. Keeping their status distinct matters; the production case study validates the first layer, not these extensions. Two bounded forms of inline placement, anchored tabs and document inlining (§4.6), have since been built and are in production use; cross-sibling alignment and the forms that depend on it remain proposals. | Concept | Unifies | | --- | --- | | Annotated slots | Properties, editors, storage records, schemas, translation context, accessibility metadata | | Domain nodes | Objects, navigation hierarchy, persistence graph, and AI-operable surface | | Tiles | Summaries, property editors, list items, and navigation affordances | | Master-detail views | Relationship traversal, drill-down, context, breadcrumbs, and responsive compaction | | Collection projections | Ordering, comparison, grouping, hierarchy, density, and temporal arrangement | ### 4.1 Tiles The fundamental unit of presentation is the **tile**: a view of a single domain object or a single property of one. **Summary tiles** present domain objects with a title, subtitle, and optional sidebars. They are the primary navigation element: selecting a summary tile reveals the object's contents in an adjacent detail area.
Summary Tile
[SVG diagram]
**Property tiles** present individual properties as key-value pairs, with optional notes and validation errors. Specialized property tiles handle common types — strings, numbers, dates, images, booleans — with type-appropriate editing.
Property Tile
[SVG diagram]
Tiles support direct-manipulation gestures: slide-to-delete, long-press reordering, and drag-and-drop between tile stacks, across browser windows, and to or from the desktop and other applications. Domain objects register which MIME types they accept, enabling type-safe import and export through standard drag interactions. Tiles can be subclassed for domain-specific presentation, but the default tiles aim to be sufficient for most cases. Custom tiles should be the exception. ### 4.2 Tile Stacks A **tile stack** is a scrollable, ordered sequence of tiles presenting the subnodes of a domain object. Tile stacks support either orientation (vertical or horizontal) and gestures for adding, removing, and reordering items.
Tile Stack
[SVG diagram]
### 4.3 Master-Detail Views A **master-detail view** pairs a tile stack (the master) with a detail area showing the currently selected item. The detail area may itself contain another master-detail view, enabling arbitrarily deep navigation through recursive composition.
Master-Detail View
[SVG diagram]
Three features make this composition practical. **Flexible orientation.** The detail area can sit to the right of or below the master, as the domain object specifies or the interface overrides. The same primitive expresses both horizontal navigation (like a file manager) and vertical drill-down (like a settings panel).
Master-Detail Orientations
[SVG diagram]
**Automatic collapsing.** When the viewport is too narrow for the full chain of master-detail views, earlier columns collapse automatically. A breadcrumb bar tracks the navigation path and provides back-navigation. The same structure works on a wide desktop monitor and a narrow mobile screen with no per-object responsive design.
Expanded
[SVG diagram]

Collapsed
[SVG diagram]

**Header and footer areas.** The master section supports optional header and footer views for search, message input, or group actions. Common interaction patterns fit within the same compositional framework. ### 4.4 Composition Nesting master-detail views with varying orientations produces navigation structures that match many common application patterns: Miller column file browsers, settings hierarchies, email clients, chat applications, inspector panels. These are not special cases implemented individually. They are natural compositions of the same three primitives.
Vertical
[SVG diagram]
Horizontal
[SVG diagram]
Hybrid
[SVG diagram]
Composability is the key insight. Rather than implementing a fixed set of application templates, the framework derives a navigation structure from the object graph and allows each collection to choose a semantically appropriate projection. Selection from any projection returns to the same object-inspection and relationship-traversal grammar. Real-world evidence for the thesis predates this paper by years. Recursive, auto-collapsing master-detail is now the dominant navigation pattern on phones, watches, and other small screens — settings apps, mail clients, and file browsers that show one column at a time and push or pop columns as the user drills in and backs out. That is exactly the narrow-viewport collapse described in §4.3, arrived at independently by platform designers. Small viewports do not merely *permit* the narrow grammar; they *enforce* it. There is no room for bespoke per-screen layout on a watch face, so designers converge on master-detail collapse whether or not they would choose it on a desktop. The pattern's prevalence on the most constrained devices is evidence that the design space is narrow where it is most tested. The Miller Column pattern [3] has been used since NeXTSTEP for file browsing. Our contribution is not discovering it but making it recursive (columns nest vertically or horizontally), orientation-flexible (each level chooses its own orientation), and the *generated default*, composed from model annotations rather than hand-built per screen. ### 4.5 Inline Detail and Aligned Children (Proposed) The current tile stack is already the default linear collection. Ordering it temporally or by rank and giving each item a rich tile produces a feed without requiring a separate `FeedView`. Recursive hierarchy is likewise already present in the detail browser. The smallest high-leverage extension is therefore not a catalog of new views, but a placement policy: ```text detail placement = nextColumn | inline ``` `nextColumn` is today's navigation behavior. `inline` would embed the same child browser within its parent tile, preserving node-view resolution, selection, actions, synchronization, and accessibility rather than introducing a second child-rendering path. Per-level orientation then gives several familiar forms: ```text outline = inline descendants, vertical at each level grouped list = derived group nodes, inline vertical members kanban = horizontal group nodes, inline vertical members gallery = wrapped child tiles ``` Grouping, filtering, ordering, and aggregation are transformations of the collection before presentation. For example, grouping tasks by `status` creates status-group nodes; rendering those nodes horizontally with their task children inline produces kanban geometry. Dragging between groups can map back to a mutation of `task.status`. A table needs one further constraint: equivalent children across sibling rows must share widths and positions. ```text parent stack: vertical row detail: inline, horizontal children: selected and ordered for the table context alignment: equivalent child keys share column widths ``` This makes a table a regularized recursive composition rather than a peer `TableView`. A basic spreadsheet can use the same geometry while adding range selection, keyboard movement, fill, and recalculation as interaction policies. More elaborate spreadsheets may still warrant specialized behavior, but their layout need not begin from a separate abstraction. Child order cannot remain solely a class-level declaration under this model. The same `Contact` may need a full inspector order, a compact summary, or a table-specific subset. Effective child descriptors should resolve from the current relationship and presentation context, with class annotations as defaults. Such descriptors can choose visibility, order, sizing, editability, summary/detail role, and placement without changing the object's semantic schema. Value-to-space views remain different. A timeline, for example, positions an item by `startDate` and gives it extent through `endDate`; a chart maps values to axes and graphical encodings. Here domain values determine geometry rather than merely selecting, nesting, or aligning nodes. These examples illustrate a proposed direction, not a current Strvct API. The framework—not the model—must remain responsible for viewport decisions, gesture mechanics, and concrete rendering. The model may declare semantic mappings and presentation hints; the view layer decides how they become pixels on a particular platform. This preserves the naked-objects boundary and keeps the same application runnable under web, terminal, or headless user interfaces. Two bounded forms of this placement policy are now built and used in production; §4.6 describes them. ### 4.6 Anchor Tabs and Document Inlining The `inline` placement of §4.5 is a general proposal. Two narrower forms of it now exist in Strvct, each adopted where the column grammar proved awkward in the case study. Both lay out the same subtree with the same tiles. They differ in how many levels appear in place, and in who chooses them: | Layout | Levels shown in place | Who chooses what is shown | Choosing a tile | | --- | --- | --- | --- | | Column (default) | none; one level per column | the user, by navigating | opens the next column | | Anchored tabs | one: the selected children, side by side | the user, interactively, within the width available | opens within that child's pane | | Document inline | several, as nested sections | the model, by hint | focuses or edits in place; navigation resumes below the inlined depth |
Three Layouts of One Subtree
[SVG diagram]
**Anchor tabs: interactive, partial inlining.** A node that answers `nodeSubnodesAreAnchoredTabs()` presents its children as one row of tabs. Every *open* tab sits at the top-left of its own pane, and the panes lie side by side in tab order. The user chooses which children are open and may pin them; the available width decides how many fit. On a phone, the row degrades to ordinary tabs with one pane. On a wide screen, the same row fans out into several panes. This is partial inlining: of the children that would otherwise be reached one at a time in the next column, the user-selected subset is rendered in place at once. Each pane is a full detail view, so traversal inside it continues by the ordinary column grammar, scoped to that pane. The model contributes only semantic hints: - `nodeAnchoredTabNodes()` says which children are tabs, so internal bookkeeping nodes never become tabs. - `nodeAnchoredTabKey()` gives a stable identity under which a user's pins persist across reloads and devices. - `nodeTabPinPreference()` suggests a default, which the user's own choice overrides. - A child that is not currently applicable hides itself through its ordinary visibility. In the case study, the game session's Me tab appears only once a character is chosen, and the Party tab only when the party has more than one member. The view layer owns pane widths, which panes fit, dividers, and pinning. No tab is privileged, so the primary context (the session's narration) is a peer of the others, not a special column.
Anchored Tabs: Wide
[SVG diagram]

Anchored Tabs: Narrow
[SVG diagram]

Anchor tabs subsumed the companion view of §4.8 in the case study. A companion pairs one primary context with *one* secondary node. Anchored tabs let any number of sibling contexts sit side by side under the node that owns them, with one width-arbitration rule instead of two. The companion mechanism remains in the framework for cases that need exactly one docked secondary context. **Document inlining: model-chosen, multi-level inlining.** A node that answers `nodeChildrenLayout()` with `"inline"` is read as a document, not navigated. Its children become sections, each headed by its title, with its own children shown in place beneath. Successive levels nest to `nodeInlineDepth()`. The framework flows these sections responsively: - **Columns.** Sections flow in CSS columns sized from the existing `nodeMinTileWidth` hint, newspaper-style, or in rows with `nodeInlineFlow()` set to `"rows"`. `nodeInlineMaxColumns()` caps the column count, so wide screens widen the columns instead of adding empty ones. - **Spans.** A section may span every column with `nodeSpansInlineColumns()`, as a header or status strip would. - **Opting out.** A heavy subtree, such as a long spell list, declines inlining with `nodeIsInlined()` and remains an ordinary navigable tile. - **Empty collections.** Inline documents leave out empty collections (`nodeIsEmptyCollection()`). A column still lists them, because there they are places to add things; in a document they are noise.
Inline Document
[SVG diagram]
Taps inside a document focus and edit fields in place but never navigate. Past the inlined levels, traversal resumes exactly as before: in the next column, or in the current pane inside anchored tabs. The three layouts therefore compose. A document can sit in an anchored pane, and a tile in the document can open into the column grammar. **A node presented as another node.** Document inlining needed one further mechanism. A domain object's natural structure is not always its most readable one. A character's subnodes follow its schema: ability scores, skills, inventory, spellcasting. A character *sheet* groups the same facts by how a player reads them. Rather than write a custom view, a node may answer `nodePresentedNode()` with another node whose children the column shows in its place. The character stays the node on the navigation path; its column shows a derived sheet node, rebuilt when the character changes and laid out inline. In the case study this replaced a bespoke character-sheet design with roughly the same visual result, built entirely from tiles, sections, and hints. The derived sheet shows the character in every context where it appears: the player's character list, the session's Me and Party tabs, and beside its assistant.
Presented Node
[SVG diagram]
One limitation surfaced. In version 1, sheet rows are derived lines rather than the character's own nodes. A node has exactly one parent, so a spell cannot be both a child of the character and a row in a sheet section. Editing such a projection in place requires a way to show a node without taking ownership of it. That is the next framework question this work raises. It is the same requirement that context-resolved child descriptors (§4.5) would impose on tables. These two forms test the §4.5 hypothesis only partially. Neither aligns equivalent children across siblings, so neither yet produces a table or kanban board. Both confirm the cheaper part of the claim: in-place placement can be added as a per-node layout role over the existing tiles, synchronization, editing, and theming, without a second child-rendering path and without the model referencing a view. ### 4.7 Runtime Objects Built from Nodes (Proposed) Inline matrices expose a more general possibility. A row need not be an instance of a statically declared JavaScript class. It can be a runtime object whose explicit child nodes provide both state and behavior: ```text RowObject ├─ quantity ValueNode ├─ unitPrice ValueNode ├─ subtotal MethodNode └─ tax MethodNode ``` A message proxy can adapt this graph to ordinary object-like dispatch: ```javascript row.messageProxy().subtotal() ``` The proxy resolves `subtotal` to a stable message key, finds the corresponding child node, and calls `activate(args)`. A value node returns or updates stored state. A method node stores inspectable source, compiles it to a JavaScript function, and invokes it with the row's message proxy as receiver, allowing named expressions such as `this.quantity() * this.unitPrice()` rather than coordinate references such as `C7*D7`. Stable keys, duplicate-name behavior, execution authority, caching, error propagation, and asynchronous activation would require explicit contracts. This makes spreadsheet formulas methods on actual row objects. Column position is presentation rather than identity, so reordering columns does not invalidate named dependencies. Presentation metadata decides whether a method cell shows its source, activation result, or both. A cell remains an ordinary tile: it can edit directly in the matrix or navigate to a detail column where Strvct automatically exposes its value, source, validation, dependencies, formatting, and actions. The result is broader than spreadsheets: structure and behavior can both be assembled dynamically from persistent, inspectable nodes while participating in the normal Strvct messaging and navigation protocols. Presentation is one consumer of this runtime object graph, not its definition. ### 4.8 Companion Views: Preserving Secondary Context Relationship traversal usually advances one selected path through the object graph. Some tasks also need a second context to remain available while that path changes: a conversation beside a session, an inspector beside an editor, reference material beside a document, or guidance beside a workflow. Strvct implements this through the **companion view**. A model node may answer `nodeCompanionNode()` with another node to present alongside its ordinary master-detail content: ```javascript nodeCompanionNode () { return this.referenceMaterial(); } ``` This is a semantic relationship, not a layout instruction. The model names the secondary context but does not choose its width, inspect the viewport, reference a view class, or control collapse state. The view layer docks the companion to the right or bottom according to the stack axis, reserves real space for it, and compacts the navigation chain rather than floating the panel over neighboring content. When space becomes scarce, the panel collapses behind an edge handle or disappears entirely; a user may pin it open or closed while sufficient room remains. By default the companion node receives its own embedded `SvBrowserView`, with isolated navigation and breadcrumbs, so following a relationship inside the companion does not disturb the application's primary path. A node may instead resolve to a specialized view through the ordinary node-view protocol. Companion View therefore demonstrates a bounded form of **hybrid view composition already present in Strvct**: generated navigation and responsive arbitration can contain either another generated object browser or an irreducibly custom representation without creating a parallel application shell. Companions are not a third peer to graph traversal and collection projection. They are a composition rule: preserve one secondary node context beside the current traversal while the framework continues to own placement, responsiveness, and navigation isolation. In the case study the companion has since been superseded by anchored tabs (§4.6), which generalize it from one secondary context to any number of sibling contexts; the mechanism remains in the framework. ### 4.9 Examples We decompose four widely-used applications into their constituent views:
Email
[SVG diagram]
Twitter/X
[SVG diagram]
Facebook
[SVG diagram]
Amazon
[SVG diagram]
These diagrams are simplifications, not exact reproductions. Their structures combine relationship traversal with collection projection: folders and products as linear or wrapped tile collections, posts as temporally or rank-ordered rich tiles, comments as recursive relationships, and selected objects as details. A custom item renderer is consistent with the hypothesis only when it presents one domain node without introducing an independent navigation, state, or layout system; otherwise “custom content” would become a loophole large enough to hide the application. ## 5. From Model to Interface To make "write the model, get the UI" concrete, consider a minimal domain class in Strvct: ```javascript (class Character extends SvStorableNode { initPrototypeSlots () { { const slot = this.newSlot("name", ""); slot.setSlotType("String"); slot.setShouldStoreSlot(true); slot.setSyncsToView(true); slot.setCanEditInspection(true); } { const slot = this.newSlot("level", 1); slot.setSlotType("Number"); slot.setShouldStoreSlot(true); slot.setSyncsToView(true); } { const slot = this.newSlot("inventory", null); slot.setFinalInitProto(Inventory); slot.setIsSubnodeField(true); } } initPrototype () { this.setShouldStore(true); } subtitle () { return "Level " + this.level(); } }.initThisClass()); ``` This definition contains no UI code, no form layouts, no navigation logic, and no serialization code. Yet it produces: - A **summary tile** showing the character's name as a title and "Level 1" as a subtitle - **Property tiles** for `name` (editable string field) and `level` (editable number field), with appropriate input types - A **navigable field** for `inventory` that opens a new master-detail view of the inventory's contents when selected - **Automatic persistence** to a local record store, with dirty tracking and transactional commits — and, for a class that is a cloud document, versioned commits of the same records to the cloud - **Bidirectional synchronization**: editing a field updates the model; programmatic model changes update the view - **Automatic translation** of field labels and values when internationalization is active The slot annotations — `setShouldStoreSlot`, `setSyncsToView`, `setCanEditInspection`, `setIsSubnodeField` — bridge the domain model and the framework's automatic behaviors. Each controls one aspect of the object's lifecycle. Together they give the UI, storage, and synchronization layers enough information to operate without additional code. The screenshot below shows Strvct in undreamedof.ai, an AI-powered virtual tabletop for tabletop roleplaying games. Character sheets, campaign hierarchies, session management, and settings panels are all generated from domain model annotations. No bespoke layout code was written for any screen shown. Screenshot of undreamedof.ai, a Strvct-based application ## 6. Architecture Strvct is a client-side JavaScript framework. Applications run as single-page apps in the browser, making heavy use of client-side persistent storage — both for caching code and resources via a content-addressable build system, and for a local record store of application state (IndexedDB) that holds the same rows the cloud does. Strvct does not compile or pre-render user interfaces. There is no build step that produces a view tree, no template system, and no static component hierarchy. Views are instantiated lazily at runtime, only when the user navigates to a node in the object graph. Each navigation step inspects the target node's class and slot annotations, discovers or creates an appropriate view, and binds it to the node for live bidirectional synchronization. Once created, a view persists as long as its node stays visible, kept in sync through the notification system. The result is closer to a live object browser than a conventional render pipeline: the UI that exists at any moment is determined by the user's current navigation path through the object graph, and it responds immediately to model changes. ### 6.1 Domain Model The domain model is a graph of objects inheriting from a common base class. Each object has properties declared as *slots* with annotations, actions exposed as methods, a `subnodes` array of child objects, a `parentNode` reference, and a unique persistent identifier. The model is fully independent of the UI layer. Model objects hold no references to views and communicate outward only by posting notifications. The same model code therefore runs headlessly in Node.js for testing or server-side processing. ### 6.2 The Annotation Bridge The slot system makes automatic UI and storage possible. Rather than raw instance variables, properties carry metadata annotations that each framework layer consults independently: - **Type**: selects the property tile and enables runtime type checking. Every generated setter validates its argument against the declared type, catching type errors at assignment rather than at compile time. - **Persistence**: includes the slot in storage records. - **View synchronization**: triggers view updates when the value changes. - **Subnode relationship**: controls whether the value appears in the object's navigable hierarchy. - **Editability**: determines whether the property can be modified through the UI. - **Inspectability**: exposes the slot to the generic inspector for debugging, independently of whether it appears in the normal navigable hierarchy. - **Auto-initialization**: specifies a class to instantiate if no value was loaded from storage. - **Translation context**: provides semantic context for AI-powered translation. No single annotation knows about the others. The UI layer reads type and editability; the storage layer reads persistence; the synchronization layer reads sync flags. New layers — internationalization, cloud sync, schema generation — can be added without modifying existing annotations or the domain model. ### 6.3 Storage Persistence is annotation-driven. The persistence layer watches slot mutations, batches dirty objects at the end of each event loop into atomic transactions, and commits them to a local record store. On load, stored records are deserialized back into live object instances with relationships re-established. Storage is organized as *object pools*. A pool is one independently loadable document — a game session, a character, a campaign — whose objects are reachable from a root, and whose id is that root's persistent id. Every object is one row keyed by its pool and its own id; references inside a pool are near references by id, and the only way to point at another document is a far reference to its pool, which is followed asynchronously. A folder holds no list of its documents: each document's root row names the folder it is placed under, with a sort key, so a folder's contents are a query and placement is the tree. Collections that grow without bound, such as a chat's messages, use the same placement and are loaded in windows rather than whole. The cloud holds the same rows, one record per row, with a version per pool. Saving a document sends the records changed since the last acknowledged version as one commit, which the server applies atomically or refuses as a conflict; opening one on a device that already holds it asks only for the changes since its version. The local store and the cloud are therefore one shape with two backings, and the same suite of tests pins both. A separate content-addressable blob store handles large binary data using SHA-256 hashes as keys, giving automatic deduplication. Records hold hash references, never blob data, and long text spills to the same store, so every record stays small. Garbage collection is per pool: rows unreachable from the pool's root, by reference or by placement, are removed. Documents themselves are deleted explicitly, and deleting a folder deletes what is placed beneath it. ### 6.4 Synchronization Model and view communicate through a deferred, deduplicated notification system. When a model property changes, a notification is posted; observing views schedule a sync pass. Multiple changes within one event loop are coalesced. Bidirectional sync stops automatically when values converge, preventing infinite loops. Observations use weak references, so garbage collection of either party cleans up subscriptions automatically. ## 7. Structural Consequences When the framework controls the entire pipeline from model annotation to rendered view, capabilities that would otherwise cost per-component effort fall out of the architecture. These capabilities are not surprises. They are downstream consequences of one structural fact: the framework has complete knowledge of the domain model and controls the single point where model data flows to the UI. We mark each capability's status explicitly, and group the subsections accordingly: those **demonstrated** in the case study (§7.1–7.7), those that are **architectural affordances** the design provides but we have not externally validated (§7.8–7.9), and two **proposed** directions the architecture invites but we have not built (§7.10–7.11). #### Demonstrated in the case study ### 7.1 AI-Operable Domain Model The same annotations that drive UI generation make the domain model operable to AI agents — and operable *within the runtime*, not merely legible to a bolted-on assistant. A schema for any object is derived from its slot metadata. Edits arrive as JSON patches and are applied to the live object graph through the same setters, type checks, notifications, and sync passes a human edit takes. There is no separate AI-facing surface to drift out of sync. This is the eliminate-the-translation-layer thesis applied a second time: naked objects removed the layer between model and view; the same annotation bridge removes it between model and agent. A single pair of tools—*schema-fetch* and *apply-patch*—covers the entire domain, regardless of how many classes are editable. A rejected patch carries the offending slot's schema, so the agent self-corrects without re-fetching context. Function calling, Model Context Protocol, and OpenAPI can all expose a similarly generic interface; the distinction is not a limitation of those transports. Strvct's advantage is that the schemas and patch behavior are derived automatically from the live domain model used by UI and persistence, rather than maintained as a parallel description that can drift. A new domain class is therefore AI-operable when it is declared, and the agent-facing tool surface remains constant in the size of the model. ### 7.2 Headless Execution and Testability Model classes hold no references to views or browser globals, so the same domain code runs unchanged under Node.js. Tests instantiate the model, drive it through action methods, and assert against slot values without a DOM. The notification system, persistence, and patch validation all operate without rendering, so behaviors that would normally require browser automation against a real DOM reduce to direct model assertions. The model/view separation that makes auto-generation possible is the same separation that makes the model headlessly executable: one architectural choice serves both ends. ### 7.3 Transparent Persistence and Cloud Sync The framework owns the complete object graph and understands its structure through annotations, so persistence splits transparently into two strategies: synchronous object pools for the model graph, keeping the UI immediately responsive, and an asynchronous content-addressable blob store for large binary resources, so they never block rendering. The same structural knowledge enables transparent cloud synchronization. Because every object is already a row with a known pool, the framework knows exactly which records changed, which blobs they reference, and which document they belong to; a cloud save is a commit of those rows against the document's version, and a conflict is detected rather than silently merged. Annotations reach this layer too: a slot can be stored yet kept on the device, out of what a commit sends. The developer annotates what should persist; the framework decides how and when. ### 7.4 Content-Addressable Resource Loading The build system produces a content-addressable bundle keyed by content hash. Unchanged resources are never re-downloaded across deployments, and identical content across paths is stored only once — caching granularity that path-based bundlers cannot achieve. End-to-end control of the resource pipeline is the same structural fact that drives the other consequences in this section. ### 7.5 Automatic Responsive Design Layout flows from model annotations, not screen-specific CSS, so the interface adapts to viewport size without per-view breakpoints. The recursive master-detail chain collapses when the viewport narrows, a breadcrumb bar preserves the navigation path, and the same composition scales from desktop to mobile with no per-screen code. Responsive behavior is paid once at the primitive level, not per screen. ### 7.6 Built-in Inspector and Developer Mode Every node carries enough slot metadata to drive its own UI, so the same metadata also drives a generic inspector: a view that exposes a node's slots directly as editable fields, reachable on any tile through a single modifier-click (option-click). Which slots appear is itself an annotation — a per-slot inspectability flag read by the inspector exactly as the persistence layer reads the storage flag and the UI layer reads editability — so a slot can be hidden from the ordinary navigable hierarchy yet still reachable for debugging. A complementary developer-mode toggle reveals subnodes normally hidden from end users, so the same navigation pipeline serves as a debug surface. In a conventional framework, debug tooling means custom inspectors per type and a parallel description of model shape, growing linearly with the model. Here it is a free consequence of the model-to-view pipeline already covering every object, and the inspector is simply one more independent reader of the annotation bridge (§6.2). ### 7.7 Cross-Window and Cross-App Drag-and-Drop Every tile is generated from the same view classes, so drag-and-drop works uniformly across the application in two modes that share one gesture: - A **copy** drag serializes the source node to JSON and delivers it via the declared MIME types. It extends naturally across browser windows, to and from the desktop, and to and from other applications that exchange those types. - A **reference** drag transfers a persistent node UUID, for moving or linking within the application without copying contents. Both modes are type-safe: the receiving side validates against the same slot metadata that drives form validation and AI patches. In a conventional framework, drag interop requires per-class handlers, per-screen serialization formats, and ad-hoc validation on receipt, and the cost scales with the number of draggable objects. Here it is free at the primitive level. (Cross-window reference drags, where a second client resolves the UUID against shared state, are a natural extension but not yet implemented.) #### Architectural affordances (not externally validated) ### 7.8 Accessibility Every interactive surface is generated from the same few primitives, so accessibility is paid once at the primitive level. Focus order, keyboard traversal, drill-in, and back-out belong to tiles and tile stacks. The slot metadata that drives type checking can also generate ARIA roles and constraints. The node hierarchy supplies landmarks and breadcrumb structure. In a conventional framework, accessibility is a per-component obligation that scales with screen count and routinely lapses. Here it cannot lapse selectively: fixing it once fixes it everywhere. We have not validated the result against the full WCAG checklist or with screen-reader users, and report this as an architectural property, not a measured outcome. ### 7.9 Transparent Internationalization All UI text flows from slot annotations through a single rendering pipeline, so translation is injected at the model-to-view boundary with no per-component translation calls or extraction tools. New classes are translatable by default. Centralization also makes AI-powered translation tractable: the framework enumerates translatable strings by walking class prototypes, and slot-level context annotations travel with each string to give the translator domain-appropriate terminology. Adding a language becomes a configuration change, not a translation project. As with accessibility, full multi-language deployment and right-to-left layouts are not yet validated in production; the architectural surface exists. #### Proposed directions (not built) ### 7.10 AI Extensibility Operability moves an agent *within* a fixed space of types. The same architecture suggests an as-yet-unbuilt affordance that would *enlarge* it. Because every layer reads from slot annotations rather than per-type code, an agent could declare a new model class at runtime and have it become a full citizen immediately — navigable, editable, storable, synced, translatable, and itself AI-operable — with no build step. This turns *write the model, get the app* into *the running app writes its own model*. We have not built this; the case study exercises operability over existing types only. It also raises an unsolved problem: minting types lets the agent mint the type contract itself. A safe form would need a **declared, immutable floor** of types and invariants the runtime AI may build on but not alter, with the annotation bridge as the natural seam. §7.11 sketches the security side. ### 7.11 Security If runtime AI-extensibility (§7.10) is built, deriving views from trusted framework code also suggests a security advantage. View code is the least confinable surface in a browser: it touches the DOM and carries origin authority. Model objects do not. An untrusted extension would then supply **data and metadata, never DOM-touching code**, so "extending the UI" becomes "extending the model" — confinable like anything else. The layer naked objects eliminates was not only a maintenance cost but an attack surface. Making this safe would need two primitives we have not built: - **Isolation**: runtime-created code runs in a web worker with no ambient access. - **Authority**: capabilities — an object gets only the references it is granted, which lets the *immutable floor* of §7.10 be expressed as the set of capabilities the runtime declines to grant. Two limits would remain. The protection is only as wide as the derivation reaches; a genuine custom view reopens the hole. And the rendering path becomes a concentrated trust root that must output-encode all model data. Capability discipline is also hard to retrofit. We present this as a clear path, not a solved problem. ## 8. Case Study: undreamedof.ai Strvct has been used to build undreamedof.ai, an AI-powered virtual tabletop for Dungeons & Dragons and other tabletop roleplaying games. The breakdown by subsystem: | Subsystem | Domain classes | Custom views | | --- | ---: | ---: | | Character system | ~30 | 0 | | Campaign system | ~20 | 1 (map) | | Session system | ~25 | 1 (3D dice) | | AI integration | ~15 | 0 | | **Total** | **~90** | **2** | Fewer than 10% of classes required custom view code. The remainder — character sheets, campaign hierarchies, settings panels, administrative interfaces — use auto-generated tiles and master-detail views exclusively. The domain is non-trivial: character sheets nest deeply (character → ability scores → individual scores → modifiers), campaigns contain recursive location trees, and the session system maintains real-time state across multiple connected clients. The default primitives produce navigable, usable interfaces throughout. **Scenario: AI-driven character creation.** A user asks an AI assistant to populate a character sheet. The assistant calls the same patch tools used internally; the same setters validate; the UI updates through the same notification system as direct edits. Adding a new character property requires a single slot declaration. The UI, the AI tool surface, the persistence layer, and the translation enumeration all pick it up without further code. In a component framework, the same change would touch the model, a form component, an AI tool spec, and a serializer. The custom views that remain — a 3D dice roller and a battle map — fall into the category §3 identifies as outside the narrow design space: inherently graphical, domain-specific components that cannot be derived from model annotations. Their existence does not undermine the approach; it confirms that the boundary between auto-generated and bespoke views falls where predicted. **The count is a pipeline-stage metric, not a fixed residue.** The number moved while this work was underway, which is itself informative. The chat interface began as a custom view; it has since been generalized into the framework as reusable message-list and input tiles, dropping the case study from three custom views to two. This reflects a recurring workflow: write a custom view, recognize the general pattern inside it, then promote that pattern into the framework. Chat was always the borderline case — a message list with a header and a footer input is master-detail-plus-footer wearing domain-specific styling — so its absorption is unsurprising in hindsight. The implication should be stated plainly. "Two of ~90" is not a measurement of an essential residue. It is a count of what has not been generalized *yet*, so it depends partly on developer effort and skill, which reinforces the single-developer caveat below. It also makes the narrow-space hypothesis benignly self-fulfilling: as patterns are recognized and promoted, the residue grinds down toward a graphical floor (WebGL, canvas) almost regardless of where the "true" boundary between essential and accidental custom views lies. The honest open question is empirical, and one application cannot answer it: is there a hard floor well above zero — a class of non-graphical surfaces that genuinely resist generalization — or does the residue keep shrinking toward the graphical minimum as effort is applied? The dice roller and the battle map are almost certainly below any such floor. Whether anything non-graphical sits above it remains unknown. This is an existence proof, not a generalization: one application, one primary developer. The claim it supports is feasibility, not optimality. ## 9. Related Work **Naked objects implementations.** Apache Isis (now Apache Causeway) [2] is the most mature naked objects framework, providing automatic UI generation for Java domain models with both a web UI (Wicket viewer) and a REST API. JMatter [4] implemented naked objects for Java Swing. Both use form-and-table UI strategies and target enterprise/administrative use cases. Strvct differs in UI strategy — composable spatial primitives rather than forms and tables — and in target — end-user applications rather than internal tools. **Model-based and automatic UI generation.** A long line of model-based user-interface development (MBUID) generates interfaces from abstract specifications. IFML [5] (Interaction Flow Modeling Language) and UsiXML [6] are representative, deriving concrete interfaces from explicit UI models. These typically require a separate UI model on top of the domain model — the specification that naked objects eliminates by treating the annotated domain model as the only source. More pointed for our hypothesis is the adaptive-generation line, above all SUPPLE [7] (Gajos & Weld), which casts interface generation as a constrained optimization over device, task, and user, and shows that *usable* interfaces, not merely complete ones, can be produced automatically. SUPPLE is the sharpest prior pressure-test of the narrow-design-space claim: it reaches usability through search over a flexible space, whereas we argue that a *small fixed* grammar of spatial primitives already covers the informational design space, making generation a problem of composition rather than optimization. The two are complementary readings of the same evidence — that good interfaces can be derived. Our specific contribution is the claim that the covering vocabulary is small and that uniformity over it is an asset. **Concept design and legible software.** Jackson's *concept design* [8] (*The Essence of Software*) and the recent Meng & Jackson, *What You See Is What It Does* [9], pursue a structure-first, legibility-oriented program adjacent to ours: software organized around a small set of independent, reusable concepts whose behavior is directly inspectable. We share the premise that legibility and consistency follow from constraining structure rather than decorating it; these are the nearest neighbors in the same venue. The difference is the locus of the constraint. Concept design constrains the *behavioral* decomposition of a system into concepts; the narrow-design-space hypothesis constrains the *presentational* vocabulary and derives the interface from it. The two are composable in principle: concept-structured behavior rendered through a derived, uniform presentation. **Miller Columns.** The column-based navigation pattern was introduced in NeXTSTEP and popularized by macOS Finder [3]. It provides spatial continuity when browsing hierarchical data. Its later dominance on small-screen platforms — one column shown at a time, columns pushed and popped on drill-in and back-out — is independent evidence that the grammar is narrow where it is most constrained (§4.4). Strvct extends the pattern by making it recursive (columns nest vertically or horizontally), orientation-flexible (each level chooses its own orientation), and self-composing (the layout follows from model annotations rather than application code). **Component frameworks.** The dominant approach to modern UI development (React, Vue, Svelte) addresses the same cost problem as low-code, but at a different layer: rather than eliminating view code, they make it cheaper to write. Component libraries (shadcn, MUI, Ant Design) cut per-screen effort further with reusable building blocks. But the view tree still exists, must be authored, and must be kept in sync with the model. Adding a property still requires editing a form component, a validator, a serializer, and possibly a translation file. Naked objects, done well, eliminates the view tree as an authored artifact. The view is derived. No component library closes this gap. **Low-code and no-code platforms.** Modern low-code platforms (Retool, Appsmith, OutSystems) aim to reduce UI development cost through visual builders and pre-built components. They approach the same problem as naked objects from the opposite direction: rather than eliminating bespoke UI, they make it faster to produce. The result is still a collection of individually designed screens that must be maintained as the data model evolves. Naked objects eliminates this maintenance cost. **AI-generated UI.** Large language models can now generate UI code from natural-language descriptions. This automates the *creation* of bespoke interfaces but not their *maintenance*. Each generated screen is still a separate artifact that must be updated when the model changes. Naked objects is a fundamentally different approach: rather than automating the production of bespoke UIs, it eliminates the need for them. ## 10. Discussion ### The Crossover Point The crossover is not only between generated and hand-crafted interfaces. It is also between document-oriented and object-oriented information management. A document is excellent when the dominant operation is reading or writing prose. It scales with content length. It scales less naturally with semantic complexity. As a note acquires typed properties, people, tasks, dates, attachments, actions, repeated object types, and relationships, a document system tends to reconstruct an object model through blocks, databases, properties, templates, relations, filters, and rollups. The model-first alternative starts at the other end: ```text Project ├─ overview Rich text ├─ status Enum ├─ owner Person ├─ tasks Kanban or table ├─ milestones Timeline ├─ people Grid or list └─ notes Feed ``` Rich text remains important, but becomes one datatype among many rather than the universal container for an application. At low semantic complexity, a notepad may be superior. At high semantic complexity, explicit objects and relationships scale more cleanly and are easier for both people and agents to inspect and manipulate. There is a parallel engineering crossover. Hand-crafted screens may be economical when there are few of them. As the domain grows, every separately authored representation adds coordination cost and opportunities for drift. A consistent derived interface can eventually become both cheaper to maintain and easier to learn. The undreamedof.ai case study shows coverage at one point on this curve; it does not establish where the crossover occurs for other teams or whether users prefer the result. ### Adoption versus Coverage A coverage result and an adoption result are not the same thing, and the distinction governs how this paper's central claim should be read. Everything in §3 and §8 argues *coverage*: the patterns fit most informational UIs. But the reason naked objects stalled for twenty-five years was never that the patterns failed to fit — prior implementations already produced complete, correct interfaces. The binding constraint is **switch cost**. The pointer analogy (§3) is strong on coverage but misleading on adoption: the mouse carried a near-zero relearning tax, whereas adopting a derived-UI framework means giving up the React ecosystem, the component-library commons, and fine-grained per-screen control. "Most UIs fit the patterns" can be entirely true and still not produce pointer-style adoption, because the quantity being weighed is not coverage but the cost of leaving. **The economic lever.** Agent-mediated development changes the *adoption* arithmetic rather than the *coverage* arithmetic. When an LLM is a routine co-editor of application state, the bespoke-UI path acquires a recurring obligation: it must expose, document, and keep synchronized a tool surface for every mutable type, a cost that grows with the model and decays as the model changes. A derived architecture pays that cost once, structurally, because the tool surface *is* the model (§7.1). The value proposition is therefore not only consistent UI and lower view maintenance, but an application that is natively agent-operable and remains aligned as its domain evolves. A bespoke architecture can achieve the same property only by introducing a shared model-derived interface of its own. The practical adoption question is therefore not whether Strvct can imitate every screen in a mainstream application. It is whether a team gains more by keeping one inspectable model authoritative than it loses by leaving familiar package, component, and tooling ecosystems. Semantic projections improve that exchange because they reduce the amount of ordinary application UI that triggers an escape into custom code. Independent developers and independently chosen applications are still needed to measure it. ### Strengths The approach is strongest where the model itself is the volatile, high-value artifact — where requirements change often and the cost of keeping UI, storage, and synchronization in sync with a shifting model is the main bottleneck. A model change propagates automatically to the UI, persistence, cloud sync, AI integration, and internationalization, so the cycle from "requirement changed" to "working software" is compressed to the time it takes to modify a class definition. Adding a property, restructuring a hierarchy, or introducing a new entity requires no changes to view code, form layouts, serialization logic, or API schemas. This suits exploratory or fast-evolving applications: tools for analysis, research, operations, or any domain where the data model is expected to grow and change throughout the application's life. Headless execution reinforces this: the same model that drives the UI can be tested, simulated, or batch-processed in Node.js with no browser dependency, enabling rapid validation of model changes before they reach users. ### Limitations *Scope.* The approach suits informational and navigational interfaces: browsing, editing, and managing structured data. Inherently graphical interfaces — data visualizations, design canvases, game renderers, timeline editors — need domain-specific rendering and fall outside the auto-generation pipeline. Strvct supports custom view classes for these, but each is a return to the costs the approach was meant to eliminate. *Composition maturity.* Strvct's recursive master-detail grammar is implemented and production-tested, as are two bounded forms of inline placement, anchored tabs and document inlining (§4.6). General inline detail placement, context-resolved child descriptors, cross-sibling alignment, value-to-space mapping, and runtime node-built objects described in §3 and §4 are proposals. Until they exist as framework-level behavior, the coverage gains argued here remain hypotheses rather than results. *Locale.* The spatial conventions we rely on reflect Western reading order. Right-to-left layouts are within the framework's flexbox-based rendering but not validated end-to-end. *Performance.* Lazy view instantiation keeps the initial UI cheap, but very large collections (10⁴+ tiles in one stack) are not stress-tested. The notification-and-sync model is built for graph-shaped UIs with modest fan-out, not stream-shaped UIs with high-volume updates. *Tooling and ecosystem.* The framework forgoes the standard JavaScript module ecosystem for a custom content-addressable resource loader. This enables hash-based caching and the centralized model-to-view pipeline, but cuts the framework off from the React/Vue tooling commons: IDE component support, type-checked component props, hot reload, and the component-library ecosystem. Debugging dynamically evaluated code requires a sourceURL discipline rather than standard source maps. The trade is deliberate but real. *Single-application evidence.* The case study is one application by one primary developer. Whether the approach scales to multi-team development, third-party plugins, or large existing codebases is open. *Server-side compute and concurrency.* Strvct runs entirely client-side, with a local record store and optional versioned cloud commits. This gives excellent offline operation and snappy local interactions, but constrains use cases needing very large datasets or heavy server-side computation. Concurrency control is optimistic and per document: two writers to the same document are detected at commit and the later one reloads; edits are not merged. *External validation.* Accessibility, internationalization, and mobile experience are architecturally supported but have not undergone external audits, large-scale user studies, or production deployment beyond the primary application. ### Future Directions *Extend inline composition beyond documents.* Document inlining (§4.6) already reuses tiles in place with bounded depth and responsive flow; the next steps are per-level orientation and projections that show a node without taking ownership of it. Then add context-resolved child visibility and ordering plus cross-sibling alignment. Test whether trees, grouped lists, kanban boards, tables, and basic spreadsheets emerge from these constraints before adding named widget classes. *Prototype runtime node-built objects.* Define stable message keys and an `activate(args)` protocol for value and method nodes, then adapt them through a message proxy. A spreadsheet is a useful stress case because it exercises dynamic structure, named formulas, computation, inline editing, and drill-down inspection. The execution model must address authority, isolation, caching, dependency tracking, errors, and asynchronous methods before it can safely host user-authored code. *Build value-to-space mapping.* Numeric, temporal, and spatial mappings should be explored over the same collection and slot metadata. The open question is whether charts fit a generalized axis-and-encoding system or require a separate quantitative-visualization family. *Test the projection grammar adversarially.* Take representative screens from CRM, project management, accounting, knowledge management, ecommerce, healthcare, messaging, developer tools, social software, media libraries, calendars, and analytics. Score domain representability, navigation fit, projection fit, and custom code separately. The useful result is not a promotional percentage but the smallest reusable grammar that covers ordinary informational interaction. *Generalize hybrid view composition.* Companion View already demonstrates one bounded form: a model-named node becomes either an isolated generated browser or a specialized view inside the responsive master-detail shell. Future work should generalize that mechanism so charts, editors, canvases, maps, and 3D viewports can participate at other well-defined points in the generated graph without becoming a parallel application architecture. *Server-side execution variants.* Pairing Strvct's headless mode with a server-side coordinator could support workloads that exceed pure-client constraints — large datasets, heavy compute, strict multi-user concurrency — while keeping the same model and annotations as the source of truth. *Independent use and usability studies.* External developers should build nontrivial applications of their own choosing with minimal guidance. Controlled comparisons should measure onboarding time, task completion, navigation errors, maintenance after model changes, accessibility, and the amount and significance—not merely the count—of custom UI. ## 11. Conclusion The naked objects pattern has offered a compelling proposition for twenty-five years: write the domain model, and let the application follow. Its limited adoption does not show that derivation is impossible. It shows that deriving every object into a form and every collection into a table is not enough. The stronger grammar has two operations: traverse relationships through an object graph, and project collections along semantic dimensions. Strvct already implements recursive hierarchy, linear tile collections, and feed-like rich-item sequences through tiles, tile stacks, and master-detail navigation. The next hypothesis is that this same recursion can absorb most remaining structured-information layouts. Inline detail placement, per-level orientation, context-resolved children, and cross-sibling alignment may yield trees, grouped lists, kanban boards, tables, and basic spreadsheets without peer widget classes. Value-to-space mapping remains the clearest separate projection family, with quantitative visualization as an open boundary. Runtime objects built from value and method nodes deepen the claim. A spreadsheet row can be an actual messageable object assembled at runtime; named formula methods can display their results as cells, edit inline, and open automatically into full semantic inspection. If validated, this would unify dynamic schemas, computation, presentation, and navigation without turning cell coordinates into object identity. This formulation gives custom views a principled boundary. They are not an escape hatch for ordinary page layout. They are the right representation when geometry or a specialized medium is itself part of the domain: editors, maps, charts, waveforms, canvases, 3D scenes, and games. The same authoritative model can then drive more than pixels. It can drive persistence, synchronization, schema, inspection, translation context, accessibility behavior, headless tests, and AI tools. This is the central architectural claim: these are not separate features coordinated by convention; they are projections of one explicitly described domain. Strvct's production case study is an existence proof for that architecture, not a general validation of every proposed projection or usability claim. The next evidence must come from external developers, adversarial applications, and measurements that distinguish domain coverage, navigation coverage, viewport coverage, and product value. The economic prediction remains. As AI agents become routine authors and operators of application state, maintaining independent model, UI, persistence, and tool descriptions becomes increasingly fragile. A system whose interface and agent surface are derived from the model pays that coordination cost structurally, once. The durable application architecture will be the one in which the UI is a live projection of the domain, not an authored artifact that merely attempts to mirror it. ## References [1] Pawson, R., & Matthews, R. (2002). *Naked Objects.* Wiley. See also Pawson, R. (2004). *Naked Objects.* PhD Thesis, Trinity College, Dublin. [2] Apache Software Foundation. *Apache Causeway* (formerly Apache Isis). https://causeway.apache.org/ [3] Miller Columns. *Wikipedia.* https://en.wikipedia.org/wiki/Miller_columns (navigation pattern introduced in NeXTSTEP, c. 1989, and popularized by macOS Finder). [4] Arteaga, J. M. *JMatter: A Naked Objects Framework for Java Swing.* http://jmatter.org/ [5] Brambilla, M., & Fraternali, P. (2014). Interaction Flow Modeling Language. In *Proceedings of the 23rd International Conference on World Wide Web (WWW '14 Companion).* ACM. [6] Limbourg, Q., Vanderdonckt, J., Michotte, B., Bouillon, L., & López-Jaquero, V. (2005). UsiXML: A Language Supporting Multi-path Development of User Interfaces. In *Engineering Human Computer Interaction and Interactive Systems (EHCI-DSVIS 2004),* LNCS 3425, Springer. [7] Gajos, K., & Weld, D. S. (2004). SUPPLE: Automatically Generating User Interfaces. In *Proceedings of the 9th International Conference on Intelligent User Interfaces (IUI '04).* ACM. See also Gajos, K. Z., Weld, D. S., & Wobbrock, J. O. (2010). Automatically generating personalized user interfaces with Supple. *Artificial Intelligence,* 174(12–13), 910–950. [8] Jackson, D. (2021). *The Essence of Software: Why Concepts Matter for Great Design.* Princeton University Press. [9] Meng, E., & Jackson, D. (2025). What You See Is What It Does: A Structural Pattern for Legible Software. In *Proceedings of Onward! 2025 (SPLASH).* ACM. ### Works cited by author and year Gentner, D., & Stevens, A. L. (Eds.). (1983). *Mental Models.* Lawrence Erlbaum Associates. Koffka, K. (1935). *Principles of Gestalt Psychology.* Harcourt, Brace & World. Nielsen, J. (1994). Enhancing the Explanatory Power of Usability Heuristics. In *Proceedings of CHI '94.* ACM. See also Nielsen, J. "10 Usability Heuristics for User Interface Design," Nielsen Norman Group. Nielsen, J. (2006). F-Shaped Pattern for Reading Web Content (original eyetracking research). Nielsen Norman Group. https://www.nngroup.com/articles/f-shaped-pattern-reading-web-content-discovered/ Norman, D. A. (1988). *The Design of Everyday Things.* Basic Books. Pernice, K. (2017). F-Shaped Pattern of Reading on the Web: Misunderstood, But Still Relevant (Even on Mobile). Nielsen Norman Group. https://www.nngroup.com/articles/f-shaped-pattern-reading-web-content/ Wertheimer, M. (1923). Untersuchungen zur Lehre von der Gestalt II. *Psychologische Forschung,* 4, 301–350. (Translated as "Laws of Organization in Perceptual Forms.") ### Software and platforms cited React. Meta Open Source. https://react.dev/ — Vue.js. https://vuejs.org/ — Svelte. https://svelte.dev/ shadcn/ui. https://ui.shadcn.com/ — MUI (Material UI). https://mui.com/ — Ant Design. https://ant.design/ Retool. https://retool.com/ — Appsmith. https://www.appsmith.com/ — OutSystems. https://www.outsystems.com/ --- Source: /docs/Nodes/ # Nodes The core domain object abstraction, object graph hierarchy, and subnode management in Strvct. ## Overview Nodes (`SvNode`) are the fundamental domain abstraction in Strvct. Every piece of application state—a document, a user profile, a RPG character sheet, a project folder, or a settings item—is represented as an object inheriting from `SvNode`. Nodes form a **hierarchical object graph**: every node holds an ordered array of child `subnodes` and a reference to its `parentNode`. The framework automatically derives the complete user interface from this object graph without hand-authored UI components. SvNode Subnode tree & parent relationships SvTitledNode Title, subtitle, & path labels SvInspectableNode Property Inspector field generation SvViewableNode View class resolution & tile layout SvStorableNode Persistence & dirty tracking SvSummaryNode Base class for application domain models Each node class level adds an isolated capability. Application domain models typically extend SvSummaryNode or SvStorableNode. --- ## The Node Inheritance Chain | Class Name | Key Capability Added | Usage | |---|---|---| | `SvNode` | Subnode management, parent/owner references | Root base class | | `SvTitledNode` | Title, subtitle, note, ARIA accessibility, navigation path | Labeled nodes | | `SvTranslatableNode` | Per-node translation string cache for i18n | Internationalization | | `SvInspectableNode` | Property Inspector field generation from slot metadata | Live debugging | | `SvViewableNode` | View class selection, layout orientation, tile settings | Visual UI presentation | | `SvStyledNode` | Theme class name resolution | Programmatic styling | | `SvStorableNode` | Persistence dirty tracking & IndexedDB serialization | Persistent models | | `SvSummaryNode` | Configurable summary tile formatting | Standard app model base | --- ## Subnode Operations The primary structural relationship in Strvct is the parent-child node tree managed via `subnodes()`: ```javascript // Adding subnodes parentNode.addSubnode(childNode); parentNode.addSubnodeAt(childNode, 0); // Querying subnodes parentNode.subnodeCount(); parentNode.subnodeAt(index); parentNode.hasSubnode(childNode); // Removing subnodes parentNode.removeSubnode(childNode); // Reordering subnodes parentNode.moveSubnodesToIndex([nodeA, nodeB], 2); ``` When `addSubnode()` or `removeSubnode()` is called, the node automatically posts a change notification (`"didChangeSubnodes"`), causing active views (`SvNavView`, `SvTilesView`) to update smoothly without manual page refreshes. --- ## Related Guides - [Slots](../Slots/index.html): Complete guide to property slots and metadata. - [Technical Overview](../Technical%20Overview/index.html): High-level system architecture. --- Source: /docs/Notifications/ # Notifications Event-driven communication between framework layers using observations, scheduling, and weak references. STRVCT's notification system provides loose coupling between the model, view, and storage layers. Rather than holding direct references to each other, objects communicate through three complementary mechanisms: a deferred, deduplicated notification center for broadcast events; a sync scheduler that coalesces direct method calls; and a lightweight broadcaster for synchronous dispatch. All three use weak references for automatic cleanup — when an observer or sender is garbage collected, its registrations are removed without manual intervention. These are separate because they optimize for different tradeoffs. The notification center is loosely coupled — the sender doesn't know who's listening — but that generality has overhead: queuing, indexing, pattern matching. View synchronization doesn't need any of that; it needs a specific method on a specific object to run exactly once, which is what the sync scheduler provides directly. And some internal events (like storage-layer slot propagation) need synchronous delivery with no deferral at all, which is the broadcaster's role. A single mechanism couldn't serve all three without either over-engineering the simple cases or under-serving the complex ones. **Processing order within an event loop:** Application code runs first — any slot changes during this phase trigger slot change hooks immediately, and any Broadcaster dispatches also execute synchronously inline. Meanwhile, notifications and sync requests are queued, not executed. At the end of the event loop, the SyncScheduler processes its queue in priority order: view-to-model syncs (priority 0) run first, then notification dispatch (which delivers queued NotificationCenter events to observers), then model-to-view syncs (priority 2). Finally, the persistence layer auto-commits all dirty objects to IndexedDB. This ordering guarantees that user edits land before reactive updates, and that storage always sees the final settled state. text { font-family: 'Inter', system-ui, -apple-system, sans-serif; font-size: 12px; fill: #111; } .b { font-weight: 600; } .dim { fill: #666; } .box { fill: none; stroke: #111; stroke-width: 1; } .fill { fill: #f0ede5; stroke: #111; stroke-width: 1; } .flow { stroke: #111; stroke-width: 1; fill: none; } During application code events fire inline; deferred queues fill but don't drain Slot Change Hooks fires on setter Broadcaster synchronous broadcast NotificationCenter events queued SyncScheduler requests queued - end of event loop End of event loop queues drain in priority order 1. SyncScheduler: view → model priority 0 2. NotificationCenter: dispatch queued events priority 1 3. SyncScheduler: model → view priority 2 - Persistence auto-commit: dirty objects → IndexedDB - Notification Center - Sync Scheduler - Broadcaster - Slot Change Hooks --- Source: /docs/Notifications/Broadcaster/ # Broadcaster Immediate, synchronous event broadcasting across object trees in `SvBroadcaster`. ## Overview While `SvNotificationCenter` handles loose asynchronous change observations and `SvSyncScheduler` handles event-loop deferred rendering passes, **`SvBroadcaster`** handles **immediate, synchronous event broadcasts** down or up object subtrees. Root Node / View Invokes broadcast() SvBroadcaster Synchronous tree traversal Subtree Nodes Immediate method execution Used for high-priority synchronous signals like window resizing, theme switching, or modal dismissals. --- ## Related Guides - [Notification Center](../Notification%20Center/index.html): Weak observer event dispatch. - [Sync Scheduler](../Sync%20Scheduler/index.html): Coalesced event loop scheduling. --- Source: /docs/Notifications/Notification%20Center/ # Notification Center Asynchronous event dispatching, dual WeakMap observation indexing, and decoupled change propagation in `SvNotificationCenter`. ## Overview In a framework where model, view, and storage layers must stay independent, objects announce state changes without holding direct references to observers. Direct method calls create tight coupling—the sender must hold a reference to every observer, and adding a new listener requires modifying sender code. `SvNotificationCenter` solves this: senders post named notifications into a shared center, observers register interest by name and sender, and the two sides never reference each other directly. Sender Objects (SvNode) this.postNoteNamed("didChange") newNote().setInfo({...}).post() SvNotificationCenter _senderToObservations WeakMap index for O(1) lookup _nameToObservations WeakMap index by name Observer Objects (SvNodeView) View A: didChange(note) View B: customHandler(note) WeakRef observer storage prevents retain cycles; unmounted views are reclaimed automatically without manual unwatching. --- ## Posting Notifications Senders post notifications when their state mutates: ```javascript // Convenience method on SvNode: this.postNoteNamed("didUpdateNode"); // Advanced notification with info dictionary: SvNotificationCenter.shared().newNote() .setSender(this) .setName("didUpdateNode") .setInfo({ fieldName: "title", oldValue: "Draft", newValue: "Final" }) .post(); ``` --- ## Observing Notifications & Convention Handlers Objects register observations using `newObservation()`: ```javascript // Register observation SvNotificationCenter.shared().newObservation() .setSender(targetNode) .setName("didUpdateNode") .setObserver(this) .startWatching(); ``` ### Handler Method Resolution: - **Default Convention:** When `targetNode` posts `"didUpdateNode"`, the notification center automatically calls `this.didUpdateNode(note)` on the observer if defined. - **Explicit Override:** To direct dispatch to a different method name, call `setSendName()`: ```javascript obs.setSendName("handleNodeUpdate"); ``` --- ## Dual WeakMap Indexing & Memory Safety To minimize dispatch overhead as domain graphs grow, `SvNotificationCenter` maintains two internal index maps: 1. `_senderToObservations`: A `WeakMap` mapping senders to their registered observations. 2. `_nameToObservations`: A `WeakMap` mapping notification names to observations. During a post operation, the notification center intersects the two maps to retrieve target observations in $O(\text{observations on sender})$ time, avoiding full-table scans. ### Memory Leak Protection: Observers are held in **`WeakRef`** wrappers. When an observing view is removed from the DOM and has no remaining strong references, JavaScript's garbage collector automatically reclaims it. Dead observations are cleaned up during dispatch passes without throwing errors. --- ## Related Guides - [Sync Scheduler](../Sync%20Scheduler/index.html): Coalescing high-frequency notification dispatches. - [Broadcaster](../Broadcaster/index.html): Synchronous inline event broadcasting. - [Slot Change Hooks](../Slot%20Change%20Hooks/index.html): Declarative model change hooks. --- Source: /docs/Notifications/Slot%20Change%20Hooks/ # Slot Change Hooks Declarative lifecycle hooks invoked automatically during slot mutation. ## Overview When an auto-generated slot setter runs (e.g. `setName("Thorin")`), it checks for optional convention-based hook methods on the owning object before and after mutating internal state: ```javascript (class Character extends SvStorableNode { initPrototypeSlots () { { const slot = this.newSlot("level", 1); slot.setSlotType("Number"); slot.setSyncsToView(true); } } // Optional hook called BEFORE value is mutated willUpdateSlotLevel (oldValue, newValue) { console.log("Level changing from", oldValue, "to", newValue); } // Optional hook called AFTER value is mutated didUpdateSlotLevel (oldValue, newValue) { this.recalculateHitPoints(); } }.initThisClass()); ``` --- ## Hook Lifecycle Sequence 1. **Setter Invoked:** `setName(newValue)` 2. **`willUpdateSlotName(oldVal, newVal)`:** Called if defined on the object. 3. **Value Assignment:** Internal private variable `_name` is updated. 4. **`didUpdateSlotName(oldVal, newVal)`:** Called if defined on the object. 5. **Mutation Notification:** If `setSyncsToView(true)` is set, posts `"didChangeSlot"` notification via `SvNotificationCenter`. --- ## Related Guides - [Slots](../../Slots/index.html): Complete guide to slot metadata and declarations. - [Notification Center](../Notification%20Center/index.html): Weak observer event dispatch. --- Source: /docs/Notifications/Sync%20Scheduler/ # Sync Scheduler Coalescing, deduplication, and event-loop-deferred method execution in `SvSyncScheduler`. ## Overview When multiple property slots mutate rapidly within a single user gesture (or batch data load), triggering a full UI re-render pass for every individual setter call would cause severe performance degradation and layout thrashing. `SvSyncScheduler` solves this by **coalescing and deduplicating** target and method calls within the browser event loop: N Rapid Slot Mutations Schedules syncFromNode() SvSyncScheduler Deduplicates target/method End of Event Loop Executes 1 single UI pass 100 slot property mutations in 1 frame trigger exactly 1 UI render pass at the end of the loop. --- ## Usage Pattern Views and persistent objects register deferred sync requests with `SvSyncScheduler`: ```javascript // Schedule a deferred method execution SvSyncScheduler.shared().scheduleTargetAndMethod(view, "syncFromNode"); ``` Regardless of how many times `scheduleTargetAndMethod(view, "syncFromNode")` is invoked during the current event loop, `view.syncFromNode()` executes **exactly once** when the scheduler flushes. --- ## Related Guides - [Notification Center](../Notification%20Center/index.html): Asynchronous weak observation dispatch. - [Broadcaster](../Broadcaster/index.html): Synchronous event broadcasting. --- Source: /docs/Persistence/ # Persistence Local storage, cloud sync, and blob management for object graphs. Three tiers: the in-memory model, local storage (a record store holding every object pool's rows, plus a content-addressable blob pool), and the cloud, which holds the same rows one record per row, with a version per pool. Each document is its own pool; a folder's contents are the documents whose root rows are placed under it. Mutations are stored locally at the end of each event loop and committed to the cloud asynchronously, as the records changed since the pool's last acknowledged version. text { font-family: 'Inter', system-ui, -apple-system, sans-serif; font-size: 12px; fill: #111; } .b { font-weight: 600; } .dim { fill: #666; } .box { fill: none; stroke: #111; stroke-width: 1; } .fill { fill: #f0ede5; stroke: #111; stroke-width: 1; } .flow { stroke: #111; stroke-width: 1; fill: none; } Model SvNode graph in memory - - mutate load Local Storage Record Store rows by pool + puuid Blob Pool content-addressable - - commit fetch Cloud Storage Scopes owners, members Records rows, version per pool Cloud Blob Storage blob records Mutations are stored locally at once and committed to the cloud asynchronously; GC collects orphan blobs at both tiers. - Local Object Pools - Cloud Object Pools - Local and Cloud Blob Storage --- Source: /docs/Persistence/Cloud%20Object%20Pools/ # Cloud Object Pools Cloud persistence for object pools: one record per row, a version per pool, and an atomic commit protocol. ## Overview Every cloud document—a game session, a character sheet, a campaign catalog—is an **Object Pool**: a cyclic graph of records reachable from a single root record (`objectId == poolId`). Locally, pool rows live in `SvLocalRecordStore` (IndexedDB). In the cloud, the **exact same rows** live in a cloud records collection (`SvCloudRecordStore`). There is no second format: a single mapper converts objects to rows on both sides, making cloud sync a simple operation of reading rows from one store and writing them into the other. Browser Client SvObjectPool Live object graph in memory SvLocalRecordStore IndexedDB row cache Root row mirrors last acknowledged cloud version SvCloudRecordStore Read Operations open · changes · children asyncScopeRootRows Commit Operation baseVersion → version Idempotent requestId check Cloud Backend (Firestore/DB) records Collection One cloud doc per record row Root row holds pool version blobs/<sha256> Content-addressed storage Lazy fetch on render ### The Cloud Model in Five Sentences: 1. **Root Row Identity:** A pool's ID is its root object's `puuid` (`objectId == poolId`). 2. **Server-Owned State:** The root row—and only the root row—carries server-owned columns: `version`, `state`, `parentId`, `orderKey`, and `owner`. 3. **Zero-List Folder Pools:** Folders are pools whose rows list placed children via root `parentId` references without storing explicit child lists. 4. **Far References (`{ "**": poolId }`):** The only way to point across pool boundaries. Following a far reference is asynchronous. 5. **Atomic Commit Protocol:** Edits reach the cloud through a single commit protocol that compares base versions and applies row deltas atomically. --- ## Scoped Pool Identifiers (`scopedPoolId`) In the cloud, a pool is identified by its scoped ID: ``` : ``` - **`scopeId`:** The sharing boundary (e.g., user account ID, multiplayer room ID, public catalog ID). - **`localPoolId`:** The root object's `puuid` string. Scoped pool IDs ensure that two accounts cloning the same template document never collide in cloud storage. --- ## Record Row Columns (`SvRecordRow`) | Column | Root Row (`objectId == poolId`) | Child Row (`objectId != poolId`) | Written By | |---|---|---|---| | `poolId` | The root object's `puuid` (identifies the pool) | The enclosing pool's `poolId` | Client | | `objectId` | The root object's `puuid` (`objectId == poolId`) | The child object's own distinct `puuid` (`objectId != poolId`) | Client | | `parentId`, `orderKey` | Folder ID & fractional sort key | Sort key for windowed collections | Client | | `payloadJson` | Root object's slot record | Child object's slot record | Client (commit payload) | | `version` | Monotonic content sequence number | — | Server (mirrored down) | | `modifiedVersion`, `isDeleted` | Version that last updated row | Last modified version; tombstone flag | Server (mirrored down) | | `scopeId`, `state`, `owner` | Sharing boundary & lifecycle state | `scopeId` only | Server | > **Identity Rule:** For the **Root Row**, `objectId` is identical to `poolId` (`objectId == poolId`), identifying the entire document pool and carrying server-owned metadata (`version`, `state`, `owner`). For **Child Rows**, `objectId` is the child object's own unique `puuid`, while `poolId` identifies the parent pool it belongs to (`objectId != poolId`). ### Local-Only Slots: A stored slot can be kept exclusively on the device: `slot.setIsInCloudRecord(false)` keeps it in the local IndexedDB record row but strips it when generating cloud commit payloads (`SvObjectPool.cloudPayloadFor`). Local view settings, scroll positions, and device sync timestamps use this mechanism to prevent triggering unnecessary cloud commits. --- ## The Record Store Protocol (`SvRecordStoreProtocol`) Every backing implementation conforms to `SvRecordStoreProtocol`: | Method | Answers / Action | |---|---| | `asyncOpen(poolId)` | `{ root, records, version, state }` — the entire pool, or `null`. | | `asyncReadChanges(poolId, sinceVersion)` | `{ rows, tombstones, version, reloadRequired }` — modified rows since version. | | `asyncChildren(nodeId, range)` | Rows placed under `nodeId` ordered by `(orderKey, objectId)`. | | `asyncResolveFar(poolId)` | Opens the pool a far reference points to. | | `asyncCommit({ poolId, baseVersion, requestId, writes, deletes })` | Atomic commit: returns `{ status: "committed", version }`, `"conflict"`, or `"refused"`. | ### Backing Implementations: - **`SvLocalRecordStore`:** The device's IndexedDB store holding every local pool row. Accepts `asyncPut` / `asyncDelete`. - **`SvMemoryRecordStore`:** Reference implementation of both sides (including commit protocol) used for headless testing and in-memory cloud caches. - **`SvCloudRecordStore`:** The cloud backing executing `callFunction(name, args)` over HTTPS. Refuses direct writes; modified only via `asyncCommit`. --- ## Reading a Pool (Opening Decision Tree) When opening a document, Strvct uses an optimized decision tree to minimize network bandwidth: ``` [ User Opens Document ] | v Has Local In-Sync Version? (inSyncVersionOfPool) / \ YES / \ NO v v asyncReadChanges(sinceVersion) asyncOpen(poolId) / \ (Fetch Whole Pool) Normal / \ reloadRequired=true v v Import Deltas Replace Local Copy (0 to 1 row download) (Cloud Wins) ``` 1. **In-Sync Version Check:** The opener queries `SvLocalRecordStore.inSyncVersionOfPool(poolId)`. If a local copy exists with no unsent local edits, it calls `asyncReadChanges(cloudPoolId, version)`. For returning users, this transfers **0 to 1 rows** instead of re-downloading the entire document. 2. **Whole-Pool Download:** If no local version exists, it calls `asyncOpen(poolId)` and imports the full pool (`asyncImportOpenedPool`). 3. **`reloadRequired` Handling:** If the server has pruned tombstones since `sinceVersion`, it returns `reloadRequired: true`, falling back to a full pool download. 4. **Atomic Snapshot Reading:** Readers accept only rows stamped at or below the root's `version`, ensuring a commit currently being written is never seen half-finished. --- ## Writing & Commit Protocol Edits are saved locally first at the end of the event loop. Sending them to the cloud is a separate, debounced step: `SvObjectPool.asyncCommitToCloud()`: 1. **Flush Local Writes:** Flushes pending local IndexedDB writes and computes changed rows since the last acknowledged cloud snapshot (`cloudChanges()`). 2. **Post Commit Request:** Sends modified rows with the local root's `version` as `baseVersion` and a unique `requestId`. 3. **Idempotent Receipts:** The server records the `requestId`. If a network interruption causes the client to retry the request, the server returns the saved receipt without double-incrementing the pool version. 4. **Optimistic Concurrency Control:** - **`committed`**: The server's new `version` is stamped on local rows, and the snapshot advances. - **`conflict`**: Another client committed first. The caller invokes `holdsCommitContent(commit)` to check if its edits were included before reloading remote changes (`cloud wins`). - **`refused`**: The commit violated a rule (e.g. attempting to edit server-owned columns). --- ## Staged Commits (`SvStagedRecordCommit`) For commits exceeding transaction limits (`maxOpsPerCommit()` 450 operations or 4 MB of payload), `SvStagedRecordCommit` stages the write: 1. **Begin:** Reserves the next pool version via a compare-and-set operation. 2. **Batch Writes:** Pushes row updates in sequential batches. 3. **Finalize:** Commits the root row, version, and request receipt in a final transaction. While a stage is open, the pool answers **busy** to other readers/writers, and `SvCloudRecordStore` retries automatically (`busyRetryDelays`). If a stage is abandoned mid-way, the next access to the pool rolls back incomplete batches from saved pre-images. --- ## Zero-List Folder Membership (`SvCloudFolder`) Folders (`SvCloudFolder`) declare `setSubnodesArePools(true)`. A folder **never stores a list of child IDs**: - **Placement:** A document is in a folder because the document's root row sets its `parentId` to the folder's ID. - **Scope Root Listings:** A folder queries scope root rows via `asyncScopeRootRows(scopeId)`. Each root row contains enough metadata (title, subtitle, thumbnail hash) to render placeholder tiles without opening child pool bodies. - **Pruning & Tombstones:** If a complete scope listing omits a child, the local child is pruned. Deleting a child queues a tombstone descriptor (`pendingCloudDeletes`) that survives reloads until confirmed by the server. --- ## Far References (`{ "**": poolId }`) A pointer across pool boundaries is stored as `{ "**": poolId }`, naming the target pool root rather than an individual object. It keeps nothing alive and grants no permissions: resolving it opens the target pool under the target's own permissions. A dangling far reference is a normal state to display in the UI rather than an error. --- ## Key Persistence Classes Matrix | Class | Purpose | |---|---| | `SvObjectPool` | Manages live objects for a document; handles `asyncCommitToCloud` & `cloudChanges`. | | `SvLocalRecordStore` | Manages local IndexedDB rows (`inSyncVersionOfPool`, `asyncImportOpenedPool`). | | `SvCloudRecordStore` | Manages cloud record reads, commits, staged commits, and scope root listings. | | `SvMemoryRecordStore` | Reference implementation of the record store protocol for headless tests. | | `SvStagedRecordCommit` | Drives multi-batch commits for large payload transactions. | | `SvRecordRow` | Defines the serialized row shape and column constraints. | | `SvCloudFolder` | Manages document collections via root `parentId` references and scope listings. | | `SvOrderKey` | Generates fractional sort keys for document order in collections. | --- ## Related Guides - [Local Object Pools](../Local%20Object%20Pools/index.html): Local IndexedDB persistence engine. - [Local and Cloud Blob Storage](../Local%20and%20Cloud%20Blob%20Storage/index.html): Content-addressable binary asset storage. - [Technical Overview](../../Technical%20Overview/index.html): High-level system architecture. --- Source: /docs/Persistence/Local%20and%20Cloud%20Blob%20Storage/ # Local and Cloud Blob Storage SHA-256 content-addressable binary asset storage for images, audio, video, and files. ## Overview While domain object properties are serialized into standard JSON record rows, large binary assets (images, audio files, PDFs) are managed by `SvBlobPool`. Binary assets are stored using **Content-Addressable Storage (CAS)**: - The key for any binary blob is its **SHA-256 hash digest** string. - Object slots store hash reference strings (e.g., `"hash:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"`) rather than inline base64 data. - Duplicate uploads of identical binary files automatically resolve to the same SHA-256 key, providing zero-effort binary deduplication. Binary Asset / Upload Image, audio, or PDF file SHA-256 Hash Digest Computes content key SvBlobPool / Cache IndexedDB & Cloud Store Domain node slots store only SHA-256 hash strings; binary content is fetched asynchronously on demand. --- ## Local & Cloud Sync Flow 1. **Local Writes:** When a binary file is added, `SvBlobPool` computes its SHA-256 hash asynchronously and stores the ArrayBuffer in a dedicated IndexedDB blob store. 2. **Lazy Cloud Fetching:** When rendering an image or playing an audio file, `SvBlobPool` checks local IndexedDB first. If missing, it fetches the raw binary from the cloud blob store using its SHA-256 key and caches it locally. 3. **Automatic Deduplication:** Two different domain nodes referencing the exact same image share a single binary record in storage. --- ## Related Guides - [Local Object Pools](../Local%20Object%20Pools/index.html): Domain object graph persistence. - [Cloud Object Pools](../Cloud%20Object%20Pools/index.html): Cloud record synchronization. --- Source: /docs/Persistence/Local%20Object%20Pools/ # Local Object Pools IndexedDB-backed persistence for domain object graphs using dirty tracking, the local record store (`SvLocalRecordStore`), and atomic event-loop commits. ## Overview Strvct's persistence engine is **local-first**: application state is stored directly in the browser's IndexedDB (or LevelDB under Node.js). Rather than requiring developers to write explicit SQL/ORM queries or API save calls, the framework monitors slot mutations automatically, serializes dirty domain objects into **Record Rows** (`SvRecordRow`), and commits them to IndexedDB at the end of each browser event loop. Domain Node Graph (SvNode) SvStorableNode Slot setters trigger didUpdateSlot & mark object dirty SvObjectPool In-memory dirty cache; serializes dirty nodes to SvRecordRow SvLocalRecordStore Row database holding all pool records (objectId == poolId) SvPersistentAtomicMap & SvIndexedDbFolder Synchronous Map cache; batched writes on commit IndexedDB (Browser) / LevelDB (Node.js Headless) --- ## Opting Into Persistence Domain classes opt into local persistence by extending `SvStorableNode` and configuring storage flags: ```javascript (class Task extends SvStorableNode { initPrototypeSlots () { { const slot = this.newSlot("title", ""); slot.setSlotType("String"); slot.setShouldStoreSlot(true); // Marks slot value for serialization } { const slot = this.newSlot("score", 0); slot.setSlotType("Number"); slot.setShouldStoreSlot(true); } { const slot = this.newSlot("transientCache", null); // Not stored — recomputed at runtime } } initPrototype () { this.setShouldStore(true); // Enables persistence for this node this.setShouldStoreSubnodes(true); // Persists child subnodes array } }.initThisClass()); ``` ### Storage Flags Breakdown: - **`setShouldStore(true)`**: Called in `initPrototype()`. Enables persistence for instances of the node. - **`setShouldStoreSlot(true)`**: Called in `initPrototypeSlots()`. Includes individual slot values in serialized JSON record rows. - **`setShouldStoreSubnodes(true)`**: Persists the node's `subnodes` array. When false, subnodes are re-created dynamically on load (typically via `setFinalInitProto()` on `setIsSubnodeField(true)` slots). --- ## Inheritance Chain Storage capabilities begin at `SvStorableNode` in the core node hierarchy: ``` SvNode -> SvTitledNode -> SvInspectableNode -> SvViewableNode -> SvStyledNode -> SvStorableNode ``` Classes above `SvStorableNode` cannot be persisted. Application domain models extend `SvStorableNode` or `SvSummaryNode`. --- ## Persistent Unique IDs (`puuid`) Every stored object has a **puuid**—a 10-character random string generated via `crypto.getRandomValues()` and stored as `_puuid`. Puuids serve two key roles: 1. **Record Row Key:** Combined with `poolId`, the `puuid` forms the object ID key in storage (`objectId`). For pool root objects, `objectId == poolId`. 2. **Object Pointers:** - **Near References (`{ "*": "puuid" }`):** References between objects within the same pool store local `puuid` pointers. - **Far References (`{ "**": "poolId" }`):** Pointers across pool boundaries store external pool IDs. --- ## Record Serialization & Local-Only Slots Domain objects serialize to JSON record rows via `recordForStore(aStore)`: ```json { "type": "Task", "entries": [ ["title", "Buy Groceries"], ["score", 10], ["assignee", { "*": "u-99120" }] ] } ``` ### Local-Only Slots (`slot.setIsInCloudRecord(false)`): A slot can be kept on the local device without being included in cloud sync commits: ```javascript slot.setIsInCloudRecord(false); ``` Local-only slots are saved into local IndexedDB rows but stripped when generating cloud commit payloads (`SvObjectPool.cloudPayloadFor`). Local view states, scroll offsets, and sync timers use local-only slots. --- ## Mutation Tracking & Batched Commits 1. **Setter Invoked:** Setting a slot value calls `didUpdateSlot()`. 2. **Dirty Registration:** `didUpdateSlot()` calls `didMutate()`, notifying the `SvObjectPool` via a mutation observer. 3. **Coalesced Commit Pass:** `SvObjectPool` adds the object to its dirty set and schedules a deferred commit pass with `SvSyncScheduler`. 4. **Atomic Transaction:** At the end of the browser event loop, `commitStoreDirtyObjects()` serializes all dirty objects and writes them to IndexedDB in a single atomic transaction. --- ## `SvPersistentAtomicMap` & Multi-Backend Abstraction `SvPersistentAtomicMap` wraps `SvIndexedDbFolder` with a synchronous in-memory `Map` cache: - **Synchronous Reads:** Reads are served instantly from the in-memory cache without async IndexedDB latency. - **Batched Writes:** Writes modify the in-memory write cache and are flushed to disk in atomic transactions during commit passes. - **Environment Abstraction (`SvIndexedDbFolder`):** Uses native IndexedDB in the browser and LevelDB (`classic-level`) in Node.js, providing identical storage behavior for headless testing and browser execution. --- ## Opening Pools & Class Migrations (`ClassRenames.json`) The application opens local object pools at boot: ```javascript const pool = SvPersistentObjectPool.sharedPool(); await pool.promiseOpen(); const root = await pool.rootOrIfAbsentFromClosure(() => { return TaskRootNode.clone(); }); ``` ### Class Migrations: When refactoring domain class names in code, existing stored records contain the old class name. Strvct maps old class names to new constructors via `ClassRenames.json`: ```json { "OldTaskNode": "Task" } ``` --- ## Related Guides - [Cloud Object Pools](../Cloud%20Object%20Pools/index.html): Versioned cloud record store synchronization and commits. - [Local and Cloud Blob Storage](../Local%20and%20Cloud%20Blob%20Storage/index.html): Content-addressable binary asset storage. - [Technical Overview](../../Technical%20Overview/index.html): High-level architecture and local-first triad. --- Source: /docs/Plans/ # Plans Design ideas, architectural directions, and planned improvements, with a meta plan for the order to do them in. ## Order - Meta Plan ## Next - Naked Objects Issues - Cleanup Notes - Promise-Wrapped Slots - Capabilities & Permissions - JSON Schema - Browser Cleanup ## Later - Tile Container Views - Tile Views - Accessibility Testing & Tuning - Case Studies ## Ideas & Directions - Emergent Capabilities - Async Navigation - Graph Database ## Done or Closed - Complete Protocols - Lazy Slots - Async Final Initialization --- Source: /docs/Plans/Accessibility%20Testing%20%26%20Tuning/ # Accessibility Testing & Tuning Validating and refining the framework's ARIA implementation across screen readers, devices, and applications. **Status:** ongoing. **Order:** the automated regression checks (last section) first, since they keep what exists from slipping; the manual screen-reader passes after [Browser Cleanup](../Browser%20Cleanup/) and [Tile Container Views](../Tile%20Container%20Views/), so they test the navigation and containers that will stay. The navigation announcements need Browser Cleanup's single navigation entry point, which knows whether the user or the program navigated. ## Overview The core accessibility infrastructure is in place -- ARIA roles, labels, states, landmarks, live regions, focus indicators, and slot-to-ARIA metadata wiring are all implemented in the framework's view classes (see [Accessibility](../../Accessibility/) documentation). What remains is testing that implementation against real assistive technology and tuning behavior for edge cases that only surface during actual screen reader use. ## VoiceOver Testing macOS VoiceOver is the primary testing target since it's built into the development platform. - Walk through a representative application with VoiceOver enabled (Cmd+F5) - Verify that tile navigation announces tile content (`aria-label` from `title()`) - Verify that field tiles announce their role, label, and current value - Verify that boolean fields announce as checkboxes with checked state - Verify that action fields announce as buttons with enabled/disabled state - Verify that option lists announce as listbox with selected option - Verify that breadcrumbs announce as navigation with current location - Verify that `aria-live` regions announce new content (chat messages, status updates) - Verify that landmark roles provide useful navigation shortcuts (VO+U landmarks menu) ## Tab Key / Screen Reader Interaction The framework overrides native Tab behavior with a custom `nextKeyView` chain. This may conflict with screen reader conventions. - Test whether VoiceOver's Tab navigation (VO+Tab) works correctly with `tabindex=-1` tiles - Determine if the `nextKeyView` chain needs to be suspended when a screen reader is detected - Investigate `aria-activedescendant` as an alternative to physical focus movement for tile navigation - Verify that form fields within tiles receive focus correctly when Tab is pressed ## Navigation Announcement Mechanism The policy is established: announce programmatic navigation, stay silent on user-initiated navigation. The mechanism needs implementation. - Investigate whether tile-selection navigation and programmatic navigation go through different code paths in `SvStackView` / `SvNavView` - Determine how to detect "this focus change was not a direct response to a tile selection" - Implement `aria-live` announcements for programmatic navigation (e.g., "Start Session" navigating to Narration view) - Test that user-initiated drill-in/drill-out does not produce redundant announcements ## Cross-Screen-Reader Testing Different screen readers have different behaviors and ARIA support levels. - **NVDA on Windows** -- the most popular free screen reader; test with Firefox and Chrome - **JAWS on Windows** -- the most widely used commercial screen reader - **TalkBack on Android** -- test with Chrome on Android - Verify that ARIA roles, states, and properties work consistently across readers - Document any reader-specific workarounds needed ## Per-Application Adjustments The framework provides good defaults, but some content needs application-level attention. - **Alternative text for images** -- the framework can't infer what a picture shows; applications must provide `alt` text for meaningful images - **Custom views** -- any view that overrides default rendering may need custom ARIA attributes - **Domain-specific labels** -- where auto-generated slot descriptions aren't clear enough, applications should override `title()` or provide `aria-label` overrides - **Complex widgets** -- application-specific composite widgets (e.g., dice rollers, map views) need manual ARIA patterns ## Color Contrast Verification The default dark theme has been reviewed for WCAG 4.5:1 contrast compliance. Remaining work: - Run automated contrast checks (axe, Lighthouse) against a running application - Verify contrast ratios for all interactive states (hover, focus, disabled, selected) - Check contrast in light theme variants if applicable - Verify that `prefers-contrast: more` media query produces sufficient enhancement - Ensure information is not conveyed by color alone -- use shape, text, or pattern as reinforcement ## Text Resize Testing WCAG 1.4.4 requires content to be usable at 200% text size. - Test with browser zoom at 200% - Verify that content reflows correctly at 320px equivalent viewport width (WCAG 1.4.10) - Check that no content is clipped or overlapping at increased text sizes - Verify that STRVCT's flexbox-based layout accommodates text expansion gracefully ## Focus Management Refinements - **Focus trapping in modals** -- when a modal dialog is open, Tab should cycle within the dialog - **Focus restoration** -- drilling out should restore focus to the tile that was drilled into - **Skip links** -- provide a way to skip past repetitive navigation to main content - Verify that focus is visible and meets WCAG 2.2 contrast requirements (3:1 against adjacent colors) in all themes ## Automated Regression Testing - Evaluate integrating axe-core or similar into the test suite for automated ARIA validation - Consider adding Playwright accessibility assertions for critical navigation paths - Set up CI checks that flag new accessibility regressions --- Source: /docs/Plans/Async%20Final%20Initialization/ # Async Final Initialization Adding an async phase to the object initialization lifecycle. **Status:** not planned (2026-11-13). Its main case, stubs that need data before they can display, was solved first by manifest metadata and then by [Lazy Slots](../Lazy%20Slots/), which load synchronously. Reopen it if a second real case appears that neither covers. The page is kept for the analysis. ## Context When objects need async data during initialization (e.g., fetching from cloud storage, API calls), the current synchronous initialization flow (`init()` → `finalInit()` → `afterInit()`) doesn't accommodate this cleanly. ## The Idea Add an `asyncFinalInit()` phase that runs after synchronous initialization but before the object is considered "fully ready." ## Potential Benefits - Clean architectural pattern — async initialization gets its own explicit phase - Objects have a clear "fully ready" state - Generalizes to many async initialization scenarios - Could handle lazy-loaded cloud data, API-dependent initialization, etc. ## Challenges to Solve ### Initialization State Tracking - Objects need an `isFullyInitialized` flag - Anything accessing them needs to check or wait for completion - Views need to handle "initializing" state gracefully (loading indicators, disabled interactions) ### Cascading Dependencies - If object A's `asyncFinalInit` depends on object B's `asyncFinalInit`, ordering becomes complex - Need dependency resolution or explicit waiting mechanisms - Risk of deadlocks if dependencies are circular ### Validation Timing - Current validation runs synchronously and may depend on async data - Options to consider: - Defer all validation until after `asyncFinalInit` - Add a `validationReady` state that skips validation when false - Make validation itself async-aware - Example: Options dropdown validation needs character names, but characters are lazy-loaded stubs ### Persistence Edge Cases - What happens if object is accessed/modified before `asyncFinalInit` completes? - Should writes be queued? Rejected? Merged later? - How does this interact with the dirty tracking system? ### UI Synchronization - Views may render before async data is ready - Need consistent pattern for showing loading states - Re-render triggers when `asyncFinalInit` completes ## Alternative Approaches Considered **Manifest-Based Metadata:** For the specific case of lazy-loaded cloud objects, storing display metadata (title, subtitle) in a manifest allows stubs to display correctly without fetching full data. The data is synchronously available — just stored in a different place. - Pros: No framework changes, uses existing infrastructure - Cons: Only works when you control what metadata goes in the manifest **Async Closures for Options:** Add `validItemsAsyncClosure` to slots/options that returns a Promise. The options node shows "Loading..." until the closure resolves. - Pros: Localized to options, doesn't affect whole initialization flow - Cons: Adds complexity to Slot and SvOptionsNode, may be over-engineering for limited use cases - Note: This was implemented and then removed in favor of the manifest approach ## Open Questions - How common is async initialization across the codebase? Is framework support warranted? - Should `asyncFinalInit` be opt-in per class, or a universal phase? - How would this interact with the persistence system's `loadFromRecord` flow? - Could a simpler "initialization complete" event/notification pattern suffice? ## Related Patterns in Other Frameworks - React's `useEffect` for async operations after render - SwiftUI's `.task` modifier for async work tied to view lifecycle - Android's `ViewModel` with `init` blocks and coroutine scopes --- Source: /docs/Plans/Async%20Navigation/ # Async Navigation Rearchitecting the navigation stack to support asynchronous loading at every level. ## Status **Direction, no work planned** (2026-11-13). Windowed collections (`setSubnodesAreWindowed`, `loadLatestWindow`, `loadOlderWindow`) and synchronous [lazy slots](../Lazy%20Slots/) have since met the large-collection and cold-data cases with the navigation stack still synchronous. This is a long-term architectural direction, not expected to happen soon. The current synchronous navigation model works well for the common case and is significantly simpler to reason about. This page captures the motivation and tradeoffs for future reference. ## Context STRVCT's navigation stack is currently synchronous. When a user drills into a node, its subnodes are expected to be available immediately in memory -- the tile container reads the subnode array, creates tiles, and displays them in the same frame. This synchronous guarantee makes the navigation code straightforward: there are no loading states, no cancellation of in-flight requests, no partial renders, and no race conditions between navigation events. However, this model assumes all data is local. As the framework is used with cloud-backed data, server-side collections, or very large hierarchies, the assumption that subnodes are always available breaks down. Async navigation would allow any level of the hierarchy to load its children on demand -- from a remote API, a lazy database query, or any other asynchronous source. ## What Would Change The synchronous contract runs deep through the navigation stack: - **`SvStackView`** assumes column content is ready when a navigation event fires. - **`SvNavView`** assumes it can read a node's subnodes and build tiles immediately. - **`SvTilesView`** assumes the subnode array is complete and in memory. - **Tile creation** assumes the node it represents is fully initialized. An async-capable navigation stack would need to handle the possibility that any of these steps returns a promise rather than a value. This means: - **Loading states**: Each navigation level needs a placeholder (spinner, skeleton tiles, or empty state) while data loads. - **Cancellation**: If the user navigates away before loading completes, in-flight requests must be cancelled to avoid stale data arriving in the wrong column. - **Error handling**: Network failures, timeouts, and partial results need UI treatment at every level, not just at the data layer. - **Progressive rendering**: Results may arrive incrementally -- the container needs to render partial subnode sets and update as more arrive. - **Back-navigation caching**: Previously loaded levels should be cached so drilling out doesn't re-fetch. ## Performance Tradeoffs The synchronous model is fast precisely because it avoids async overhead. Making navigation async introduces significant performance costs even when data is local: - **Microtask overhead**: Every `await` yields to the microtask queue, adding latency between navigation steps. A drill-in that currently takes one synchronous frame would span multiple frames even if all data is cached, creating visible delay or flicker. - **Layout thrashing**: Progressive rendering (show spinner, then replace with content) causes multiple layout passes. The current model lays out tiles once. - **Complexity tax**: Every call site in the navigation chain gains error handling, cancellation logic, and state management. This isn't just code complexity -- it's runtime cost from additional branching, promise allocation, and state tracking on every navigation event. - **Synchronous fast path**: Even with an async architecture, the common case (local data) should remain fast. Maintaining a synchronous fast path alongside async support adds implementation complexity and testing surface. - **Memory pressure**: Caching previously loaded levels for back-navigation trades memory for responsiveness. The cache eviction policy itself becomes a source of bugs and tuning. These tradeoffs are the primary reason this is a long-term direction rather than an immediate goal. The current synchronous model is the right default for most applications -- the performance cost of async navigation is only worth paying when the data genuinely can't be local. ## Relationship to Other Work Several other plans intersect with async navigation: - **[Lazy Slots](../Lazy%20Slots/)** and **[Promise-Wrapped Slots](../Promise-Wrapped%20Slots/)** address async data at the slot level. Async navigation would be the view-layer counterpart -- the container knowing how to wait for and display async subnode sources. - **[Scaling to Large Collections](../Tile%20Container%20Views/)** (in Tile Container Views) describes virtual scrolling and async data sources for tile containers. Async navigation generalizes this from a single container feature to a stack-wide capability. - **[Graph Database](../Graph%20Database/)** would introduce query-based node retrieval, which naturally produces async results. Lazy slots were implemented, but synchronously: a pool's records are in memory once it opens, so loading an object needs no await. What remains genuinely async is opening another pool (`asyncResolveFar`) and fetching from a server, and that is where this direction would start if it is ever needed. --- Source: /docs/Plans/Browser%20Cleanup/ # Browser Cleanup Simplifying and documenting the browser navigation architecture. **Status:** open. **Order:** (1) one navigation entry point, (2) a compaction coordinator with a written protocol, (3) composable breadcrumbs, (4) the auxiliary view, which needs 2 and 3. [Tile Container Views](../Tile%20Container%20Views/) waits on 2, and the navigation announcements in [Accessibility Testing & Tuning](../Accessibility%20Testing%20%26%20Tuning/) wait on 1. The compaction notes from Cleanup Notes are merged in below. ## Current Architecture The browser is built from four cooperating classes that implement a recursive Miller column navigation pattern: ### SvBrowserView The top-level container. Extends `SvStackView` and adds application-level concerns: listening for `onRequestNavigateToNode` notifications, handling keyboard shortcuts, and managing the root node hierarchy (app root, settings, breadcrumbs). On startup it schedules `moveToBase()` to set the initial navigation state. ### SvStackView The core navigation primitive. Each stack view is a pair: a **nav view** on the left (or top) showing the selected node's subnodes as selectable tiles, and an **other view** on the right (or bottom) that contains the next `SvStackView` for deeper navigation. This recursive nesting is what produces the Miller column layout. Key responsibilities: - **Path selection**: `selectNodePathArray(pathArray)` walks an array of nodes, selecting one at each level and recursing into the next stack view. - **Path reporting**: `selectedNodePathArray()` and `selectedPathTitlesString()` return the current selection path by walking up or down the stack chain. - **Direction**: The `direction` slot (`"right"` or `"down"`) controls whether subnodes lay out as side-by-side columns or stacked rows. Nodes set this via `setNodeIsVertical()` -- the stack view reads it and adjusts its flex direction accordingly. The recursive combination of different directions at each level is what distinguishes STRVCT's navigation from a standard Miller column browser. - **Compaction**: `updateCompactionChain()` automatically collapses columns that don't fit the available width, showing them as expandable when space is available again. - **Notification broadcasting**: When the user selects a tile, `didChangeNavSelection()` propagates up to the root, which posts `onStackViewPathChangeNote` for breadcrumbs and other observers. ### SvNavView An individual navigation column within a stack view. Contains a header, a scrollable tile container (`SvTilesView`), and a footer. When assigned a node via `setNode()`, it populates the tiles view with that node's subnodes. Additional features: - **Gesture-based resizing**: Users can drag the right or bottom edge to resize the column. The new size is stored on the node (`nodeMinTileWidth` / `nodeMinTileHeight`), so it persists across navigation. - **Collapse / uncollapse**: The compaction system can hide a nav view entirely when space is tight, replacing it with a back-navigation affordance. - **Orientation sync**: Reads the parent stack view's direction and adjusts its own layout accordingly. ### SvBreadCrumbsTile Displays the current navigation path as a row of clickable buttons. Coordinates with the stack view entirely through notifications: 1. Observes `onStackViewPathChangeNote` from the root stack view. 2. Reads `targetStackView().selectedNodePathArray()` to get the current path. 3. Builds a button for each node in the path, storing the path-up-to-that-point in each button's `.info()`. 4. On click, calls `targetStackView().selectNodePathArray()` with the stored path to navigate back. The breadcrumbs also compact: when the path is too long to fit, earlier crumbs are hidden and a back arrow appears that navigates to the most recent hidden crumb. ## Navigation Flow When the user clicks a tile: 1. `SvTilesView` selects the tile and notifies its `SvNavView`. 2. The nav view's parent `SvStackView` calls `didChangeNavSelection()`. 3. This propagates up to the root stack view, which posts `onStackViewPathChangeNote`. 4. `SvBreadCrumbsTile` receives the notification and rebuilds its path buttons. 5. The next `SvStackView` in the chain receives the selected node and populates its nav view. When the user clicks a breadcrumb: 1. `SvBreadCrumbsTile` reads the stored path array from the clicked button. 2. Calls `selectNodePathArray()` on the root stack view. 3. The stack chain recursively selects each node in the path, collapsing deeper levels. 4. The resulting path change triggers `onStackViewPathChangeNote`, and breadcrumbs update. ## Cleanup Opportunities The browser navigation works well but has accumulated complexity over time. Areas to consider: ### Clearer separation of concerns `SvStackView` handles direction, compaction, path selection, and notification broadcasting. Some of these could be factored into smaller, more focused collaborators -- for example, a compaction manager or a path selection coordinator. ### Compaction logic The column compaction system (`updateCompactionChain()` on `SvStackView`, `collapse()` / `uncollapse()` on `SvNavView`) spans both classes with mutual callbacks. It works, but the protocol between them is implicit. - **A compaction coordinator.** Measuring the available width, choosing which columns to collapse, and collapsing or expanding them could live in one object rather than across `SvStackView` and `SvNavView`. - **A written protocol.** What triggers compaction, the order columns compact in, how a column says it can't compact further, and how expansion reverses it. - **Priorities.** All columns compact alike today. Some should resist longer: the auxiliary view below, and nodes whose content matters more than their siblings'. - **Animation.** Collapse and expand are instant; animating them would help the user see what moved. - **Measure once.** Compaction runs on every node update that bubbles to the root, so it is a hot path. Measure container widths once and cache them, invalidated by resize (as `SvStackView.cachedRootWidth()` does), then write; never measure after writing in the same pass. Verify with `?thrash=count` before and after. ### Navigation API surface `selectNodePathArray()`, `navigateToNode()`, `selectNodePathString()`, and `moveToBase()` all navigate but through different entry points. A unified navigation interface would reduce the number of paths through the code. It should also say who asked: the accessibility work announces programmatic navigation and stays quiet for the user's own, and can only tell them apart if every navigation goes through one place that knows its cause. ### Mobile and responsive behavior The compaction system provides basic responsive behavior, but a dedicated mobile navigation mode (e.g., single-column with swipe gestures) could replace the current approach of compacting columns until they fit. ### Composable breadcrumbs Breadcrumbs are not built into the browser view — they're a regular node (`SvBreadCrumbsTile`) added to the node tree. But the tile currently finds its target by walking up to the root `SvStackView`, so only one set of breadcrumbs can exist per browser. This breaks down when a split view or inspector pane contains its own nested stack view that the user navigates independently. That inner pane needs its own breadcrumbs tracking its own path, not the root's. A concrete example: during a game narration conversation, a side panel could let the player inspect their character sheet — drilling into inventory, spells, ability scores — without navigating away from the conversation. That panel would be its own stack view with its own breadcrumbs, independent of the main browser path. The fix is to make breadcrumbs composable: instead of always targeting the root stack view, the breadcrumbs node should target the nearest ancestor stack view (or a specifically assigned one). This would let any stack view — whether it's the top-level browser, one side of a split view, or a deep inspector panel — have its own independent navigation context with its own breadcrumb trail. ### Auxiliary view A node could declare an auxiliary node that the view system renders as a side panel with its own independent navigation context. The auxiliary panel would be a full stack view — the user can drill into nested content within it — but scoped and constrained by hints from the primary node. ```javascript this.setNodeAuxiliaryNode(this.characterSheet()); this.setNodeAuxiliaryPosition("right"); // or "bottom" this.setNodeAuxiliaryDefaultState("expanded"); // or "collapsed" this.setNodeAuxiliaryCompactsFirst(true); // collapse auxiliary before main columns this.setNodeAuxiliaryMaxColumns(2); // cap drill-in depth within the panel ``` This stays declarative — the node says what it wants, the view system handles layout. The auxiliary side is a fully independent navigation context with its own breadcrumbs (once breadcrumbs are composable), its own selection, and its own internal compaction. No changes to the main selection model. The `maxColumns` hint is important for space management. A conversation node knows it only needs a narrow inspector — one or two columns to peek at the character sheet. Once the user drills past the limit, deeper navigation replaces the last column rather than adding a new one. ### Compaction with auxiliary views The current compaction algorithm walks the stack chain and collapses columns that don't fit the available width. Auxiliary views add a new dimension to this because column compaction (horizontal, across navigation levels) and auxiliary compaction (within a single level's content area) are orthogonal. The compaction sequence would become: 1. **Auxiliary internal compaction**: If the auxiliary panel has more columns than fit its allotted width, collapse its inner columns first (using the existing compaction logic, scoped to the auxiliary stack view). 2. **Auxiliary collapse**: If still too tight, collapse the auxiliary panel entirely — to a toggle button, thin strip, or hidden — freeing its width for the main content. 3. **Main column compaction**: If the main stack chain still doesn't fit, run the existing column compaction on the primary columns. Expanding works in reverse: as width becomes available, the main columns uncollapse first, then the auxiliary panel reappears, then the auxiliary's internal columns expand. Node hints control priority: `auxiliaryCompactsFirst` (default `true`) means the auxiliary gives up space before any main columns. A node could set this to `false` if the auxiliary content is more important than the surrounding navigation context — though that would be unusual. This approach requires no fundamental changes to the compaction algorithm itself. The auxiliary panel's internal compaction is just a smaller instance of the same algorithm running on a scoped stack view. The new work is the coordination layer that decides the order of compaction across the two contexts. --- Source: /docs/Plans/Capabilities%20%26%20Permissions/ # Capabilities & Permissions Asking "can this caller do this here?" in one place, answered by the pool's store, so that views offer only what will be honored and a refused write is never silent. **Status:** open; rewritten 2026-11-13 to build on the editability cascade and the Record Store, which both shipped after the first draft. The editing half is in use (`SvNode_editability`); the questions about reading, sharing and authority, and the denial path, are not. ## Context A concrete failure in one application: a non-admin user dragged a JSON file onto an admin-only catalog. The local model accepted the change, the dirty flag fired, a save animation ran, and the write was dropped at the sync layer. The user found out on the next reload. Two layers needed a gate, and each reimplemented the same admin check. Two things have shipped since: - **The editability cascade.** `subtreeIsUserEditable` is a tri-state slot (null means "ask the parent"); `effectiveUserEditability()` walks up the parent and owner chain, and views ask `offersUserEdit(rawCapability)` before offering an edit, a delete, an add or a pick. It is deliberately a UI affordance, not authority: server rules remain the write gate. It is consulted by the option picker, keyboard delete and tile delete, and not yet by title editing, inspector slot editing or drops, which is exactly where the catalog failure happened. - **The Record Store.** A pool is one document, and it is the unit of sync and of permission: a far reference "keeps nothing alive and grants no permissions", and resolving it opens the target pool under the target's own permissions. ## Proposed Shape ### 1. Close the editing gaps (small, do first) Make title editing, inspector slot editing and drops consult `offersUserEdit()`. That alone fixes the catalog failure on the UI side: the drop isn't offered. ### 2. The pool answers for its contents `effectiveUserEditability()` today ends the walk with `true`. Instead, a node whose chain has no opinion asks the pool it lives in, and the pool asks its store: - `SvRecordStoreProtocol` gains an optional `callerRolesForPool(poolId)` (or `callerCanWrite(poolId)`), answered synchronously from what the store already knows: the local store says "all", the cloud store says what the pool's membership and the server rules allow. - An optional method with a default, not a new protocol: the shape [Complete Protocols](../Complete%20Protocols/) settled on for hooks most implementers don't need. - The answer is cached on the pool and refreshed when membership changes, so a tile pass doesn't cost a lookup per node. This keeps one answer for the view and for the store: the store that will refuse the write is the one that told the view not to offer it. ### 3. More than editing The cascade answers one question. The others, as optional hooks on `SvNode` with defaults, consulted the same way: - `callerCanRead()` — default true. For hidden or partly shared content. - `callerCanDelete()` — default: what editing says. - `callerCanShare()` — default false. - `callerCanCreate(aClass)` — default: what editing says. Lets a node accept edits while limiting which children may be added. Each resolves through the cascade and then the pool, as in 2. ### 4. Refusals are never silent When the store refuses a write anyway (stale cache, a rule the client didn't know), it posts a domain notification naming the node and the action, and the UI shows it through the existing user-alert path (`onRequestUserAlert`). The message names the thing, not the role: "You can't edit 'Monster Catalog'." The local change is rolled back with `pool.transaction()` where it ran in one. ## Why This Shape - **One gate per question.** Views and the store ask the same thing and get the same answer. - **Role names stay out of call sites.** "Admin" becoming "catalog editor" and "catalog publisher" changes the store's policy, not the views. - **Per-node policy is an override.** Draft/published, locked during a long operation, read-only after archive: each is a node overriding a hook, not a new flag. ## Open Questions - Should the cached answer ever be async-refreshed mid-session (membership changes while a pool is open), and how is that announced? Probably a notification from the store, observed by the pool, which re-syncs its views. - Capability discovery ("what can I do here?") versus checking an attempted action: the hooks above give both, but a view that wants to hide rather than disable needs a convention. - Is `subtreeIsUserEditable` (not stored, set by whoever builds the tree) enough for app context such as a session's copy of a character, or should those become pool facts too? --- Source: /docs/Plans/Case%20Studies/ # Case Studies Comparative implementations of small applications in STRVCT and conventional stacks. **Status:** not started. **Order:** Contacts first, and early: it needs nothing the framework lacks, and what it turns up feeds the [Meta Plan](../Meta%20Plan/). The others once their features exist: Photo Gallery after the grid container, Discussion Forum after [Capabilities & Permissions](../Capabilities%20%26%20Permissions/), Knowledge Base and Bookmark Manager after search. ## Purpose The naked objects pattern makes strong claims about development efficiency: the framework generates views from models, so developers write less code, and cross-cutting concerns like accessibility and persistence come automatically. These claims are testable. Each case study would implement the same application in STRVCT and in a conventional React stack (React + React Router + a state library + a component library), built by LLMs under identical conditions. The comparison would measure: - **Development effort** -- rounds of prompting, debugging iterations, total token usage - **Code volume** -- lines of code, number of files, boilerplate ratio - **Correctness** -- bugs found in manual testing, edge cases handled or missed - **Accessibility** -- ARIA coverage without explicit effort, screen reader usability - **Persistence and sync** -- how much code is required for local storage and cross-device sync - **Time to feature** -- how quickly a new feature can be added to the existing app Multiple LLMs could run the same studies independently to control for model-specific strengths. ## Core Requirements Every case study app must meet these baseline requirements, because they represent what users expect from a real, useful application: - **Local persistence** -- data survives page refresh and browser restart - **Cloud sync** -- data is available across devices via authenticated user accounts - **Accessibility** -- correct ARIA roles, labels, and states on all interactive elements; keyboard-navigable - **Drag-to-reorder** -- lists that have a user-meaningful order support drag reordering These features are often omitted from small apps not because users don't want them, but because the tools make them expensive to implement. A fair comparison should include them precisely because they reveal where framework design choices reduce or increase the cost of building what users actually need. ## Candidate Applications Each app is small enough to build in a single session but non-trivial enough to exercise real framework features: persistence, cloud sync, navigation, editing, validation, and multiple data types. ### 1. Contacts A personal contacts manager. Each contact has structured fields (name, phone numbers, email addresses, physical address, birthday, notes) with the ability to add multiple entries per field type. Contacts are grouped, searchable, and persisted with cross-device sync. Exercises: nested data structures, multiple field types, search/filtering, persistence, list navigation. ### 2. Photo Gallery A personal photo gallery with albums containing images. Users upload images (with drag-and-drop), which are stored as blobs with generated thumbnails. Each image has a caption, tags, and date taken. Albums display as a grid of thumbnails; selecting an image opens a detail view. Images are drag-reorderable within albums. Supports bulk upload. Exercises: binary blob storage and retrieval, image upload and thumbnail generation, grid layout, lazy loading, media-heavy UI, drag-to-reorder in a grid context, tagging and filtering. ### 3. Project Tracker A lightweight project management tool with projects containing tasks. Each task has a title, description, status (todo/in-progress/done), priority, due date, and assignee. Tasks can be drag-reordered within status groups. Exercises: enum fields (status, priority), date handling, drag-to-reorder, grouping/filtering by property, multiple navigation levels (project → task list → task detail). ### 4. Discussion Forum A multi-user discussion forum with boards, threads, and posts. Users create accounts, post in threads, and see content from other users in real time. Thread authors can edit or delete their own posts; board-level moderation controls allow designated admins to remove content. Threads sort by latest activity; posts are chronological within a thread. Posts support basic formatting (markdown or simple HTML). Exercises: shared mutable state across users, authentication and per-user permissions, real-time updates from other users, threading/nesting, rich text input, moderation controls. ### 5. Knowledge Base A personal wiki for organizing notes, ideas, and reference material. Each entry has a title, rich text body (headings, bold, italic, lists, code blocks), tags, and creation/modification timestamps. Entries can link to other entries via wiki-style cross-references (`[[Entry Title]]`), forming a navigable graph. A backlinks section on each entry shows all entries that reference it. Full-text search across all entries. Exercises: rich text editing, cross-referencing and link resolution, backlink computation, tagging, full-text search, deep content hierarchy. ### 6. Bookmark Manager A hierarchical bookmark organizer with folders, tags, and full-text search. Each bookmark has a URL, title, description, tags, and a timestamp. Folders can nest arbitrarily. Bookmarks are drag-reorderable within folders. Supports import from a simple format. Exercises: recursive hierarchy (nested folders), tagging system, full-text search, URL validation, drag-to-reorder, bulk import, deep navigation. ## Study Design ### Environment Each implementation starts from the same written specification. The LLM receives the app spec and the relevant framework documentation (STRVCT docs or React/library docs) and builds the app through iterative prompting. No human code review or correction during the build -- the LLM debugs its own errors. ### Metrics | Metric | What it measures | |---|---| | Prompt rounds | Number of user→LLM turns to reach a working app | | Debug iterations | Turns spent fixing errors vs. building new features | | Token usage | Total input + output tokens consumed | | Lines of code | Final app size excluding framework/library code | | File count | Number of source files in the final app | | ARIA coverage | Percentage of interactive elements with correct ARIA roles and states | | Persistence + sync code | Lines dedicated to storage and cloud sync (annotations vs. explicit read/write) | | Feature addition | Effort to add a specified new feature after initial completion | ### Controls - Same app spec, same acceptance criteria - Same LLM model (or multiple models run independently) - React stack chosen to be representative, not strawman: current React with hooks, a mainstream router, and a widely-used component library - React implementations may use any third-party libraries (drag-and-drop, Firebase SDK, accessibility utilities) -- the total effort including library integration is part of the measurement - Each app tested against the same manual test checklist --- Source: /docs/Plans/Cleanup%20Notes/ # Cleanup Notes Areas of the codebase that work but could benefit from simplification, documentation, or restructuring. **Status:** open; checked against the source 2026-11-13. Done since the first draft: Notification Center indexing (`tests/headless/TestNotificationIndexes.js`) and the `isInTx()` question in the object pool. Moved: view compaction to [Browser Cleanup](../Browser%20Cleanup/), model/view items to [Naked Objects Issues](../Naked%20Objects%20Issues/), schema migration to its own entry in the [Meta Plan](../Meta%20Plan/). The runtime-risk items are done; the rest are for when a file is being changed anyway. When rewriting a file, re-check the fixes already applied to it (see the framework guide on diagnostics coming back in rewrites). ## Can Fail at Runtime Both items here are fixed (2026-11-15): - **ObjectPool recursive GC.** `markPid()` (`SvObjectPool_collection.js`) walks with an explicit stack; a chain of 300,000 references marks without overflowing (`tests/headless/TestGcDeepReferenceChain.js`). - **Promise-wrapped slot errors.** A failed computation is no longer cached. See [Promise-Wrapped Slots](../Promise-Wrapped%20Slots/#error-recovery). ## Structure ### Slot Hooks `Slot.js` (2,295 lines) has a TODO: "hooks code is a mess, need to cleanup and modularize." The hook system (`onWillGet`, `onDidUpdate`, `onUndefinedGet`, …) is set up across scattered code paths, and the file also holds storage configuration, inspector settings, validation, JSON Schema and lazy loading. Splitting it into categories (`Slot_hooks.js`, `Slot_storage.js`, `Slot_inspection.js`, `Slot_lazy.js`) would separate concerns without changing the public API; `Slot_promiseWrapper.js` already shows the shape. ### SvCssDomView `SvCssDomView.js` (2,993 lines) holds 100+ CSS property accessors, plus commented-out code: a push/pop attribute stack and an `applyCSS` helper. - **Group the accessors** into categories (`SvCssDomView_layout.js`, `SvCssDomView_typography.js`, …), or generate the repetitive ones from a property list. - **Remove the commented-out code.** Git keeps it. ### Notification Names Notification names (`onStackViewPathChangeNote`, `onRequestNavigateToNode`, …) are string literals scattered through the code. A pass could: - Collect them as constants on the classes that post them. - Document which classes post and which observe each. - Find the ones no longer posted or observed. ### View Class Discovery Discovery by naming convention (`Contact` → `ContactTile`) is surprising when it doesn't find a match. A debug log, or an inspector field, showing which view class was chosen for a node and why would help. ### Boot Loader Ordering `SvBootLoader.js` loads its files from a hardcoded array whose order matters, with the dependencies recorded only in comments ("important that this be after SvIndexedDbFolder/Tx"). An explicit dependency list or a check at boot would let it validate its own order. ### IndexedDB Browser/Server Duplication `SvIndexedDbFolder.js` exists in `browser-only/` (871 lines) and `server-only/` (483), as does `SvIndexedDbTx.js` (445 and 438). A shared base would shrink the surface and keep the two consistent. ### Resource Manager and the Loading View `SvResourceManager.js` calls `SvBootLoadingView` directly to update progress. Posting progress notifications instead would let the loading view observe them, and keep the loader free of UI. ### Error Handling Errors are reported in several ways: `console.error()` with emoji prefixes, context added to error objects (`evalError.evalPath = path`), custom error classes (`SvJsonPatchError`, `SvMissingSlotError`, the AI request errors), and catch-and-log. A convention for which to use when would make errors easier to trace. ### Theme Value Generation `SvThemeState`'s value lists (`validLetterSpacingValues()` and its siblings) are rebuilt on every call, 50+ strings each. Compute them once per class. ## Noise ### Commented-Out Code - `SvJsonGroup.js`: the `hasBeenLoaded` slot and lazy-loading scaffolding, superseded by [Lazy Slots](../Lazy%20Slots/). - `SvStorableNode.js`: the commented-out `setIsLazy(true)` ("no point in using this until we have coroutines"), also superseded. - `SvCssDomView.js`: the push/pop attribute stack (above). - `SvResourceManager.js`: an alternative parallel loading approach. - `SvNode_subnodes.js`: two "TODO: remove after debugging" lines. ### Unused Files 107 files sit in 33 `_unused/` folders across the source tree. They're out of the build, but they turn up in every search. Delete them (git keeps them) or move them to one archive folder. ### Stale TODOs There are 140 TODO/FIXME comments in `source/` (not counting `_unused/` and `external-libs/`). Some are stale: "hasOwnProperty?" questions in `Slot.js` that `Object.hasOwn()` already answers, debug leftovers, and bare `// TODO:` with no description. A pass to resolve or explain them would make the rest useful as a backlog. --- Source: /docs/Plans/Complete%20Protocols/ # Complete Protocols Replacing duck-typed method checks with the right kind of contract: a default on a base class, a protocol, or nothing at all. **Status:** done (2026-11-12) for the hooks and protocol below. `tests/headless/TestHookDefaults.js` checks the defaults and the protocol; `tests/headless/TestDuckTypedChecks.js` keeps new checks from appearing. ## Context STRVCT has a [protocol system](../../Programming%20Idioms/Protocols/) for declaring interfaces. A class adopts a protocol with `addProtocol()`, which verifies at class setup that it implements every required method; a protocol can also name optional methods (`optionalMethodNames()`). Protocols declared so far: - **Contracts:** `SvRecordStoreProtocol` (the local, memory and cloud record stores), `SvCollapsibleRegionProtocol`, `SvAudioClipProtocol`, `SvProgressiveImageSourceProtocol`. - **Delegates:** `SvDelegateProtocol` and its subprotocols, whose methods are all optional: `SvAudioClipDelegateProtocol`, `SvAiRequestDelegateProtocol`, `SvConversationMessageDelegateProtocol`, `SvXhrRequestDelegateProtocol`, `SvHtmlStreamReaderDelegateProtocol`, `SvImagineProImageGenerationDelegateProtocol`, `SvRzPeerConnDelegateProtocol`, `SvRzSigServerConnDelegateProtocol`. Elsewhere the code checks whether an object has a method before calling it: `if (node && node.cssVariableDict) { … }`. These checks hide three different situations, and each wants a different fix. ## Three Kinds of Check ### 1. Optional hooks: give the base class a default Most checks ask whether a node or view *offers* some optional behavior, because most don't. A protocol doesn't help here: it verifies classes that claim conformance, but these call sites need to know about every object, so the check would only change from `node.foo` to `node.conformsToProtocol(P)`. The fix is a default on the common base class that does nothing or returns a neutral value. Subclasses override it, and every call site loses its check. This is the same shape as the `node*` view hints: the base class answers for everyone, and a class that wants something different says so. | Hook | Checked in | Defined today | Default to add | | --- | --- | --- | --- | | `cssVariableDict()` | `SvNodeView`, app tiles | Only app classes (`UoAiChat`, `UoAiResponseMessage`) | `null`, on `SvNode` | | `nodeAcceptsDrop(node)`, `nodeDropped(node)` | `SvTile_dragging` | `SvLinkNode` only | `false`, and do nothing, on `SvNode` | | `keyIsComplete()`, `valueIsComplete()` | `SvFieldTile`, image and video well tiles | Slots on some message classes | `true` | | `referencedBlobHashesSet()` | `SvObjectPool_blobs` (every pooled object) | `SvBlobNode` only | an empty set, on the storable base | ### 2. Checks for methods the base class already has: delete them Some checks guard methods every possible receiver already inherits. They can go now: | Method | Checked in | Already defined on | | --- | --- | --- | | `nodeBecameVisible()` | `SvNodeView` | `SvNode` | | `onBrowserDropChunk(chunk)` | `SvTilesView` | `SvViewableNode` (and a do-nothing default on `SvNode`) | | `activate()` | `SvFieldTile` (on its value view) | `SvStyledDomView` | Before deleting each check, confirm the receiver can't be some other class (a plain `SvNode` where an `SvViewableNode` is expected, a value view that isn't an `SvStyledDomView`). Where it can, the base default belongs one level higher, as in kind 1. The node defaults are on `SvNode`, not `SvViewableNode` where the other hints live: a view may show any node, and some aren't viewable nodes (the top bar's feedback link is an `SvTitledNode`). Defaults first put on `SvViewableNode` threw for it on every sync. Kept: `SvTile`'s check for `didChangeNavSelection()` on its tiles view, which is just its parent view and isn't always an `SvTilesView` (inline documents, the companion). The sync scheduler has no such check: it calls whatever method it is given. ### 3. Real contracts: declare a protocol A protocol fits when several methods must come together and are implemented by classes that share no base class that could hold them. These are the ones to declare: **`SvJsonSerializableProtocol`**: `serializeToJson()` and `deserializeFromJson(json)`. - Implemented by: `SvJsonGroup`, `SvJsonArrayNode`, `SvJsonDictionaryNode`, `SvField`, `SvBooleanField`, `SvPointerField`, `SvJsonNullField`, `SvDateNode`, `SvTimeNode`, `SvImageNode`, `SvToolResult`, `SvConversation`, `SvJsonIdNode`. - The two don't always come as a pair today: `SvImageNode` and `SvJsonDictionaryNode` serialize but don't deserialize, and `SvJsonIdNode` (the base of `SvJsonGroup`) deserializes but doesn't serialize. Declaring the protocol makes each class say which it supports, perhaps as two protocols, or one with an optional half. - The checks at call sites stay as method checks (`value.serializeToJson`, `typeof node.deserializeFromJson === "function"`): the values can be strings, numbers or `null`, and the reading checks sit in the JSON patch paths, where a rewrite would change nothing but risk. The protocol's job is the verification at class setup and the one place that documents the contract. **`SvNodeDropTargetProtocol`**, only if a second drop target appears. With `SvLinkNode` as the only implementer, the defaults in kind 1 are simpler. Not a protocol: storage. `recordForStore()` and `loadFromRecord()` are categories on `Object`, `ProtoClass` and the built-ins (`Array_store`, `Map_store`, …), so every object already has them. Protocols can only be adopted by `ProtoClass` subclasses today, so built-ins couldn't declare conformance anyway. ## Approach 1. **Defaults (kind 1).** For each hook: add the default to the base class, delete the checks at its call sites, and check the app (`Uo*`) for overrides that relied on the method being absent. 2. **Deletions (kind 2).** Confirm each receiver's class, then delete the check. 3. **Protocols (kind 3).** Declare `SvJsonSerializableProtocol`, have each implementer adopt it, and settle the pairs that are half implemented. 4. **Keep it from coming back.** A headless test that lists the remaining `if (x && x.method)` checks in `source/`, with an allowance for the deliberate ones (values that can be primitives), so a new check is noticed when it's added. Each step stands alone and changes no behavior: kind 1 replaces a check with a default that gives the same answer, kind 2 removes a check that always passed, and kind 3 adds verification at class setup. ## Benefits - **Less code at call sites.** Most checks disappear rather than being rewritten. - **One place to look.** A hook's default on the base class documents it: its name, what it's for, what it returns when a class doesn't care. - **Early errors where they help.** A class that adopts `SvJsonSerializableProtocol` but lacks a method fails at startup, not when its JSON is first exported. - **Consistency with node hints.** Optional behavior works the same way throughout: the base class answers, subclasses override. --- Source: /docs/Plans/Emergent%20Capabilities/ # Emergent Capabilities Capabilities that the naked objects architecture makes possible at the framework level. **Status:** a list of candidates, not a plan. Each candidate now has a home, so this page can become a docs page about the pattern once they're placed: | Candidate | Where it goes | | --- | --- | | Undo / redo | Its own plan when wanted, built on slot-change notifications and `pool.transaction()` | | Search & filtering | [Tile Container Views](../Tile%20Container%20Views/) (container chrome, and search over windowed collections) | | Data validation | [JSON Schema](../JSON%20Schema/) (validation against the same annotations) | | Automated testing | An idea until wanted | | Analytics & telemetry | An idea until wanted | | Debug inspection | Already true; belongs in [Inspectors and Debugging](../../Inspectors%20and%20Debugging/) | | Migration & schema evolution | Its own plan, with the [Meta Plan](../Meta%20Plan/)'s note, when a slot type change needs it | ## Context In a conventional web framework, cross-cutting concerns -- accessibility, internationalization, search, undo -- must be implemented per component. The cost scales linearly with the number of components, and coverage is always incomplete. STRVCT's architecture inverts this. All state lives in typed slots with rich metadata (type, description, min/max, required, read-only). All UI passes through a small set of view classes (~15 tile and container classes render every application). This means a capability implemented once at the framework level automatically covers every application built on the framework. Two capabilities already demonstrate this pattern: - **[Accessibility](../../Accessibility/)** -- Slot metadata maps to ARIA attributes, view classes emit roles and states, and every application inherits WCAG 2.2 AA support without per-component accessibility code. - **[Internationalization](../../Internationalization/)** -- Translatable nodes and a batched translation service give every application multilingual support through the model layer. The candidates below are additional capabilities that the same architectural properties make possible. Each would be difficult or impractical to add after the fact in a conventional framework, but in STRVCT they can be implemented at the framework level and applied uniformly. ## Candidates ### Undo / Redo Every state change flows through `didUpdateSlot()` with both old and new values. A command history captured at the slot level would give automatic undo/redo to every editable field and action. The notification system already provides the hook points; what's missing is a journal that records slot mutations and can replay them in reverse. The slot system's granularity is an advantage here -- each undo step corresponds to a single slot change with a known previous value, avoiding the complexity of diffing arbitrary state trees. ### Search & Filtering The entire node graph is structured, typed, and labeled. A framework-level search could traverse all nodes and slots, using slot metadata (type, description) to build both full-text and structured queries -- without per-component indexing code. Slot types inform how to search (string matching on text slots, range queries on numeric slots, boolean filtering on flags), and node titles and descriptions provide natural result labels. The same traversal could support filtering a tile container's visible subnodes by query. ### Data Validation Slot annotations already drive three consumers: JSON Schema for AI tool calls, ARIA attributes for screen readers, and persistence constraints. A fourth consumer -- a validation layer -- would use the same metadata (type, min, max, required, pattern) to provide automatic error messages and visual feedback on invalid input. Because the metadata is already there, validation rules wouldn't need to be declared separately from the slot definitions. A field tile with `setAnnotation("minimum", 0)` would automatically reject negative input and display an appropriate message, just as it already emits `aria-valuemin="0"` and `"minimum": 0` in JSON Schema. ### Automated Testing The model is effectively its own specification. Slot metadata declares what types, ranges, and constraints each field accepts. This makes generative testing possible: the framework could automatically produce test cases for every editable slot (valid and invalid input for its type), exercise every action, and walk every navigation path in the node graph. This is a stronger property than conventional snapshot or integration testing -- the tests derive from the model's structural definition rather than from manually written expectations, so they stay in sync as the model evolves. ### Analytics & Telemetry Every user interaction passes through the same tile, navigation, and action paths. Instrumenting once at the framework level would capture usage data (which nodes are visited, which fields edited, which actions taken, how users navigate the hierarchy) for every application -- without per-feature tracking code. The node hierarchy provides natural grouping for analytics events, and slot metadata provides labels and types for structured event properties. ### Debug Inspection STRVCT applications are already their own inspectors -- the node hierarchy is directly navigable, every slot's current value is visible in the UI, and the notification system shows the flow of changes in real time. This isn't a feature to build; it's an inherent property of the naked objects pattern worth calling out as a capability. Conventional frameworks require separate developer tools (React DevTools, Vue DevTools) to inspect component state. In STRVCT, the production UI and the debug inspector are the same thing. ### Migration & Schema Evolution When slot definitions change across versions, the framework knows both the stored schema (from the persisted record) and the current schema (from live slot definitions). This structural knowledge makes automatic migration possible: detecting renamed, added, or removed slots and transforming stored records to match the current definition. In conventional systems, schema migration requires manually written migration scripts. In STRVCT, the slot system provides enough information to detect and potentially automate many common migrations. ## The Common Pattern Each candidate above follows the same structural argument: 1. **Slot metadata already describes the data** -- types, constraints, descriptions, and relationships are declared once in `initPrototypeSlots()`. 2. **A small set of view classes renders everything** -- behavior added to the ~15 tile and container classes covers every application. 3. **The notification system provides hook points** -- `didUpdateSlot()`, `scheduleSyncToView()`, and the notification center make it possible to intercept and react to changes at the framework level. 4. **The node hierarchy provides structure** -- traversal, search, serialization, and inspection all operate on a uniform graph rather than an ad-hoc component tree. The cost of each capability is proportional to the number of view classes (small and fixed), not the number of application components (large and growing). This is the fundamental leverage of the naked objects pattern. --- Source: /docs/Plans/Graph%20Database/ # Graph Database Long-term direction: replacing the current cloud storage backend with a native graph database. **Status:** direction, no work planned (2026-11-13). The Record Store already provides per-record sync, change feeds by version and placement queries, and windowed collections cover large folders. See [Timeline](#timeline) for what would make it compelling. ## Context STRVCT's domain model is a cyclic graph of objects connected by typed references. Locally, this graph is stored in IndexedDB as a flat key-value map of serialized records, with object references represented as persistent unique IDs (puuids). In the cloud the same records are stored one per Firestore document, grouped into pools (one per document, each with a version), with folders formed by placing each pool's root row under its folder; edits are sent as versioned commits of the changed records (see [Cloud Object Pools](../../Persistence/Cloud%20Object%20Pools/)). This record store already gives per-record sync, change feeds by version, and placement queries — much of what is listed below. What remains is a mismatch at the level of references: the domain model is a graph, while the record store sees each reference only as an id inside a serialized payload. It can list a node's placed children, but it cannot answer structural queries across references or serve a subgraph by traversal. ## Why a Graph Database A graph database would store nodes and edges as first-class entities, directly mirroring how the domain model already works internally: **Structural alignment.** Each domain object becomes a node in the database. Each slot that references another object becomes an edge. The database's structure matches the application's structure — no serialization/deserialization impedance mismatch. **Granular sync.** Changes to a single node or edge can be synced independently without uploading an entire pool snapshot or maintaining a separate delta log. Updating a contact's phone number doesn't require re-uploading the entire address book. **Lazy traversal.** The database can serve subgraphs on demand — fetch a node and its immediate neighbors, then expand as the user navigates. This is the graph-native version of what collection sync's manifest stubs approximate with per-item lazy loading. **Query by structure.** "Find all contacts who share a company with this person" or "show me every group this contact belongs to" become native graph traversals rather than full-table scans or application-level filtering. **Conflict resolution at the edge level.** When two clients modify different parts of the same graph concurrently, a graph-aware system can merge at the node/edge level rather than the document level, reducing false conflicts. ## Prior Art [vertex.js](https://github.com/stevedekorte/vertex.js) is an earlier graph database implementation by the framework author. It stores a persistent graph of nodes with named slots (key-value pairs), where values can be primitives or references to other nodes. The data model is close to what STRVCT's domain objects already look like: - Nodes have unique IDs and named properties - Properties can hold primitive values or references to other nodes - The graph supports cycles and bidirectional traversal - Queries walk the graph by following named edges The concepts from vertex.js — persistent graph nodes with slot-based properties, structural traversal, and path-based addressing — map directly onto STRVCT's existing object model. ## What This Would Replace The current cloud sync stack has several layers that a graph database would subsume: | Current | Graph DB equivalent | |---|---| | JSON serialization of object records | Direct node/edge storage | | puuid-based references between objects | Native graph edges | | Per-record versioned commits | Per-node/per-edge mutations | | Placement queries and windowed loading | Subgraph traversal | | Changes since a pool version | Change feed on individual nodes/edges | | Optimistic per-pool version checks | Node-level or edge-level conflict resolution | The local IndexedDB layer would likely remain as a client-side cache, but the canonical store would be the graph database rather than the records collection. ## Challenges ### Scalability A hosted graph database must handle concurrent reads and writes from many clients, with low latency for the interactive traversals that drive STRVCT's navigation-based UI. This is a harder operational problem than serving static JSON files from cloud storage. ### Partial sync and offline-first STRVCT applications work offline with local data, syncing when connectivity returns. A graph database sync protocol needs to handle: - Efficient diffing: which nodes/edges changed since last sync? - Subgraph boundaries: which parts of the graph does this client care about? - Conflict resolution: two clients modified the same node offline — how to merge? ### Migration Existing applications store data in the records collection. A migration path is needed — likely a period where both backends coexist, with the graph database gradually taking over as the primary store. ### Hosting and operations Firestore is a managed service with minimal operational overhead. A graph database requires either a managed graph DB service (e.g., Neo4j Aura, Amazon Neptune) or self-hosted infrastructure with its own scaling, backup, and monitoring concerns. ## Object Sub-Pools One concept from the current architecture that should carry forward is the **object pool** (formerly called a sub-pool) — a self-contained subgraph where outside nodes may point to the root, but all internal objects hold no hard references to objects outside the subgraph. These sub-pools can be nested and are the natural unit of ownership, sync, and access control. In practice, sub-pools correspond to the coarse-grained "documents" of an application. In a contacts app, for example, each contact card — with its addresses, phone numbers, notes, and group memberships — forms a sub-pool. The contacts list holds references to each card's root, but the internal objects within a card don't reference objects in other cards. Each sub-pool can be: - **Synced independently** — upload or download a sub-pool without touching the rest of the graph - **Garbage collected** — objects reachable only within the sub-pool can be collected together - **Access controlled** — permissions can be scoped to a sub-pool (e.g., a user owns their contacts but shares specific groups with collaborators) - **Migrated or archived** — move a sub-pool to cold storage or a different backend without breaking references A graph database backend should preserve this sub-pool structure as a first-class concept — not flatten everything into a single global graph. The sub-pool boundary is what makes it practical to sync, permission, and reason about parts of the graph independently, even though the database itself supports arbitrary cross-references. ## Relationship to Current Architecture This is envisioned as a backend replacement, not a framework rewrite. The domain model, slot system, persistence API, and view layer would remain unchanged. The swap would happen below the record store protocol (`SvRecordStoreProtocol`): - `SvLocalRecordStore` continues to manage local IndexedDB storage - A new `SvRecordStoreProtocol` backing would speak to a graph database API instead of the records collection - The serialization format would change from JSON documents to node/edge mutations - The sync protocol would change from per-pool versioned commits to a graph-aware change feed - Object sub-pools remain the unit of sync — the graph database stores the full graph, but sync, permissions, and lifecycle operate at the sub-pool level The domain model already *is* a graph — the change is making the storage layer acknowledge that. ## Timeline This is a long-term architectural direction, not near-term work. The current Firebase-based cloud sync is functional and sufficient for the application's current scale. A graph database backend would become compelling when: - The object graph grows large enough that pool-level sync becomes a bottleneck - Multi-user collaborative editing requires finer-grained conflict resolution than document-level merging - Query patterns emerge that are awkward to express without structural graph traversal --- Source: /docs/Plans/JSON%20Schema/ # JSON Schema Expanding auto-generated JSON Schema coverage across slots, classes, and the domain model. **Status:** open. **Order:** slot-level keywords, then validation against them (which takes in the Data Validation item from [Emergent Capabilities](../Emergent%20Capabilities/)), then type unions. Leave `if`/`then`/`else` until a real case needs it. ## Context STRVCT automatically generates JSON Schema from the domain model — classes produce object schemas, slots produce property schemas, and cross-references between classes produce `$ref` and `definitions` entries. These schemas are used for AI tool calls (constraining function parameters), data exchange, and validation. The current implementation covers the most common schema features, but there are gaps at both the slot level (individual property constraints) and the class level (object-wide constraints and composition). Closing these gaps would make the auto-generated schemas more precise, which directly improves AI behavior — tighter schemas reduce hallucinated parameters and improve structured output quality. ## Current Coverage ### Class-level (SvNode) `SvNode.asJsonSchema()` generates object schemas with: | JSON Schema keyword | Source | Notes | |---|---|---| | `type` | Always `"object"` | | | `description` | `jsonSchemaDescription()` | Static method on each class | | `properties` | `jsonSchemaProperties()` | Composed from slots marked `isInJsonSchema` | | `required` | `jsonSchemaRequired()` | From slots marked `isRequired` | | `additionalProperties` | `additionalProperties()` | Boolean — whether extra keys are accepted | | `readOnly` | `jsonSchemaIsReadOnly()` | Optional, class-wide | | `title` | `jsonSchemaTitle()` | Only emitted when different from class name | | `$ref` | `jsonSchemaRef()` | For cross-class references | | `definitions` | `jsonSchemaDefinitionsForRefSet()` | Collects all referenced classes recursively | ### Slot-level (Slot) `Slot.asJsonSchema()` generates property schemas with: | JSON Schema keyword | Slot API | Notes | |---|---|---| | `type` | `setSlotType()` | Mapped to JSON Schema types | | `description` | `setDescription()` | | | `title` | Auto-generated | From slot name | | `default` | `initValue()` | When not `undefined` | | `enum` | `setValidValues()` / `setValidItems()` | | | `examples` | `setExamples()` | | | `pattern` | `setJsonSchemaPattern()` | String regex | | `readOnly` | `setIsReadOnly()` | | | `items` | `setJsonSchemaItemsType()` | Array item type, description, uniqueItems, $ref | | `properties` | `setFinalInitProto()` | Nested object schemas | | `$ref` | Auto-generated | For slots referencing node classes | ### Already inconsistent One annotation already has two readers that disagree: `SvFieldTile` emits `aria-valuemin` / `aria-valuemax` from a slot's `minimum` / `maximum` annotations, but `Slot.asJsonSchema()` doesn't emit those annotations. It only derives `minimum` and `maximum` from a contiguous integer `enum`. Wiring the annotation into the schema is the natural first change. ## Missing Slot-Level Keywords These JSON Schema keywords have no corresponding slot annotation yet: ### Numeric constraints - **`minimum` / `maximum`** — bounded ranges for Number slots (e.g., ability scores 1–30, hit points 0–999) - **`exclusiveMinimum` / `exclusiveMaximum`** — strict bounds - **`multipleOf`** — step constraints (e.g., currency in increments of 0.01) ### String constraints - **`minLength` / `maxLength`** — character limits for text fields - **`format`** — semantic formats like `"date-time"`, `"email"`, `"uri"`, `"uuid"`. Particularly useful for AI — knowing a string is a UUID vs. a display name changes how the AI generates it ### Array constraints - **`minItems` / `maxItems`** — collection size bounds - **`uniqueItems`** — partially supported on item-typed arrays but not as a general slot annotation ## Missing Class-Level Keywords ### Composition - **`oneOf` / `anyOf` / `allOf`** — union and intersection types. A slot that accepts "either a UoCharacter or a UoCreatureTemplate" currently can't express this. At the class level, this could describe polymorphic collections. - **`const`** — fixed-value properties (more specific than a single-element enum) ### Conditional - **`if` / `then` / `else`** — conditional validation. For example: if `characterClass` is "Wizard" then `spellSlots` is required; if `type` is "ranged" then `range` must be present. These constraints currently live only in code or prompt text. ### Object structure - **`propertyNames`** — constraints on key names for Map-typed slots - **`patternProperties`** — schema for properties matching a regex pattern - **`minProperties` / `maxProperties`** — bounds on the number of properties ## Implementation Approach ### Slot-level additions Each missing keyword follows the existing annotation pattern — a getter/setter pair on `Slot` that `asJsonSchema()` reads: ```javascript // On Slot: setMinimum (n) { this.setAnnotation("minimum", n); return this; } minimum () { return this.getAnnotation("minimum"); } // In asJsonSchema(): const min = this.minimum(); if (min !== undefined) { schema.minimum = min; } ``` The slot system's annotation mechanism already supports arbitrary key-value metadata, so no structural changes are needed — just adding the accessors and wiring them into `asJsonSchema()`. ### Class-level additions Composition keywords (`oneOf`, `anyOf`) would need static methods on `SvNode` that `asJsonSchema()` includes in the class schema. Conditional keywords (`if`/`then`/`else`) are more complex — they'd require a way to express inter-slot dependencies at the class level, possibly as a static `jsonSchemaConditionals()` method that returns an array of condition objects. ### Validation unification Currently, JSON Schema annotations are output-only — they describe the slot's contract to external consumers but don't enforce it at runtime. A natural extension would be to have the auto-generated setter validate against the same constraints: - A `Number` slot with `setMinimum(0)` would reject negative values - A `String` slot with `setMaxLength(100)` would warn on overflow - A `String` slot with `setFormat("email")` could validate format This would unify schema declaration and runtime validation, ensuring the contract described to AI consumers is actually enforced in the application. The existing `validatesOnSet` mechanism already provides the hook point — it just needs to consult the richer set of annotations. **A new constraint applies to every record already stored**, the same way slot flags do. So it must never stop a record loading: - **Loading** (`loadFromRecord`, `deserializeFromJson`, lazy materialization): warn and keep the value. The setter already only warns on a type mismatch; constraints should do the same. - **Edits** (the user, a JSON patch from an AI): reject, with a message built from the annotation ("must be at least 0"). For AI patches the rejection goes back as a tool-call error, so the model can correct itself. - **Field tiles** show the same message beside the field, which is the Data Validation idea from Emergent Capabilities: one set of annotations feeding the schema, the ARIA attributes and the error text. ## Richer Type Unions Slots currently declare a single type via `setSlotType("String")`. Some slots legitimately accept multiple types — a value that could be a `String` or `null`, or a slot that holds either a `Number` or an `Array`. The type system doesn't express this, leading to validation warnings that must be suppressed. A possible API: ```javascript slot.setSlotType("String|null"); // or: slot.setSlotTypes(["String", "Number"]); ``` This would generate `oneOf` or union types in JSON Schema and validate against any of the listed types at runtime. ## Open Questions - Should all JSON Schema keywords be supported, or only those that map to runtime behavior? Keywords like `if`/`then`/`else` add schema expressiveness but may be complex to implement as runtime validation. - How should schema versioning work? If the schema changes between app versions, should the schema include a `$id` with a version component? - Could the framework auto-infer some constraints — for example, deriving `minimum: 0` from a slot named "count" or "quantity"? Or is explicit annotation always better? - How should the schema handle slots that are writable by the app but read-only for AI? The current `readOnly` is all-or-nothing. --- Source: /docs/Plans/Lazy%20Slots/ # Lazy Slots Deferring object loading until first access, so large object graphs don't pay for what they don't touch. **Status:** shipped (2026-07), with a few items left (below). In use by app collections and character sheet sections; `tests/headless/TestLazyMaterializationNeutrality.js` and `TestPendingMaterialization.js` cover it. ## What Shipped A stored slot marked lazy isn't loaded with its owner. It holds a placeholder until something reads it: ```javascript { const slot = this.newSlot("locations", null); slot.setShouldStoreSlot(true); slot.setIsLazy(true); } ``` - **Loading leaves a placeholder.** `loadFromRecord` puts an `SvStoreRef` (the record's pid) in the slot instead of instantiating the object and everything it reaches. - **The getter is synchronous.** The record store reads a pool's records into memory when it opens, so turning a pid into an object needs no I/O, and the first getter call does it in place: `onInstanceMaterializeLazySlot` loads the object through the pool (whose identity map keeps one instance per pid) and writes it through the setter, so slot hooks and view sync fire as for any other change. No caller awaits anything. The objection in `SvStorableNode` ("no point in using this until we have coroutines") no longer applies. - **Loading is not editing.** A write that replaces an `SvStoreRef` is a load, so it marks nothing dirty and touches no timestamps. Hooks can tell: `oldValue instanceof SvStoreRef` means "there was no previous live value". `Slot.isMaterializingAnyLazySlot()` covers the one consumer that can't see the old value. - **Untouched subtrees round-trip.** Serializing a slot that still holds its `SvStoreRef` writes the pid back without loading it. - **Lazy collections.** Laziness is per slot, not per array element: a collection is lazy as a whole (`subnodes` included), and a deep tree gets a lazy boundary at each level. - **A default for lazy slots with a proto.** A lazy slot with no stored value creates its `finalInitProto` default on first access rather than at load (`onInstanceMaterializeLazyDefault`). - **JSON too.** Reading JSON into a node parks the JSON for a lazy slot in an `SvLazyJsonRef`, so importing a large object doesn't build subtrees nobody looks at. - **Failure.** If the record is missing, the getter returns null or the owner's `onFailedLazyLoadSlot()` fallback. The `SvStoreRef` stays in the slot, so the next access retries (rate-limited by a negative cache on the ref), and a fallback written by the hook is a load, not a repair, so it isn't stored. An exception while deserializing propagates; it is a bug, not a missing record. - **GC.** Store GC marks reachable records by walking records, not instances, so unloaded subtrees stay reachable. Blob GC scans records for hashes for the same reason. The design and its measurements (boot went from 12.5 s to 8.3 s, with two-thirds of a mature store left unloaded) are in undreamedof.ai's "Slot Lazy Loading" plan. ## What Changes for Code in a Lazy Subtree - `finalInit()` and `afterInit()` of a lazily held object run when it loads, not at boot. Nothing outside the subtree may rely on them having run. - Observers inside the subtree don't exist until it loads, so the subtree registers its own when it wakes. - `duplicate()` loads the value: copying is an explicit "I need it" moment. ## What Remains - **Why records go missing.** The failure handling is containment; the cause of the missing records it was built for hasn't been found. - **Docs.** This belongs in the Persistence docs (Local Object Pools) as a description, with this page reduced to the remaining items. - **Old scaffolding.** The commented-out `setIsLazy(true)` in `SvStorableNode` and its comment, and the commented-out `hasBeenLoaded` slot in `SvJsonGroup`, predate this design and can go. - **Choosing what to make lazy.** Today it's per slot, chosen from a histogram of records by class. A framework default (for example, lazy subnodes for every windowed or pool-backed collection) hasn't been considered. ## Relationship to Other Plans - [Async Final Initialization](../Async%20Final%20Initialization/) was the other answer to "an object isn't ready yet". Synchronous materialization removed its main case. - [Promise-Wrapped Slots](../Promise-Wrapped%20Slots/) cache values that are *computed* asynchronously; lazy slots defer *loading* stored ones. They don't overlap now that loading is synchronous. - [Async Navigation](../Async%20Navigation/) assumed lazy loading would be async. It isn't, which removes one of its motivations. --- Source: /docs/Plans/Meta%20Plan/ # Meta Plan The order to do the other plans in, why, and what should change in them first. **As of:** 2026-11-15. Every plan page now opens with a status line; this page orders them. Steps 1 to 3 are done. ## Where Things Stand | Plan | State | Note | | --- | --- | --- | | [Complete Protocols](../Complete%20Protocols/) | Done | Defaults on base classes, `SvJsonSerializableProtocol`, and a ratchet test. | | [Lazy Slots](../Lazy%20Slots/) | Shipped | Rewritten to describe what shipped; a few items remain. | | [Async Final Initialization](../Async%20Final%20Initialization/) | Closed | Its main case was solved by manifests and then lazy loading. | | [Naked Objects Issues](../Naked%20Objects%20Issues/) | Done | Every listed class moved; the ratchet test's baseline is empty. Two gaps stay open until needed. | | [Cleanup Notes](../Cleanup%20Notes/) | Opportunistic | The runtime-risk items are fixed; the rest are for when a file is being changed anyway. | | [Promise-Wrapped Slots](../Promise-Wrapped%20Slots/) | Core done, unused | One shared promise per value, retry after failure, recompute on a dependency change; no slot uses it yet. | | [Capabilities & Permissions](../Capabilities%20%26%20Permissions/) | Next | Rewritten to build on the editability cascade and the Record Store. | | [JSON Schema](../JSON%20Schema/) | Next | Now includes validation; constraints warn on load and reject edits. | | [Browser Cleanup](../Browser%20Cleanup/) | Next | Now holds the compaction notes; has its own order. | | [Tile Container Views](../Tile%20Container%20Views/), [Tile Views](../Tile%20Views/) | Later | Wait on compaction. Large collections rewritten around windowed collections. | | [Accessibility Testing & Tuning](../Accessibility%20Testing%20%26%20Tuning/) | Ongoing | Automated checks now; manual passes after the navigation work. | | [Case Studies](../Case%20Studies/) | Later | Contacts can run early. | | [Emergent Capabilities](../Emergent%20Capabilities/) | Ideas | Each candidate now points to the plan that takes it. | | [Async Navigation](../Async%20Navigation/), [Graph Database](../Graph%20Database/) | Directions | No work planned. | ## Recommended Order ### 1. A test runner — done (2026-11-15) `npm test` (or `just test`) rebuilds `build/_index.json`, then runs every `tests/headless/Test*.js` in its own process, one at a time, with a timeout each; arguments filter by file name (`npm test -- Record`). The tests share LevelDB databases under `data/leveldb/`, so they can't run in parallel. The first full run found one flaky test, `TestWindowedCollections`: classic-level's `close()` resolves before LevelDB lets go of its files, so a quick reopen sometimes failed. `SvIndexedDbFolder` now retries such an open briefly, and the test's sleeps are gone. All 73 tests pass, in about 40 seconds. ### 2. The model/view boundary — done (2026-11-15) [Naked Objects Issues](../Naked%20Objects%20Issues/): add the environment accessors and view actions, move the nine classes onto them, then add the ratchet test. The list is short, and the headless and swappable-UI claims depend on it. ### 3. Runtime-risk fixes — done (2026-11-15) - `markPid()` is iterative ([Cleanup Notes](../Cleanup%20Notes/#can-fail-at-runtime)). - A promise-wrapped slot's cached promise is cleared when it fails ([Promise-Wrapped Slots](../Promise-Wrapped%20Slots/#error-recovery)). Its getter had never worked; the feature was then finished properly (one promise every caller shares), though nothing uses it yet. The rest of Cleanup Notes is for when a file is being changed anyway. ### 4. Capabilities & Permissions The most user-facing value: the failure it describes is silent data loss. Its first step (making title editing, inspector editing and drops consult `offersUserEdit()`) is small and fixes that failure on the UI side; the pool-level answer and the denial path follow. ### 5. JSON Schema and validation Additive, and tighter schemas improve AI tool calls at once. Start by emitting the `minimum` / `maximum` annotations that the ARIA code already reads. ### 6. Browser Cleanup In its own order: one navigation entry point, the compaction coordinator, composable breadcrumbs, the auxiliary view. ### 7. Tile Container Views and Tile Views After the compaction coordinator. Meter and badge tiles can be done at any point. ### 8. Accessibility Automated checks alongside step 1; manual passes after steps 6 and 7. ### 9. Case Studies Contacts can run as early as step 2, as a gap-finder; what it finds comes back to this page. The rest once their features exist. ## Not Yet Plans - **Undo / redo** has no other home. Write it as its own plan when wanted, built on slot-change notifications and `pool.transaction()`. - **Schema migration.** Class renames are handled (`classNameConversionMap()`); slot type changes and custom migrations aren't. Write a plan when a real type change needs it, taking in the migration item from Emergent Capabilities. - **Choosing lazy slots by default** (from [Lazy Slots](../Lazy%20Slots/#what-remains)): whether windowed or pool-backed collections should be lazy without being asked. --- Source: /docs/Plans/Naked%20Objects%20Issues/ # Naked Objects Issues Known places where framework model classes still cross the model/view boundary — touching view classes, browser globals, or UI state — plus the framework gaps that force such crossings. **Status:** done for framework model code (2026-11-15): every class below is moved, and the ratchet test's baseline is empty. Two gaps remain open (a viewport accessor, a platform client id); close them when a model needs them. The browser-side changes were checked headless only. The target is the model/view separation and **Platform Abstraction** rules in the framework guide (see [App Lifecycle](../../Lifecycle/App%20Lifecycle/index.html)): a model (`SvNode` and subclasses) should never reach into `document` / `window` / `navigator` / `localStorage` or reference view classes, so it stays headless-clean and the UI platform stays swappable. ## Framework model classes still touching the platform | Class | What it does | Fix | | --- | --- | --- | | `SvErrorReport` | Read `navigator.userAgent`, `window.location`, `document.referrer` for a report | **Done:** `SvPlatform.userAgent()`, `pageUrl()`, `referrer()` | | `SvFirestoreNode` | Read `window.location.hostname` and set a `window.__uo_firestore_emulator_configured__` flag | **Done:** the host from `SvPlatform.pageUrl()`; the configured databases in a `WeakSet` on the class | | `SvAiParsedResponseMessage_parsing` | `document.createElement("div")` to find tags in HTML content | **Done:** the code was already commented out; deleted | | `SvFirebaseFile` | `window.open(url)` | **Done:** posts `onRequestOpenUrl({ url })`; the user interface's `openUrl()` opens it (headless logs it) | | `SvOpenAiStyleTransfer` | Built a file `` to pick an image | **Done:** `await userInterface().asyncPickFile({ accept })` — a `File`, or null when the user cancels (the old code never settled on cancel) | | `SvDefaultProxyServer` | Read `window.location` for its default config | **Done:** `configDictForPageUrl(SvPlatform.pageUrl())` | | `SvApp.hardReloadForDataReset()` | `window.location.reload()` (guarded, no-op headless) | **Done:** the user interface's `reloadApp()` | | `SvXhrRequest` | Read `window.location.protocol` to explain a failed request from `file:` | **Done:** `SvPlatform.pageUrl()` (null headless) | | `SvgIconNode.svgIconView()` | Created an `SvgIconView` (its own TODO said so) | **Done:** it and `SvIconResources.iconWithName()` were unused — `SvgIconView.setIconName()` already finds the node; both deleted | | `SvApp` | `localStorage` for the clear-on-boot flag, accepted reset epochs and boot store stats | **Done:** the user interface's `deviceValue()`. The web UI adopts a value still stored under its bare key (the old format) and moves it, so a pending flag or an accepted epoch survives; `tests/headless/TestDeviceValues.js` covers it | | `SvErrorImageResolver` | Read `window.location.origin` | **Done:** `SvPlatform.pageUrl()` | `SvResourceManager` also reads `sessionStorage`, but it runs at boot, below the model layer, so it is outside this rule. ## Framework gaps to close These abstractions would let model code — framework *and* app — stay on the right side of the boundary: - **Environment info** — **done:** `SvPlatform.pageUrl()` (a `URL`, null headless), `userAgent()` and `referrer()`. On `SvPlatform` rather than the user interface: it lives in boot, so it is there before `SvApp` exists (an error report at boot needs it), and models already ask it `isOnline()`. - **Platform-provided client/device id** — one environment accessor instead of each model reading `sessionStorage`. - **View-layer actions** — **done:** open a URL (`onRequestOpenUrl` note → `openUrl()`), pick a file (`asyncPickFile()`), write to the clipboard (`asyncCopyText()`, already there). A download is an open URL until something needs more. - **Reload** — **done:** the user interface's `reloadApp()` (it existed; `SvApp` now uses it). - **Viewport accessor** — models that need size should receive it from the view rather than reading `window.innerWidth` / `devicePixelRatio`. - **User alerts** — already available: post `onRequestUserAlert` and the UI presents it (panel in the browser, log headless). Models should use it instead of `window.alert`. Closing these unblocks the same cleanups in any app built on STRVCT. ## Keeping it from coming back **Done:** `tests/headless/TestPlatformGlobalsInModels.js` scans `source/library/` (skipping `view/`, `node_views/`, `node/app/ui/`, `browser-only/` and `_unused/`, and comments) for `window.`, `navigator.`, `localStorage`, `sessionStorage` and `document.` followed by a DOM member, so a local variable called `document` doesn't count. It fails on any use its baseline (`tests/headless/fixtures/platformGlobalsInModels.json`) doesn't list, and says when the baseline can shrink. Low-level platform utilities are not model code reading UI state, and the test's `ALLOWED` table lists them with a reason each: canvas work in `Image_ideal`, `SvImageBorderRemover` and `SvImageMosaic`; HTML parsing in `String_ideal`; `AudioContext` in `SvSimpleSynth` and `SvWaContext`; `document.fonts` in `SvFont`; DOM output in `SvHtmlStreamReader`. Two had a native global that works in both environments and moved to it: `Object_puuid` uses `globalThis.crypto` and `String_ideal` uses `btoa` / `atob` (which threw headless before). Nothing was reimplemented. --- Source: /docs/Plans/Promise-Wrapped%20Slots/ # Promise-Wrapped Slots Automatic async getter generation with promise caching and dependency-driven invalidation. **Status:** the core contract is done and tested (2026-11-15): one promise per value that every caller shares, a computed `null` is a value, a failure is retried, and a dependency change mid-computation hands the waiting callers the new value. Nothing uses it yet: no slot in the framework or the app sets `setIsPromiseWrapped(true)` (until that date the generated getter threw on its first call). View states, persistence and dependency chains, below, wait for a first adopter. ## Context Many slots need to compute their value asynchronously — fetching a URL, querying a database, calling an API. The naive approach is to write a one-off async getter for each such slot, but this leads to repeated boilerplate and easy-to-miss edge cases: what if multiple callers request the value before the first computation finishes? What if a dependency changes and the cached value is stale? Promise-wrapped slots formalize these patterns at the slot level, so that any slot can opt into async computation with built-in promise deduplication and dependency invalidation. ## The Idea Mark a slot as promise-wrapped: ```javascript { const slot = this.newSlot("publicUrl", null); slot.setIsPromiseWrapped(true); slot.setPromiseResetsOnChangeOfSlotName("dataUrl"); } ``` This generates: - **`asyncPublicUrl()`** — returns *the* promise for the value. The first call starts the computation; every later call, during the computation or after it, gets that same promise. - **`asyncComputePublicUrl()`** — a method the class must implement, containing the actual async logic. - **`_publicUrlPromise`** — a private property holding the shared `Promise.clone()` instance. The promise is the cache. - **`didUpdateSlotDataUrl()`** — an auto-generated hook that resets the value when the `dataUrl` slot changes. The contract: - **A computed `null` is a value.** The promise, not a non-null value, says "computed", so `null` is not computed again. - **A failure is forgotten.** The callers waiting on it are rejected; the next call computes again. - **A reset while computing rejects nobody.** The stale computation's result is dropped, a new one starts, and the callers already waiting get the new value from the promise they hold. A reset after the computation clears the value, and the next call computes. - **A value set with the setter is the value.** `asyncPublicUrl()` resolves to it without computing, so a loaded or assigned value is respected. ## Implementation `Slot_promiseWrapper.js`, a category on `Slot`: - **`isPromiseWrapped`** — boolean flag on `Slot`. When true, `setupPromiseWrapperIfNeeded()` (called from `Slot.setupGetter()`) installs the async getter beside the synchronous one. - **`wrappedPromiseOn(instance)`** — what the async getter returns: the shared promise if it still stands (`wrappedPromiseIsCurrentOn()`: pending, or resolved to the value the slot holds now), else a new one, resolved at once when the value was set directly and otherwise computing. - **`asyncComputeForWrappedPromise(instance, promise)`** — runs `asyncCompute{SlotName}()` and settles the promise. Each run takes a number (`_publicUrlRun`); a run that is no longer the latest when it finishes is ignored, result or error. - **`resetWrappedPromiseOn(instance)`** — forgets the value. With a computation running it starts a new one for the same promise; otherwise it clears the promise. - **`promiseResetsOnChangeOfSlotName`** — optional string naming a dependency slot; installs a `didUpdateSlot{Name}` method that calls the reset. The pattern relies on STRVCT's extended `Promise` class (`Promise_ideal.js`), which adds `callResolveFunc()`, `callRejectFunc()` and `isCompleted()` to native promises via `Promise.clone()`. `tests/headless/TestPromiseWrappedSlots.js` checks each line of the contract. ## Current Usage - **None.** An earlier version of this page named `SvActorMessage`; no such class exists. - **`SvImageNode`** — has commented-out promise wrapping on `publicUrl` and related slots, suggesting the pattern was tested there but not yet production-ready. ## Challenges to Solve ### Null as Sentinel **Solved (2026-11-15).** The promise is the cache, so a computed `null` is not computed again. One trace remains: a slot whose value is `null` and which has no promise is "not computed", so a `null` *assigned with the setter* still computes on the first call. ### Error Recovery **Solved (2026-11-15).** A failed computation rejects the callers waiting on it and clears the promise, so the next call computes again. The first version of the fix found a worse bug underneath: the getter never created the promise it resolved, so every first call threw. A retry policy (backoff, attempt limits) can come later if a caller needs one. ### Reset While Computing **Solved (2026-11-15).** It used to reject the waiting callers with "reset before completion", which made every caller write retry logic for a change it had not caused. Now the stale result is dropped and the same promise resolves with the value for the new dependency. ### Interaction with View Sync Views that display a promise-wrapped slot's value need to handle three states: no value yet, loading, and loaded. The current view sync system triggers on `didUpdateSlot`, which fires when the setter is called after successful computation — so views update correctly on success. But there's no notification for "computation started" or "computation failed," making loading indicators and error states harder to implement. ### Ordering with Persistence If a promise-wrapped slot is also stored (`setShouldStoreSlot(true)`), the persistence system may serialize `null` (the pre-computation value) to storage. On reload, the slot starts as `null` and recomputes — which may be correct (the value is derived) or wasteful (the value could have been cached). There's no current mechanism to distinguish "not yet computed" from "computed and found to be null" in the stored record. ### Cascading Dependencies `promiseResetsOnChangeOfSlotName` handles one level of dependency. If slot A depends on slot B which depends on slot C, changes to C don't automatically propagate to A. A chain or graph of dependencies would be more general but significantly more complex. ## Relationship to Shared Promises [Shared promises](../../Programming%20Idioms/Async%20Patterns/index.html) (`Object_sharedPromises.js`, 2026-11-15) do the same sharing for *work* named by a method: load once, refresh one at a time. The framework and app code that hand-kept a `fooPromise` moved to those, not to promise-wrapped slots, because nearly all of it performs an action rather than computing a slot's value. Promise-wrapped slots remain for a derived value that lives in a slot and resets when a dependency changes. The two are separate implementations: the slot wrapper's reset keeps the promise its callers hold and settles it with the recomputed value, which needs a promise it settles itself. ## Relationship to Lazy Slots [Lazy slots](../Lazy%20Slots/) defer *loading* a stored object; promise-wrapped slots defer *computing* a derived value. Lazy slots shipped with a synchronous getter (a pool's records are in memory), so the two no longer need to share an async getter, and a slot can be both without coordination. ## Open Questions - Should the promise wrapper support configurable retry on failure? - Should there be a synchronous `hasComputedPublicUrl()` predicate so views can check without triggering computation? - How should promise-wrapped slots interact with JSON serialization — should derived values be excluded from `serializeToJson()` by default? - Could the dependency system be extended to handle multiple dependencies or dependency chains? - When the setter assigns a value while a computation is running, the computation's result replaces it. Should the assigned value win instead? --- Source: /docs/Plans/Tile%20Container%20Views/ # Tile Container Views Layout strategies for presenting a node's subnodes. **Status:** open. Waits on the compaction coordinator in [Browser Cleanup](../Browser%20Cleanup/), which gives containers the width extension points they need. **Order:** `setNodeTilesViewClass()` and the wrapping grid, then the table, then scrolling over windowed collections; the search and filter chrome takes the Search & Filtering item from [Emergent Capabilities](../Emergent%20Capabilities/). Each container gets its ARIA roles when it is written, not later. ## Context STRVCT's view architecture has two distinct roles: **tile views** present an individual subnode (its fields, label, appearance), while **tile container views** arrange the array of subnodes spatially and provide uniform interaction (selection, reordering, drill-in, drag-and-drop). Because the framework generates views from model metadata, adding a new container makes it instantly available to any node that opts in -- the same leverage that makes accessibility and i18n automatic. ## Existing Container ### Linear List (`SvTilesView`) The framework's current tile container, which lays out subnodes as a linear array -- vertical (top to bottom) or horizontal (left to right), controlled by the parent `SvStackView`'s direction. This covers most navigation and form-based interfaces. Each subnode is rendered as a tile; the container handles selection, keyboard navigation, reordering, and drill-in. ## Proposed Containers ### Wrapping Grid A container that flows tiles into rows (or columns), wrapping at the container edge. Useful for image galleries, icon grids, card collections, and any set of uniformly-sized items where the count varies. The node would opt in via something like `setNodeTilesViewClass(SvGridTilesView)` and optionally hint at minimum tile width. The grid container handles layout; each cell is still a standard tile -- so selection, drag-to-reorder, and accessibility carry over. ### Spatial Map A pannable, zoomable 2D surface with an optional background image. Subnodes report their positions and are rendered as markers or pins at arbitrary coordinates on the surface. Useful for world maps, dungeon maps, floor plans, relationship diagrams, and any visualization where items exist at continuous positions on a backdrop. The container would support scroll, drag-to-pan, pinch-to-zoom, and mouse-wheel zoom gestures (extending the existing gesture recognizer system). Subnodes would store position in slot annotations (e.g. `setAnnotation("x", 120)`, `setAnnotation("y", 340)`) and the container reads these to place tiles absolutely. Positions could be 2D or potentially 3D (with a projection). The interaction model is navigating *within* a viewport -- the user moves around the map to find things. ### Grid Map A structured grid where each subnode requests a discrete cell position and its tile fills that cell (or spans a rectangle of cells). Useful for tactical battle maps, inventory grids, seating charts, tile-based level editors, and scheduling layouts. Unlike the spatial map, the grid has cell identity -- each position is a discrete slot in the layout. This changes the interaction model: dragging a node between cells is a structured move operation (snapping to grid positions, validating placement rules, swapping or shifting occupants), not a free-form repositioning. Selection, adjacency, and pathfinding queries are natural on a grid but awkward on a continuous surface. The grid may also support cell-level styling (highlighting, coloring regions) and structured keyboard navigation (arrow keys move between cells). While a grid could technically be a special case of a spatial map with snap-to-grid, the interaction patterns diverge enough -- discrete drag-and-drop between cells, cell-based selection and navigation, occupancy rules -- that they likely warrant separate container classes with different gesture handling and different ARIA roles (`grid` + `gridcell` vs. a spatial landmark). ### Table A dense tabular layout where each subnode is a row and its field slots become columns. Field tiles already parse key/value pairs; a table container would render the same data in a compact grid. Column headers would derive from slot names, sortability from slot types. ### Chart A container that renders subnodes as data series in a chart (bar, line, scatter, etc.). The node's slot metadata (type, min, max, description) already provides enough information to auto-generate axis labels and scales -- the same annotations that drive JSON Schema and ARIA attributes. ## Design Considerations - **Opt-in per node**: Nodes select their container via a new `setNodeTilesViewClass()`. The default remains `SvTilesView`. - **Tile reuse**: Each cell, marker, row, or data point should still be a tile (or tile subclass) so that selection, gestures, theming, and accessibility work without reimplementation. - **Stack composability**: New containers should compose within the existing stack navigation model -- drilling into a grid cell or map marker opens the next column just as drilling into a list tile does. - **Responsive behavior**: Containers should adapt to their available size, reflowing or scrolling as needed. The existing `SvNavView` width management and compaction logic would need extension points. - **Accessibility**: Each container needs appropriate ARIA roles (e.g. `grid`, `table`, `img` for canvas) following the same pattern as the `SvNodeView_accessibility` category. - **User-switchable containers**: Nodes could declare a set of supported container views, and the UI would offer a control (e.g. a segmented toggle or menu in the nav header) for the user to switch between them at runtime -- viewing the same subnodes as a list, then as a grid, then as a table. The selected container preference could be persisted per node or per node class. The node would provide the list of appropriate container options (e.g. via `nodeAlternativeTilesViewClasses()`) so the UI only presents choices that make sense for that data -- a collection of images might offer list and grid, while a dataset might offer list, table, and chart. The switcher control would only appear when the node declares more than one option. ## Container Chrome Beyond the tile area itself, containers could support optional header and footer regions with standard affordances: - **Search & filter (header)**: A search field in the container header that filters visible subnodes by matching against node titles, slot values, or other metadata. The container would accept a filter predicate and re-render only matching tiles. For structured data, this could extend to faceted filtering (e.g. filter by slot type or annotation value). - **Create new item (footer)**: A persistent affordance at the bottom of the container for adding a new subnode -- similar to the "+" pattern in list UIs. The container would delegate creation to the parent node, which knows what subnode type to instantiate. This keeps the container generic while letting the node control the semantics. ## Scaling to Large Collections The current `SvTilesView` makes a tile for every loaded subnode. That is fine for typical hierarchies, and the data side of large collections now exists: a collection that declares `setSubnodesAreWindowed(true)` keeps its membership in the store and loads windows of it (`loadLatestWindow()`, `loadOlderWindow(limit)`), synchronously, since a pool's rows are in memory. What's missing is the container side: - **Loading on scroll.** Scrolling near the oldest loaded tile should call `loadOlderWindow()`, so the container, not each app, pages through a windowed collection. Today the app asks for older windows itself. - **Virtual scrolling.** Only tiles in or near the viewport are built; as the user scrolls, tiles are reused for other subnodes. This needs a fixed or measured-once tile height (see the DOM read/write rules: no measuring per scroll event). - **Search as primary navigation.** When a collection is too large to browse, search becomes the entry point. Windowed collections would need a query on the store (by title or slot value) rather than loading everything to filter it. - **Automatic grouping.** For very wide collections, the node (or container) could group subnodes into intermediate levels by a property (alphabetical buckets, category, date range), computed from the store's sort order, so no level shows an overwhelming number of tiles. - **Remote sources.** A collection that lives on a server rather than in a pool is the one case that is truly async. It is [Async Navigation](../Async%20Navigation/)'s territory, and not planned. --- Source: /docs/Plans/Tile%20Views/ # Tile Views Tile subclasses for presenting individual subnodes in specialized ways. **Status:** open. The meter and badge tiles are small and can be done any time; the rest follow [Tile Container Views](../Tile%20Container%20Views/), since they're most useful in grids and tables. Prefer a node hint the generic tile reads over a new tile class where the difference is only appearance (see the framework guide: a custom view class is the last resort). ## Context STRVCT's view architecture has two distinct roles: **tile container views** arrange the array of subnodes spatially (see [Tile Container Views](../Tile%20Container%20Views/)), while **tile views** present an individual subnode -- its content, appearance, and interaction affordances. Nodes select their tile class via `setNodeTileClass()`. All tiles inherit the standard tile infrastructure -- selection, theming, gestures, accessibility -- and add domain-specific rendering. ## Existing Tiles ### Base Tiles | Class | Extends | Purpose | |---|---|---| | `SvTile` | -- | Base navigable tile. Supports selection, styling, slide-to-delete, reordering, drag, and close/delete buttons. | | `SvTitledTile` | `SvTile` | Adds title, subtitle, note, note icon, and thumbnail subviews. | | `SvHeaderTile` | `SvTitledTile` | Section header with selectable state and specific theme class. | | `SvTextNodeTile` | `SvTile` | Displays and edits text nodes with a `SvTextView`. | | `SvBreadCrumbsTile` | `SvTile` | Breadcrumb path navigation. | ### Field Tiles | Class | Extends | Purpose | |---|---|---| | `SvFieldTile` | `SvTile` | Key/value field with label and value areas. Syncs ARIA from slot metadata. | | `SvStringFieldTile` | `SvFieldTile` | Text input field. | | `SvPasswordFieldTile` | `SvStringFieldTile` | Masked password input. | | `SvBooleanFieldTile` | `SvFieldTile` | Checkbox toggle. | | `SvActionFieldTile` | `SvTile` | Clickable button with action handling. | | `SvTextAreaFieldTile` | `SvFieldTile` | Multiline text input with speech-to-text support. | | `SvPointerFieldTile` | `SvTitledTile` | Navigation link with arrow indicator. | ### Media Input Tiles | Class | Extends | Purpose | |---|---|---| | `SvImageWellFieldTile` | `SvFieldTile` | Drag-and-drop image input. | | `SvVideoWellFieldTile` | `SvFieldTile` | Drag-and-drop video input. | | `SvSceneViewWellFieldTile` | `SvFieldTile` | 3D model input (model/* MIME types). | ### Option Tiles | Class | Extends | Purpose | |---|---|---| | `SvOptionsNodeTile` | `SvTitledTile` | Container for selectable options (`role="listbox"`). | | `SvOptionNodeTile` | `SvTitledTile` | Individual selectable option (`role="option"`). | ### Chat Tiles | Class | Extends | Purpose | |---|---|---| | `SvChatMessageTile` | `SvTextAreaFieldTile` | Chat bubble with HTML support, accessibility, and speech capability. | | `SvChatInputTile` | `SvChatMessageTile` | Multiline chat input. | ### Resource Tiles | Class | Extends | Purpose | |---|---|---| | `SvImageTile` | `SvTitledTile` | Image display with caption derived from node title. | | `SvFontTile` | `SvTitledTile` | Font preview showing family, style, weight, and stretch. | ## Proposed Tiles ### Rich Text Tile A tile whose value area supports formatted text (bold, italic, lists, headings) rather than plain text. Useful for notes, journal entries, descriptions, and any long-form content. Would need to bridge the node's value to a contentEditable region with structured markup. ### Media Tile A standalone playback tile that embeds audio or video transport controls (play/pause, scrubbing, volume). The node would reference a sound or video resource; the tile provides the playback UI. Builds on the existing `SvWaSound` infrastructure for audio and could extend to video via standard HTML5 media elements. The existing `SvVideoWellFieldTile` and `SvSceneViewWellFieldTile` handle drag-and-drop *input* of media files. This proposed tile is the complement: *playback* of media already associated with a node. ### Meter / Progress Tile A tile that renders a numeric slot value as a visual meter, progress bar, or gauge. The slot's `minimum` and `maximum` annotations define the range -- the same annotations that already drive `aria-valuemin` / `aria-valuemax`. Useful for hit points, loading progress, skill levels, and any bounded numeric value. ### Badge / Status Tile A compact tile optimized for small status indicators -- an icon plus a short label, possibly color-coded by state. Useful for tags, status markers, notification counts, and online/offline indicators. Would pair well with the wrapping grid container for dense displays. ### Document Tile A tile that composes a node's subnode tree into a rendered document. The subnodes represent the structural elements of a document -- headings, paragraphs, images, code blocks, lists -- each as an independent node with its own metadata. The document tile walks this subtree and renders the composed result inline as formatted HTML or markdown. The structural editing happens in the normal tile container: subnodes appear as draggable tiles that can be reordered, added, or removed. The document tile provides the complementary view -- the same content rendered as a reader would see it. A node could support both views (structural and composed) via the user-switchable container mechanism described in [Tile Container Views](../Tile%20Container%20Views/), letting the user toggle between editing the structure and previewing the document. Use cases include blog posts, reports, style guides, documentation pages, and any content where the author benefits from structural manipulation (drag a section to a new position, tag individual blocks with metadata, collapse sections) but the reader needs a coherent rendered document. ### Embed Tile A tile that renders an iframe or sandboxed external content. The node provides a URL; the tile handles sizing, loading states, and security boundaries. Useful for embedding external widgets, previews, or third-party content within the node hierarchy. ## Design Considerations - **Slot-driven rendering**: New tiles should derive their behavior from slot metadata wherever possible (type, annotations, description), keeping domain objects declarative rather than view-aware. - **Tile class selection**: Nodes opt in via `setNodeTileClass(SvImageTile)` etc. The framework's existing view-discovery mechanism handles the rest. - **Accessibility**: Each new tile needs appropriate ARIA roles and state, following the `SvNodeView_accessibility` pattern. For example, a meter tile would use `role="meter"` with `aria-valuemin`, `aria-valuemax`, and `aria-valuenow`. - **Composability with containers**: New tile types should work in any container -- a media tile in a list, an image tile in a wrapping grid, a badge tile in a spatial map. --- Source: /docs/Programming%20Idioms/ # Programming Idioms Recurring patterns and conventions for writing STRVCT code. - Style Guide - Async Patterns - Categories - Protocols --- Source: /docs/Programming%20Idioms/Async%20Patterns/ # Async Patterns Promise extensions, serial and parallel async array iteration, and error context rethrowing with `Error.rethrow()`. ## Overview STRVCT extends native JavaScript `Promise` and `Array` prototypes via categories (`Promise_ideal.js`, `Array_promises.js`) to provide clean, chainable asynchronous primitives without importing external async utility libraries. Array_promises Extensions promiseSerialForEach / Map Promise_ideal Extensions status, timeouts, & clone() Error.rethrow() Context Chained error stack traces Asynchronous array operations execute cleanly in serial sequence or bounded parallel batches without raw promise boilerplate. --- ## Async Array Iteration (`Array_promises.js`) STRVCT adds asynchronous iteration methods directly to `Array.prototype`: ### 1. Serial Execution (`promiseSerialForEach` / `promiseSerialMap`) Executes an async callback for each element in strict sequential order, awaiting each element before starting the next: ```javascript // Executes sequentially await items.promiseSerialForEach(async (item) => { await processItem(item); }); // Maps results sequentially const results = await items.promiseSerialMap(async (item) => { return await fetchDetails(item); }); ``` ### 2. Parallel Execution (`promiseParallelMap`) Executes async callbacks in parallel across all array elements: ```javascript const results = await items.promiseParallelMap(async (item) => { return await fetchDetails(item); }); ``` --- ## Promise Extensions (`Promise_ideal.js`) `Promise_ideal.js` extends `Promise` with status introspection and timeout helpers: ```javascript const promise = Promise.clone(); // Instantiates wrapper promise promise.isPending(); // Returns true while unresolved promise.isResolved(); // Returns true when resolved promise.isRejected(); // Returns true on rejection // Timeout protection await promise.timeout(5000, "Operation timed out after 5s"); ``` --- ## Chained Error Context (`Error.rethrow()`) When catching and rethrowing errors in async pipelines, `Error.rethrow()` preserves the original error stack while adding contextual messages: ```javascript try { await pool.commitStoreDirtyObjects(); } catch (error) { throw Error.rethrow(`Failed to commit object pool ${pool.poolId()}`, error); } ``` --- ## Shared Promises (`Object_sharedPromises.js`) Async work is often asked for by several callers at once: two views want the same image, a button and a timer both refresh a balance, an invite's auto-join races a Join click. Each caller should get the work's promise, not start the work again. Every object (and every class, for static methods) has three methods for this. Each takes a name for the work and a function that does it. ```javascript // ONCE — done one time for the life of the object. asyncLoad () { return this.sharedPromiseNamed("load", () => this.asyncLoadResource()); } // ONE AT A TIME — callers share the run in flight; after it settles, the next call runs again. asyncReadSubnodes () { return this.inFlightPromiseNamed("readSubnodes", () => this.asyncJustReadSubnodes()); } // FRESH — a caller that arrives mid-run is promised the NEXT run, which starts when this one ends. asyncUpdateFresh () { return this.freshPromiseNamed("update", () => this.asyncFetchBalance()); } ``` | Method | A caller during a run gets | After the run succeeds | After it fails | | --- | --- | --- | --- | | `sharedPromiseNamed` | the run's promise | the same promise, forever | forgotten: the next call runs again | | `inFlightPromiseNamed` | the run's promise | forgotten: the next call runs again | the same | | `freshPromiseNamed` | a promise for the next run (shared by all such callers) | the next run starts, if one was asked for | the same | What all three guarantee: - **The run is recorded before the function is called**, and the function is called synchronously. A failure before its first `await` is handled like any other. (A hand-written version that clears its promise in a `catch` inside the async function clears it *before* the caller has stored it, and then caches the failure.) - **Callers hold the one promise for the run.** Nothing else is rejected, so a failure is unhandled only if no caller handles it. - **A run only clears itself.** `forgetSharedPromiseNamed(name)` abandons the work, so the next call starts again; a run still in flight keeps going but can no longer clear or replace a newer one. - **Abandoned work can tell.** The function receives its run, and work that must not complete once abandoned asks `run.isCurrent()` after its awaits: ```javascript asyncJoin () { return this.sharedPromiseNamed("join", (run) => this.asyncConnect(run)); } async asyncConnect (run) { const room = await this.asyncOpenRoom(); if (!run.isCurrent()) { // leave() was called while connecting room.disconnect(); return null; } this.setRoom(room); return room; } leave () { this.forgetSharedPromiseNamed("join"); // … } ``` `hasSharedPromiseNamed(name)` says whether the work is under way (or was done once and kept); `existingSharedPromiseNamed(name)` returns its promise or null, for code that waits on work it does not start. **Choosing.** Use *once* for loading or joining something. Use *one at a time* for a refresh anyone may ask for, and for anything a view's sync calls. Use *fresh* only where the caller needs a result newer than its own call — the balance after a purchase, a write of bytes that replaced the ones being written. Called from a view sync, *fresh* can chain runs forever, because each run's result syncs the view, which asks again. **Not this pattern.** A promise created empty and settled later by an event — `Promise.clone()` used as a signal — is a different thing. And a slot whose *value* is computed asynchronously is a [promise-wrapped slot](../../Plans/Promise-Wrapped%20Slots/index.html), which caches the value in the slot and recomputes when a dependency changes. ## Related Guides - [Categories](../Categories/index.html): Class extension pattern. - [Protocols](../Protocols/index.html): Interface declaration and conformance checking. --- Source: /docs/Programming%20Idioms/Categories/ # Categories Extending existing classes by adding methods from separate files without subclassing. ## Overview Categories allow developers to add methods to an existing class without modifying its original file. Borrowed from Objective-C and Smalltalk traditions, categories are used throughout STRVCT to separate concerns—keeping core class files focused on essential logic while adding specialized behaviors in dedicated extension files. A category is a class that extends the target class but executes **`.initThisCategory()`** instead of `.initThisClass()`. The framework copies the category's prototype and static methods onto the target class's prototype rather than creating a new class entry in the registry. Category Extension File class SvJsonGroup_patches Extends base class .initThisCategory() Executes method merge Method Merge Engine Prototype Methods Copied to base prototype Static Methods Copied to base constructor Target Base Class SvJsonGroup Prototype Gains applyJsonPatches() instanceof Unchanged No extra prototype layer --- ## Defining a Category (`.initThisCategory()`) ```javascript // SvJsonGroup_patches.js — adds JSON Patch methods to SvJsonGroup (class SvJsonGroup_patches extends SvJsonGroup { applyJsonPatches (patches) { // Implementation } applyPatch (operation) { // Single patch operation } }.initThisCategory()); ``` Executing `.initThisCategory()` instructs the class registration system to merge all prototype and static methods into the parent class (`SvJsonGroup`). No new class entry is created in the global class registry. --- ## Naming Conventions & `_imports.json` Order - **File & Class Naming:** Category files and classes use an underscore to separate the target base class name from the category purpose: `SvJsonGroup_patches.js`, `Array_promises.js`, `Promise_ideal.js`. - **Import Dependency Order:** The base class **must** be listed before its category files in `_imports.json`: ```json [ "SvJsonGroup.js", "SvJsonGroup_patches.js", "SvJsonGroup_clientState.js" ] ``` --- ## Extending JavaScript Builtins Categories are used heavily during boot to extend native JavaScript objects without polluting the global scope with global functions: ```javascript // Promise_ideal.js — adds clone(), status tracking, and timeouts (class Promise_ideal extends Promise { static clone () { /* ... */ } callResolveFunc (...args) { /* ... */ } isPending () { /* ... */ } }.initThisCategory()); // Array_promises.js — adds async iteration methods (class Array_promises extends Array { async promiseSerialForEach (aBlock) { /* ... */ } async promiseParallelMap (aBlock) { /* ... */ } }.initThisCategory()); ``` --- ## Category Constraints & Rules 1. **No New Slots:** Categories can only add methods—they **cannot** add new slots via `initPrototypeSlots()`, as prototype slots must be defined during initial class registration. 2. **`instanceof` Compatibility:** `instanceof` checks are completely unaffected. An instance of `SvJsonGroup` answers `true` for `instanceof SvJsonGroup` and does not add a prototype link layer. 3. **Full `this` Access:** Category methods execute with full access to `this` and all slots and methods of the base class. --- ## Related Guides - [Protocols](../Protocols/index.html): Interface declaration and conformance checking. - [Style Guide](../Style%20Guide/index.html): Coding standards and class patterns. --- Source: /docs/Programming%20Idioms/Protocols/ # Protocols Declaring interfaces and verifying conformance at runtime with fail-fast registration checks. ## Overview Protocols are STRVCT's interface system. A protocol defines a set of methods that a class promises to implement. Unlike informal duck-typing (where code checks for individual methods at call sites), protocols name the contract, support inheritance, and verify conformance at class registration time. The defining feature of STRVCT's protocol engine is **fail-fast verification**: when a class declares conformance to a protocol via `addProtocol()`, the framework immediately verifies that all required methods exist. If any method is missing, an error is thrown at startup—moving bugs from rare runtime surprises to instant, deterministic startup failures. Protocol Declaration SvAudioClipProtocol Extends Protocol class .initThisProtocol() Registers interface stubs Implementer Class initPrototype() this.addProtocol(Protocol) Method Implementations play(), stop(), addDelegate() Startup Conformance Check Set Intersection O(1) Verifies required methods Pass or Instant Error Fails fast at boot if missing --- ## Defining a Protocol (`.initThisProtocol()`) A protocol inherits from `Protocol` and declares empty method stubs representing the interface: ```javascript (class SvAudioClipProtocol extends Protocol { play () { } stop () { } addDelegate (audioClipDelegate) { } removeDelegate (audioClipDelegate) { } }.initThisProtocol()); ``` ### Protocol Rules: - Execute `.initThisProtocol()` at class registration. - Class name **must** end with `Protocol` (enforced at startup). - Method bodies are empty stubs defining expected parameters. --- ## Implementing & Verifying a Protocol (`addProtocol`) Implementers call `addProtocol()` inside `initPrototype()`: ```javascript (class SvWaSound extends SvSummaryNode { initPrototype () { this.addProtocol(SvAudioClipProtocol); } play () { // Implementation } stop () { // Implementation } addDelegate (delegate) { // Implementation } removeDelegate (delegate) { // Implementation } }.initThisClass()); ``` --- ## Required and Optional Methods `addProtocol()` checks only a protocol's **required** methods. A protocol names the ones an adopter may leave out with the static `optionalMethodNames()`; by default there are none, so every declared method is required. ```javascript (class SvExampleProtocol extends Protocol { static optionalMethodNames () { return ["describe"]; } play () { } describe () { } }.initThisProtocol()); ``` --- ## Delegate Protocols A **delegate protocol** declares the messages one kind of object sends its delegate through `sendDelegateMessage()`. A delegate implements only the messages it cares about, so a delegate protocol extends `SvDelegateProtocol`, which makes every message optional. Adopting one declares who listens; it never fails. Name a delegate protocol after its sender (`SvHtmlStreamReader` → `SvHtmlStreamReaderDelegateProtocol`), and declare exactly what the sender sends, with the arguments it sends them with: ```javascript (class SvHtmlStreamReaderDelegateProtocol extends SvDelegateProtocol { onHtmlStreamReaderPushNode (reader, node) { } // ... }.initThisProtocol()); ``` The **sender** names its protocol: ```javascript delegateProtocol () { return SvHtmlStreamReaderDelegateProtocol; } ``` and each **delegate** adopts it in `initPrototype()` with `this.addProtocol(SvHtmlStreamReaderDelegateProtocol)`. Two checks keep the declaration and the code from drifting apart: - **At runtime**, `sendDelegateMessage()` warns once per sender class and message when a sender that names a protocol sends a message the protocol does not declare. - **In tests**, `tests/headless/TestDelegateProtocols.js` scans the source. Every message a sender sends must be declared, every declared message must be sent (a declared message nobody sends is an invented interface), and every delegate protocol must be named by a sender. A protocol file loads before any class that adopts it: list it first in its folder's `_imports.json`, or in a folder that loads earlier. --- ## Protocol Verification API | Method | Purpose & Return Value | |---|---| | `addProtocol(protocol)` | Registers the protocol; throws if a required method is missing. | | `conformsToProtocol(protocol)` | `true` if the class has added the protocol. | | `assertConformsToProtocol(protocol)` | Throws if the class has not added the protocol. | | `methodsConformToProtocol(protocol)` | `true` if the object implements every required method. | | `Protocol.protocolMethodNames()` | Every method the protocol declares, including those of ancestor protocols. | | `Protocol.optionalMethodNames()` / `requiredMethodNames()` | The declared methods an adopter may leave out / must implement. | | `Protocol.declaresMethodNamed(name)` | Whether the protocol declares the method (required or optional). | | `Protocol.allProtocols()` | Every protocol class. | --- ## Framework Protocols The protocol files are the source of truth. These are the ones the framework declares: **Capabilities** (every method required, unless marked optional) - **`SvAudioClipProtocol`:** something that plays (`play()`, `stop()`, `addDelegate()`, `removeDelegate()`). - **`SvRecordStoreProtocol`:** a record store: local, memory or cloud. - **`SvProgressiveImageSourceProtocol`:** a node whose image arrives in stages (aspect ratio, preview, working, failed). - **`SvCollapsibleRegionProtocol`:** a region that expands and collapses (`isExpanded()`, `toggleExpanded()`, `collapsibleAxis()`). - **`SvJsonSerializableProtocol`:** a node with a JSON form for AI exchange, import and export (`serializeToJson()`; `deserializeFromJson()` optional, since some nodes are only exported). Adopted by `SvJsonGroup`, `SvJsonArrayNode`, `SvJsonDictionaryNode`, `SvImageNode`, `SvDateNode`, `SvTimeNode` and `SvToolResult`; their subclasses conform through them. An optional hook that most classes don't implement is not a protocol: it is a method on the base class with a default (`cssVariableDict()` returns null, `nodeAcceptsDrop()` false), which classes that care override. Callers then call it without checking whether it exists. See [Complete Protocols](../../Plans/Complete%20Protocols/). **Delegate protocols** (every message optional) | Protocol | Sender | Delegates | |---|---|---| | `SvAudioClipDelegateProtocol` | an audio clip | `SvAudioQueue` | | `SvHtmlStreamReaderDelegateProtocol` | `SvHtmlStreamReader` | `SvAiParsedResponseMessage` | | `SvXhrRequestDelegateProtocol` | `SvXhrRequest` | `SvAiRequest`, `SvFileToDownload` | | `SvAiRequestDelegateProtocol` | `SvAiRequest` | `SvAiResponseMessage` | | `SvConversationMessageDelegateProtocol` | `SvConversationMessage` and its subclasses | `SvConversation` | | `SvImagineProImageGenerationDelegateProtocol` | `SvImagineProImageGeneration` | — | | `SvRzSigServerConnDelegateProtocol` | `SvRzSigServerConn` | — | | `SvRzPeerConnDelegateProtocol` | `SvRzPeerConn` | — | --- ## Related Guides - [Categories](../Categories/index.html): Class extension pattern. - [Style Guide](../Style%20Guide/index.html): Coding standards and conventions. --- Source: /docs/Programming%20Idioms/Style%20Guide/ # Style Guide Coding conventions, self-initializing class patterns, method chaining, and file structure rules across STRVCT. ## Overview STRVCT follows smalltalk-inspired JavaScript coding conventions to ensure codebase consistency, high-signal readability, and predictable framework behavior. --- ## 1. Class Declaration & Self-Registration Pattern Classes are wrapped in IIFE closures and self-register using `.initThisClass()` (or `.initThisCategory()` for categories): ```javascript (class Character extends SvStorableNode { initPrototypeSlots () { { const slot = this.newSlot("name", ""); slot.setSlotType("String"); slot.setShouldStoreSlot(true); slot.setSyncsToView(true); } } initPrototype () { this.setTitle("Character"); this.setShouldStore(true); } init () { super.init(); // Basic instance setup } finalInit () { super.finalInit(); // Post-deserialization relationship wiring } }.initThisClass()); ``` --- ## 2. Naming Conventions - **Class Names:** PascalCase with framework prefix (`SvNode`, `SvStackView`, `SvPersistentObjectPool`). - **Category Files & Classes:** Base class name + underscore + category purpose (`SvJsonGroup_patches.js`, `Array_promises.js`). - **Protocols:** Always end with `Protocol` (`SvAudioClipProtocol`, `SvDragSourceProtocol`). - **Slot Getters & Setters:** Getter matches slot name (`node.name()`); setter prepends `set` (`node.setName("Thorin")`). - **Boolean Methods:** Prepend `is`, `has`, `should`, or `can` (`node.isSubnode()`, `slot.shouldStoreSlot()`, `view.canInspect()`). --- ## 3. Chained Method Setters All configuration setters on views and slots return `this` to allow clean method chaining: ```javascript const view = SvDomView.clone() .setPosition("absolute") .setTop("0px") .setLeft("0px") .setWidth("100%") .setHeight("100%") .setBackgroundColor("#111"); ``` --- ## 4. `_imports.json` Dependency Ordering Every folder specifies its resource list and subfolder dependencies in `_imports.json`. Base class files **must** precede category extensions or subclass files: ```json [ "_css.css", "SvNode.js", "SvNode_subnodes.js", "SvStorableNode.js" ] ``` --- ## Related Guides - [Categories](../Categories/index.html): Extending existing classes via categories. - [Protocols](../Protocols/index.html): Interface declaration and conformance checks. - [Async Patterns](../Async%20Patterns/index.html): Asynchronous array iteration and promise helpers. --- Source: /docs/Reference/ # Reference Class hierarchy, module hierarchy, and protocol definitions. - Classes - Modules - Protocols --- Source: /docs/Reference/Classes/ # Classes Complete class inheritance hierarchy. Two naming conventions appear in this tree: - **Categories** (`BaseClass_suffix.js`, e.g. `Array_ideal`, `SvJsonGroup_patches`) — extend a base class purely to add methods. They share their base's prototype rather than introducing a new type. - **Protocols** (`*Protocol`, e.g. `SvAudioClipProtocol`) — interface-like classes extending `Protocol`, enumerated separately on the [Protocols](../Protocols/) page with their implementors. - Object - [AiParsedResponseMessage_tagEvents](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FParsing%2F-unused%2FAiParsedResponseMessage_tagEvents.js) - Array - [Array_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FArray_ideal.js) - [Array_mutator](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcollections%2FSvHookedArray.js) - [Array_promises](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fcategories%2FArray_promises.js) - [Array_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FArray_store.js) - [SvHookedArray](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcollections%2FSvHookedArray.js) - [SvIndexedArray](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcollections%2FSvIndexedArray.js) - [SvSortedArray](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcollections%2FSvSortedArray.js) - [SvSubnodesArray](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2FSvSubnodesArray.js) - [SvMyArray](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FType.js) - ArrayBuffer - [ArrayBuffer_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FArrayBuffer_ideal.js) - [ArrayBuffer_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FArrayBuffer_store.js) - [SvBase](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvBase.js) - [SvDatabase](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDatabase.js) - [SvDbCache](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbCache.js) - [SvDbColumn](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbColumn.js) - [SvDbDataType](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbDataType.js) - [SvDbRow](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbRow.js) - [SvDbCustomRow](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbCustomRow.js) - [SvDbSchema](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbSchema.js) - [SvDbTable](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbTable.js) - [SvDbCustomTable](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbCustomTable.js) - [SvDbTx](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbTx.js) - [SvHashCache](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvHashCache.js) - [SvIndexedDbFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fserver-only%2FSvIndexedDbFolder.js) - [SvIndexedDbTx](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fserver-only%2FSvIndexedDbTx.js) - [SvMimeExtensions](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2FSvMimeExtensions.js) - [Base](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2FBase.js) - [BaseHttpsServer](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2FBaseHttpsServer.js) - [BaseHttpsServerRequest](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2FBaseHttpsServerRequest.js) - [AcmeChallengeRequest](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2Frequests%2FAcmeChallengeRequest.js) - [FileRequest](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2Frequests%2FFileRequest.js) - [CliWebServer](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2FCliWebServer.js) - [SvBasicJsonRepairShop](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fjson%2FSvBasicJsonRepairShop.js) - [BigInt_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FBigInt_store.js) - Blob - [Blob_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FBlob_ideal.js) - Boolean - [Boolean_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FBoolean_ideal.js) - [Boolean_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2Fliterals%2FBoolean_store.js) - [SvBootLoader](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvBootLoader.js) - [SvBootLoadingView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvBootLoadingView.js) - [SvCliBrowser](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fcli%2Fserver-only%2FSvCliBrowser.js) - [ContentBase](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentBase.js) - [ContentCards](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentCards.js) - [ContentImage](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentImage.js) - [ContentKeyValue](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentKeyValue.js) - [ContentOrderedList](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentOrderedList.js) - [ContentTable](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentTable.js) - [ContentText](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentText.js) - [ContentTimeline](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentTimeline.js) - [ContentToc](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentToc.js) - [ContentUnorderedList](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentUnorderedList.js) - Date - [Date_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FDate_ideal.js) - [Date_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FDate_store.js) - [SvEnumerableWeakMap](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fweak%2FSvEnumerableWeakMap.js) - [SvEnumerableWeakSet](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fweak%2FSvEnumerableWeakSet.js) - Error - [SvAiRequestOverloadedError](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FRequests%2Ferrors%2FSvAiRequestOverloadedError.js) - [Error_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FError_ideal.js) - [Error_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FError_store.js) - [SvJsonPatchError](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2Fpatches%2FSvJsonPatchError.js) - [SvMissingSlotError](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_copying.js) - [FileReader](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fserver-only%2FFileReaderShim.js) - [FontFace](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fserver-only%2FFontFaceShim.js) - [Function_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FFunction_ideal.js) - [SvGlobals](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2FSvGlobals.js) - [HTMLCanvasElement](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fserver-only%2FImageShim.js) - [HTMLElement_textField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2Fbrowser-only%2FHtmlElement_textField.js) - [Image](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fserver-only%2FImageShim.js) - [Image_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FImage_ideal.js) - [Image_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FImage_store.js) - [ImportsIndexer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Findex-builder%2FImportsIndexer.js) - [JSON_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FJSON_ideal.js) - Map - [SvFifoMap](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FSvFifoMap.js) - [SvHookedMap](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcollections%2FSvHookedMap.js) - [Map_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FMap_ideal.js) - [Map_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FMap_store.js) - [SvMarkdownRelative](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fmarkdown%2FSvMarkdownRelative.js) - [SvMarkdownToc](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fmarkdown%2FSvMarkdownToc.js) - [SvMimeTypeDetector](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fmedia%2Fmime%2FSvMimeTypeDetector.js) - [MinimalIndexedDbFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fserver-only%2Ftests%2FMinimalLevelDbWrapper.js) - [Mirror](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FMirror.js) - [MyClass](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FType.js) - [SvMyFunction](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FType.js) - Number - [Number_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FNumber_ideal.js) - [Number_random](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fserver-only%2FNumber_random.js) - [Number_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2Fliterals%2FNumber_store.js) - [Object_boot](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fcategories%2FObject_boot.js) - [Object_categorySupport](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fcategories%2FObject_categorySupport.js) - [Object_class](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_class.js) - [Object_copying](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_copying.js) - [Object_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_ideal.js) - [Object_init](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_init.js) - [Object_mutation](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_mutation.js) - [Object_notification](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_notification.js) - [Object_puuid](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_puuid.js) - [Object_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FObject_store.js) - [Object_timeouts](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_timeouts.js) - [PageIndex](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FPageIndex.js) - [SvPlatform](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvPlatform.js) - [Promise_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fcategories%2FPromise_ideal.js) - [ProtoClass](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproto%2FProtoClass.js) - [SvAsyncTimer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2FSvAsyncTimer.js) - [SvAtomicMap](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fmap%2FSvAtomicMap.js) - [SvBlobPool](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2FSvBlobPool.js) - [SvBroadcaster](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnotification%2FSvBroadcaster.js) - [SvByteFormatter](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fformatters%2FSvByteFormatter.js) - [SvCanvasTextTapeMeasure](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FHelpers%2FTapeMeasures%2FSvCanvasTextTapeMeasure.js) - [SvCssAnimation](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FAttributes%2FSvCssAnimation.js) - [SvCssColor](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FHelpers%2FSvCssColor.js) - [SvDataUrl](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FBrowserDragAndDrop%2FSvDataUrl.js) - [SvDevice](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvDevice.js) - [SvGamePad](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvGamePad.js) - [SvKeyboard](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvKeyboard.js) - [SvKeyboardKey](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvKeyboardKey.js) - [SvMouse](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvMouse.js) - [SvTouchScreen](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvTouchScreen.js) - [SvDevices](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvDevices.js) - [SvDocumentation](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fmisc%2FSvDocumentation.js) - [SvDomBorderRadius](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FAttributes%2FSvDomBorderRadius.js) - [SvDomCssInspector](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FHelpers%2FSvDomCssInspector.js) - [SvDomTextTapeMeasure](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FHelpers%2FTapeMeasures%2FSvDomTextTapeMeasure.js) - [SvDomTransition](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FAttributes%2FSvDomTransition.js) - [SvDomTransitions](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FAttributes%2FSvDomTransitions.js) - [SvElementDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvElementDomView.js) - [SvCssDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvCssDomView.js) - [SvSubviewsDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvSubviewsDomView.js) - [SvListenerDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvListenerDomView.js) - [SvVisibleDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvVisibleDomView.js) - [SvGesturableDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvGesturableDomView.js) - [SvResponderDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvResponderDomView.js) - [SvControlDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvControlDomView.js) - [SvSelectableDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvSelectableDomView.js) - [SvEditableDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvEditableDomView.js) - [SvDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvDomView.js) - [SvCoachMarkView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2Fcoachmarks%2FSvCoachMarkView.js) - [SvDocumentBody](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvDocumentBody.js) - [SvDomView_animations](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvDomView_animations.js) - [SvDomView_browserDragAndDrop](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvDomView_browserDragAndDrop.js) - [SvDragBarView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvDragBarView.js) - [SvFlexDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvFlexDomView.js) - [SvButtonView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvButtonView.js) - [SvTileNoteButtonView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Fsubviews%2FSvTileNoteButtonView.js) - [SvCloseButton](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvCloseButton.js) - [SvgIconView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvgIconView.js) - [SvScrollToBottomButton](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvScrollToBottomButton.js) - [SvStyledDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvStyledDomView.js) - [SvBooleanView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvBooleanView.js) - [SvDragView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvDragView.js) - [SvNodeView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2FSvNodeView.js) - [SvCoachableView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2FSvCoachableView.js) - [SvImageView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2FSvImageView.js) - [SvImageWellView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2FSvImageWellView.js) - [SvNavView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvNavView.js) - [SvNodeView_accessibility](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2FSvNodeView_accessibility.js) - [SvSceneView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSpatial%2FSvSceneView.js) - [SvScrollContentView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvScrollContentView.js) - [SvTilesView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView.js) - [SvTilesView_dragViewProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView_dragViewProtocol.js) - [SvTilesView_gestures](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView_gestures.js) - [SvTilesView_helpers](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView_helpers.js) - [SvTilesView_keyboard](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView_keyboard.js) - [SvTilesView_orientation](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView_orientation.js) - [SvTilesView_selection](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView_selection.js) - [SvTilesView_styling](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView_styling.js) - [SvStackView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvStackView.js) - [SvBrowserView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2FSvBrowserView.js) - [SvTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTile.js) - [SvActionFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvActionFieldTile.js) - [SvBreadCrumbsTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvBreadCrumbsTile.js) - [SvFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvFieldTile.js) - [SvBooleanFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvBooleanFieldTile.js) - [SvImageWellFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvImageWellFieldTile.js) - [SvSceneViewWellFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSpatial%2FSvSceneViewWellFieldTile.js) - [SvStringFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvStringFieldTile.js) - [SvPasswordFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvPasswordFieldTile.js) - [SvTextAreaFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvTextAreaFieldTile.js) - [SvChatMessageTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvChatMessageTile.js) - [SvChatInputTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvChatInputTile.js) - [SvVideoWellFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvVideoWellFieldTile.js) - [SvTextNodeTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTextNodeTile.js) - [SvTile_dragging](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTile_dragging.js) - [SvTile_gestures](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTile_gestures.js) - [SvTile_keyboard](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTile_keyboard.js) - [SvTile_slideGesture](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTile_slideGesture.js) - [SvTile_styling](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTile_styling.js) - [SvTitledTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTitledTile.js) - [SvFontTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ffonts%2FSvFontTile.js) - [SvHeaderTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvHeaderTile.js) - [SvImageTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fimages%2FSvImageTile.js) - [SvOptionNodeTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2Foptions%2FSvOptionNodeTile.js) - [SvOptionsNodeTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2Foptions%2FSvOptionsNodeTile.js) - [SvPointerFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvPointerFieldTile.js) - [SvTileContainer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTileContainer.js) - [SvVideoView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2FSvVideoView.js) - [SvVideoWellView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2FSvVideoWellView.js) - [SvTextView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvTextView.js) - [SvPasswordView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvPasswordView.js) - [SvTileNoteView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Fsubviews%2FSvTileNoteView.js) - [SvTileSubtitleView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Fsubviews%2FSvTileSubtitleView.js) - [SvTileTitleView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Fsubviews%2FSvTileTitleView.js) - [SvOverlayBannerView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvOverlayBannerView.js) - [SvPanelView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvPanelView.js) - [SvScrimView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvScrimView.js) - [SvScrollView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvScrollView.js) - [SvStackScrollView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvStackScrollView.js) - [SvErrorCatalog](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Ferrors%2FSvErrorCatalog.js) - [SvErrorCatalog_auth](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Ferrors%2FSvErrorCatalog_auth.js) - [SvErrorCatalog_configuration](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Ferrors%2FSvErrorCatalog_configuration.js) - [SvErrorDefinition](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Ferrors%2FSvErrorDefinition.js) - [SvErrorImageResolver](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Ferrors%2FSvErrorImageResolver.js) - [SvEventListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2FSvEventListener.js) - [SvEventManager](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2FSvEventManager.js) - [SvEventSetListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2FSvEventSetListener.js) - [SvAnimationListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvAnimationListener.js) - [SvBatteryListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvBatteryListener.js) - [SvClipboardListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvClipboardListener.js) - [SvDocumentListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvDocumentListener.js) - [SvDragListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvDragListener.js) - [SvDropListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvDropListener.js) - [SvFocusListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvFocusListener.js) - [SvGamePadListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvGamePadListener.js) - [SvKeyboardListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvKeyboardListener.js) - [SvMouseListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvMouseListener.js) - [SvMouseMoveListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvMouseMoveListener.js) - [SvScrollListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvScrollListener.js) - [SvSelectListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvSelectListener.js) - [SvSpeechListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvSpeechListener.js) - [SvTouchListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvTouchListener.js) - [SvTouchMoveListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvTouchMoveListener.js) - [SvTransitionListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvTransitionListener.js) - [SvWebSocketListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvWebSocketListener.js) - [SvWheelListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvWheelListener.js) - [SvWindowListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvWindowListener.js) - [SvFirebaseStoragePermissions](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FSvFirebaseStoragePermissions.js) - [SvGamePadManager](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvGamePadManager.js) - [SvGestureManager](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2FSvGestureManager.js) - [SvGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2FSvGestureRecognizer.js) - [SvLongPressGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2FSvLongPressGestureRecognizer.js) - [SvOrientGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2FSvOrientGestureRecognizer.js) - [SvPanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2FSvPanGestureRecognizer.js) - [SvEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2FSvEdgePanGestureRecognizer.js) - [SvBottomEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fview%2FSvBottomEdgePanGestureRecognizer.js) - [SvLeftEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fview%2FSvLeftEdgePanGestureRecognizer.js) - [SvRightEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fview%2FSvRightEdgePanGestureRecognizer.js) - [SvTopEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fview%2FSvTopEdgePanGestureRecognizer.js) - [SvScreenEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fscreen%2FSvScreenEdgePanGestureRecognizer.js) - [SvScreenBottomEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fscreen%2Fsides%2FSvScreenBottomEdgePanGestureRecognizer.js) - [SvScreenLeftEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fscreen%2Fsides%2FSvScreenLeftEdgePanGestureRecognizer.js) - [SvScreenRightEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fscreen%2Fsides%2FSvScreenRightEdgePanGestureRecognizer.js) - [SvScreenTopEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fscreen%2Fsides%2FSvScreenTopEdgePanGestureRecognizer.js) - [SvPinchGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2FSvPinchGestureRecognizer.js) - [SvRotationGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2FSvRotationGestureRecognizer.js) - [SvSlideGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2FSvSlideGestureRecognizer.js) - [SvTapGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2FSvTapGestureRecognizer.js) - [SvgIconCache](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvgIconCache.js) - [SvHtmlStreamReader](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fhtml%2FSvHtmlStreamReader%2FSvHtmlStreamReader.js) - [SvHttpResponseCodes](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fnetworking%2FSvHttpResponseCodes.js) - [SvI18nCache](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fi18n%2FSvI18nCache.js) - [SvI18nStore](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fi18n%2FSvI18nStore.js) - [SvJsonObject](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FSvJsonObject.js) - [SvJsonStreamReader](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fjson%2FSvJsonStreamReader%2FSvJsonStreamReader.js) - [SvNamespaceSearch](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fmisc%2FSvNamespaceSearch.js) - [SvNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fbase%2FSvNode.js) - [SvNode_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2FSvNode_store.js) - [SvTitledNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fbase%2FSvTitledNode.js) - [SvApp](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2FSvApp.js) - [SvErrorReport](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2FSvErrorReport.js) - [SvTranslatableNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fbase%2FSvTranslatableNode.js) - [SvInspectableNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fbase%2FSvInspectableNode.js) - [SvViewableNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fbase%2FSvViewableNode.js) - [SvStyledNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fbase%2FSvStyledNode.js) - [SvBaseNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fbase%2FSvBaseNode.js) - [SvActorMessage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Factor%2FSvActorMessage.js) - [SvActorMessages](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Factor%2FSvActorMessages.js) - [SvActorNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Factor%2FSvActorNode.js) - [SvDataStore](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fnodes%2Finspectors%2FSvDataStore.js) - [SvDayNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Fdate%2FSvDayNode.js) - [SvFontFamily](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ffonts%2FSvFontFamily.js) - [SvHourNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Ftime%2FSvHourNode.js) - [SvI18n](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fi18n%2FSvI18n.js) - [SvI18nService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fi18n%2FSvI18nService.js) - [SvMeridiemNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Ftime%2FSvMeridiemNode.js) - [SvMinuteNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Ftime%2FSvMinuteNode.js) - [SvMonthNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Fdate%2FSvMonthNode.js) - [SvResource](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2FSvResource.js) - [SvFont](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ffonts%2FSvFont.js) - [SvgIconNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ficons%2FSvgIconNode.js) - [SvImage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fimages%2FSvImage.js) - [SvImage_evaluator](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImageEvaluator%2FSvImage_evaluator.js) - [SvJsonResource](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fjson%2FSvJsonResource.js) - [SvURLImage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fimages%2FSvURLImage.js) - [SvWaSound](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fsounds%2FSvWaSound.js) - [SvResourceFile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ffiles%2FSvResourceFile.js) - [SvResourceFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ffiles%2FSvResourceFolder.js) - [SvResourceGroup](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2FSvResourceGroup.js) - [SvFileResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ffiles%2FSvFileResources.js) - [SvFontResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ffonts%2FSvFontResources.js) - [SvIconResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ficons%2FSvIconResources.js) - [SvImageResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fimages%2FSvImageResources.js) - [SvJsonResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fjson%2FSvJsonResources.js) - [SvSoundResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fsounds%2FSvSoundResources.js) - [SvWaContext](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fsounds%2FSvWaContext.js) - [SvYearNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Fdate%2FSvYearNode.js) - [SvStorableNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fnodes%2FSvStorableNode.js) - [SvAiRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FRequests%2FSvAiRequest.js) - [SvAnthropicRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAnthropic%2FSvAnthropicRequest.js) - [SvGeminiRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FSvGeminiRequest.js) - [SvOpenAiRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FSvOpenAiRequest.js) - [SvDeepSeekRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FDeepSeek%2FSvDeepSeekRequest.js) - [SvGroqRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGroq%2FSvGroqRequest.js) - [SvXaiRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FXai%2FSvXaiRequest.js) - [SvAzureService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2FSvAzureService.js) - [SvAzureTtsRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Fspeakers%2Frequests%2FSvAzureTtsRequest.js) - [SvBlobsNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fblobs%2FSvBlobsNode.js) - [SvCreatorNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2FSvCreatorNode.js) - [SvFieldSetNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2FSvFieldSetNode.js) - [SvDataStoreRecord](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fnodes%2Finspectors%2FSvDataStoreRecord.js) - [SvI18nEntry](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fi18n%2FSvI18nEntry.js) - [SvModel](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2FSvModel.js) - [SvOptionNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Foptions%2FSvOptionNode.js) - [SvPrototypesNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2FSvPrototypesNode.js) - [SvResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2FSvResources.js) - [SvRzPeer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzPeer.js) - [SvRzSigServer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServer.js) - [SvRzSigServerConn](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServerConns%2FSvRzSigServerConn.js) - [SvSpatialModelNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSpatial%2FSvSpatialModelNode.js) - [SvSummaryNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2FSvSummaryNode.js) - [SvAiChatModel](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvAiChatModel.js) - [SvAiChatModels](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvAiChatModels.js) - [SvAiConversations](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvAiConversations.js) - [SvAiImageEditor](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FImageEditor%2FSvAiImageEditor.js) - [SvGeminiImageEditor](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FImage%2520Editing%2FSvGeminiImageEditor.js) - [SvGeminiImageScaler](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FImage%2520Upscaling%2FSvGeminiImageScaler.js) - [SvAiPromptComposer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FComposer%2FSvAiPromptComposer.js) - [SvAiService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvAiService.js) - [SvAnthropicService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAnthropic%2FSvAnthropicService.js) - [SvDeepSeekService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FDeepSeek%2FSvDeepSeekService.js) - [SvGeminiService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FSvGeminiService.js) - [SvGroqService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGroq%2FSvGroqService.js) - [SvImagineProService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FSvImagineProService.js) - [SvLeonardoService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FSvLeonardoService.js) - [SvOpenAiService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FSvOpenAiService.js) - [SvXaiService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FXai%2FSvXaiService.js) - [SvAssistantToolKit](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FTools%2FSvAssistantToolKit.js) - [SvAudioQueue](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Faudio%2FSvAudioQueue.js) - [SvAzureLocale](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Flocales%2FSvAzureLocale.js) - [SvAzureLocales](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Flocales%2FSvAzureLocales.js) - [SvAzureSpeaker](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Fspeakers%2FSvAzureSpeaker.js) - [SvAzureSpeakers](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Fspeakers%2FSvAzureSpeakers.js) - [SvAzureTtsRequests](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Fspeakers%2Frequests%2FSvAzureTtsRequests.js) - [SvAzureVoice](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Fvoices%2FSvAzureVoice.js) - [SvAzureVoices](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Fvoices%2FSvAzureVoices.js) - [SvCoachMarkManager](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2FSvCoachMarkManager.js) - [SvCredential](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fcredentials%2FSvCredential.js) - [SvCredentialManager](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fcredentials%2FSvCredentialManager.js) - [SvCredentials](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fcredentials%2FSvCredentials.js) - [SvDateNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Fdate%2FSvDateNode.js) - [SvEvalChecklistItem](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImageEvaluator%2FChecklist%2FSvEvalChecklistItem.js) - [SvEvalChecklistItems](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImageEvaluator%2FChecklist%2FSvEvalChecklistItems.js) - [SvFilesToDownload](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FText%2520to%2520Image%2Ffiles%2FSvFilesToDownload.js) - [SvFileToDownload](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FText%2520to%2520Image%2Ffiles%2FSvFileToDownload.js) - [SvFirebaseNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FSvFirebaseNode.js) - [SvFirebaseFile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FFiles%2FSvFirebaseFile.js) - [SvFirebaseFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FFolders%2FSvFirebaseFolder.js) - [SvFirebaseRootFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FFolders%2FSvFirebaseRootFolder.js) - [SvFirebaseService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FSvFirebaseService.js) - [SvFirebaseStorageService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FSvFirebaseStorageService.js) - [SvFirestoreCollections](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FCollections%2FSvFirestoreCollections.js) - [SvFirestoreDatabaseService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FSvFirestoreDatabaseService.js) - [SvFirestoreDocuments](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FDocuments%2FSvFirestoreDocuments.js) - [SvFirestoreNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FSvFirestoreNode.js) - [SvFirestoreCollection](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FCollections%2FSvFirestoreCollection.js) - [SvFirestoreDocument](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FDocuments%2FSvFirestoreDocument.js) - [SvFirestoreQuery](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FSvFirestoreQuery.js) - [SvFirestoreRoot](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FSvFirestoreRoot.js) - [SvFolderNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2FSvFolderNode.js) - [SvBreadCrumbsNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fapp%2FSvBreadCrumbsNode.js) - [SvGeminiImageEditors](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FImage%2520Editing%2FSvGeminiImageEditors.js) - [SvGeminiImageUpscalings](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FImage%2520Upscaling%2FSvGeminiImageUpscalings.js) - [SvGeminiVideoPrompt](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FText%2520to%2520Video%2FSvGeminiVideoPrompt.js) - [SvGeminiVideoPrompts](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FText%2520to%2520Video%2FSvGeminiVideoPrompts.js) - [SvHomeAssistant](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FAssistants%2FSvHomeAssistant.js) - [SvHomeAssistantFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FSvHomeAssistantFolder.js) - [SvHomeAssistantGroup](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FSvHomeAssistantGroup.js) - [SvHomeAssistantAreas](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FAreas%2FSvHomeAssistantAreas.js) - [SvHomeAssistantDevices](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FSvDevices%2FSvHomeAssistantDevices.js) - [SvHomeAssistantEntities](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FEntities%2FSvHomeAssistantEntities.js) - [SvHomeAssistantStates](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FStates%2FSvHomeAssistantStates.js) - [SvHomeAssistantObject](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FSvHomeAssistantObject.js) - [SvHomeAssistantArea](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FAreas%2FSvHomeAssistantArea.js) - [SvHomeAssistantDevice](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FSvDevices%2FSvHomeAssistantDevice.js) - [SvHomeAssistantEntity](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FEntities%2FSvHomeAssistantEntity.js) - [SvHomeAssistantState](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FStates%2FSvHomeAssistantState.js) - [SvHomeAssistants](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FAssistants%2FSvHomeAssistants.js) - [SvImageEvalChecklistMaker](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImageEvaluator%2FSvImageEvalChecklistMaker.js) - [SvImageEvaluator](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImageEvaluator%2FSvImageEvaluator.js) - [SvImageEvaluators](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImageEvaluator%2FSvImageEvaluators.js) - [SvImageMosaic](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fimage%2FSvImageMosaic.js) - [SvImageMosaics](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fimage%2FSvImageMosaics.js) - [SvImagineProImageGeneration](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FText%2520to%2520Image%2FSvImagineProImageGeneration.js) - [SvImagineProImageGenerations](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FText%2520to%2520Image%2FSvImagineProImageGenerations.js) - [SvImagineProImagePrompt](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FText%2520to%2520Image%2FSvImagineProImagePrompt.js) - [SvImagineProImageEvalPrompt](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImagineProImageEvalPrompt.js) - [SvJsonArchiver](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvJsonArchiver.js) - [SvAiJsonArchiver](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvJsonArchiver.js) - [SvJsonIdNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvJsonIdNode.js) - [SvJsonGroup](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvJsonGroup.js) - [SvBlobNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fblobs%2FSvBlobNode.js) - [SvCloudBlobNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fblobs%2FSvCloudBlobNode.js) - [SvImageNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fimage%2FSvImageNode.js) - [SvVideoNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fvideo%2FSvVideoNode.js) - [SvField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2FSvField.js) - [SvActionField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvActionField.js) - [SvBooleanField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvBooleanField.js) - [SvColorField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvColorField.js) - [SvDateField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvDateField.js) - [SvIdentityField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvIdentityField.js) - [SvImageWellField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvImageWellField.js) - [SvImageField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvImageField.js) - [SvJsonField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvJsonField.js) - [SvArrayField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvArrayField.js) - [SvJsonNullField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2FSvJsonNullField.js) - [SvNumberField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvNumberField.js) - [SvOptionsNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Foptions%2FSvOptionsNode.js) - [SvPointerField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvPointerField.js) - [SvStampField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvStampField.js) - [SvStringField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvStringField.js) - [SvPasswordField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvPasswordField.js) - [SvTextAreaField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvTextAreaField.js) - [SvChatInputNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvChatInputNode.js) - [SvConversationMessage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvConversationMessage.js) - [SvAiMessage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvAiMessage.js) - [SvAiResponseMessage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvAiResponseMessage.js) - [SvAiParsedResponseMessage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FParsing%2FSvAiParsedResponseMessage.js) - [SvAiParsedResponseMessage_parsing](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FParsing%2FSvAiParsedResponseMessage_parsing.js) - [SvAiParsedResponseMessage_streaming](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FParsing%2FSvAiParsedResponseMessage_streaming.js) - [SvAiParsedResponseMessage_voiceNarration](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FParsing%2FSvAiParsedResponseMessage_voiceNarration.js) - [SvUrlField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvUrlField.js) - [SvVideoWellField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvVideoWellField.js) - [SvJsonGroup_patches](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2Fpatches%2FSvJsonGroup_patches.js) - [SvModelReference](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fjson%2FSvModelReference.js) - [SvSyncableJsonGroup](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvSyncableJsonGroup.js) - [SvJsonNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvJsonNode.js) - [SvJsonArrayNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvJsonArrayNode.js) - [SvConversation](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvConversation.js) - [SvAiConversation](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvAiConversation.js) - [SvFirebaseFiles](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FFiles%2FSvFirebaseFiles.js) - [SvFirebaseFolders](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FFolders%2FSvFirebaseFolders.js) - [SvImages](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fimages%2FSvImages.js) - [SvImagesNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fimage%2FSvImagesNode.js) - [SvImagineProImagePrompts](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FText%2520to%2520Image%2FSvImagineProImagePrompts.js) - [SvImagineProImageEvalPrompts](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImagineProImageEvalPrompts.js) - [SvJsonArrayNode_patches](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2Fpatches%2FSvJsonArrayNode_patches.js) - [SvSyncableArrayNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fsyncing%2FSvSyncableArrayNode.js) - [SvJsonDictionaryNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvJsonDictionaryNode.js) - [SvJsonPatchRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FTools%2FJson%2FSvJsonPatchRequest.js) - [SvToolCall](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FTools%2FCalls%2FSvToolCall.js) - [SvToolDefinition](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FTools%2FDefinitions%2FSvToolDefinition.js) - [SvToolDefinition_anthropic](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAnthropic%2FSvToolDefinition_anthropic.js) - [SvLeonardoImage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FText%2520to%2520Image%2Fimages%2FSvLeonardoImage.js) - [SvLeonardoImageGeneration](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FText%2520to%2520Image%2FSvLeonardoImageGeneration.js) - [SvLeonardoImagePrompt](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FText%2520to%2520Image%2FSvLeonardoImagePrompt.js) - [SvLeonardoImagePrompts](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FText%2520to%2520Image%2FSvLeonardoImagePrompts.js) - [SvLeonardoImages](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FText%2520to%2520Image%2Fimages%2FSvLeonardoImages.js) - [SvLeonardoRefImage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FRefImages%2FSvLeonardoRefImage.js) - [SvLeonardoRefImages](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FRefImages%2FSvLeonardoRefImages.js) - [SvLeoStyleTransfer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FStyle%2520Transfers%2FSvLeoStyleTransfer.js) - [SvLeoStyleTransfers](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FStyle%2520Transfers%2FSvLeoStyleTransfers.js) - [SvLinkNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2FSvLinkNode.js) - [SvMusicFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FYouTube%2FMusicPlayer%2FSvMusicFolder.js) - [SvMusicLibrary](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FYouTube%2FMusicPlayer%2FSvMusicLibrary.js) - [SvMusicTrack](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FYouTube%2FMusicPlayer%2FSvMusicTrack.js) - [SvOpenAiImage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FText%2520to%2520Image%2Fimages%2FSvOpenAiImage.js) - [SvOpenAiImagePrompt](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FText%2520to%2520Image%2FSvOpenAiImagePrompt.js) - [SvOpenAiImagePrompts](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FText%2520to%2520Image%2FSvOpenAiImagePrompts.js) - [SvOpenAiImages](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FText%2520to%2520Image%2Fimages%2FSvOpenAiImages.js) - [SvOpenAiStyleTransfer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FStyle%2520Transfers%2FSvOpenAiStyleTransfer.js) - [SvOpenAiStyleTransfers](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FStyle%2520Transfers%2FSvOpenAiStyleTransfers.js) - [SvOpenAiTtsRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FText%2520to%2520Speech%2FSvOpenAiTtsRequest.js) - [SvOpenAiTtsSession](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FText%2520to%2520Speech%2FSvOpenAiTtsSession.js) - [SvOpenAiTtsSessions](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FText%2520to%2520Speech%2FSvOpenAiTtsSessions.js) - [SvPeerService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvPeerService.js) - [SvProxyServer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvProxyServers%2FSvProxyServer.js) - [SvDefaultProxyServer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvProxyServers%2FSvDefaultProxyServer.js) - [SvProxyServers](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvProxyServers%2FSvProxyServers.js) - [SvRzMsg](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServerConns%2FSvRzPeerConns%2FSvRzMsgs%2FSvRzMsg.js) - [SvRzMsgs](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServerConns%2FSvRzPeerConns%2FSvRzMsgs%2FSvRzMsgs.js) - [SvRzPeerConn](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServerConns%2FSvRzPeerConns%2FSvRzPeerConn.js) - [SvRzPeerConns](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServerConns%2FSvRzPeerConns%2FSvRzPeerConns.js) - [SvRzSigServerConns](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServerConns%2FSvRzSigServerConns.js) - [SvRzSigServerPeers](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServerPeers.js) - [SvRzSigServers](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServers.js) - [SvServices](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvServices.js) - [SvSpeechToTextSession](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSpeechToText%2FSvSpeechToTextSession.js) - [SvSpeechToTextSessions](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSpeechToText%2FSvSpeechToTextSessions.js) - [SvSttMessage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSpeechToText%2FSvSttMessages%2FSvSttMessage.js) - [SvSttMessages](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSpeechToText%2FSvSttMessages%2FSvSttMessages.js) - [SvSyncCollectionSource](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fsyncing%2FSvSyncCollectionSource.js) - [SvCloudSyncSource](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fsyncing%2FSvCloudSyncSource.js) - [SvPublicCloudSource](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fsyncing%2FSvPublicCloudSource.js) - [SvLocalResourceSource](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fsyncing%2FSvLocalResourceSource.js) - [SvTimeNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Ftime%2FSvTimeNode.js) - [SvToolCalls](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FTools%2FCalls%2FSvToolCalls.js) - [SvToolDefinitions](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FTools%2FDefinitions%2FSvToolDefinitions.js) - [SvToolResult](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FTools%2FCalls%2FSvToolResult.js) - [SvWaQueue](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fsounds%2FSvWaQueue.js) - [SvTextNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2FSvTextNode.js) - [SvThemeFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvThemeFolder.js) - [SvTheme](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvTheme.js) - [SvDefaultTheme](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvDefaultTheme.js) - [SvThemeClass](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvThemeClass.js) - [SvThemeClassChildren](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvThemeClassChildren.js) - [SvThemeState](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvThemeState.js) - [SvThemeStates](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvThemeStates.js) - [SvThemeResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvThemeResources.js) - [SvUserInterface](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2Fui%2FSvUserInterface.js) - [SvCliUserInterface](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2Fui%2FSvCliUserInterface.js) - [SvHeadlessUserInterface](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2Fui%2FSvHeadlessUserInterface.js) - [SvWebUserInterface](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2Fui%2FSvWebUserInterface.js) - [SvXhrRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FRequests%2FSvXhrRequest.js) - [SvYouTubeAudioPlayer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FYouTube%2FSvYouTubeAudioPlayer.js) - [SvYouTubeService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FYouTube%2FSvYouTubeService.js) - [SvNotification](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnotification%2Fnotifications%2FSvNotification.js) - [SvNotificationCenter](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnotification%2Fnotifications%2FSvNotificationCenter.js) - [SvNumberFormatter](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fformatters%2FSvNumberFormatter.js) - [SvObjectPool](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2FSvObjectPool.js) - [SvPersistentObjectPool](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2FSvPersistentObjectPool.js) - [SvSubObjectPool](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2FSvSubObjectPool.js) - [SvObservableProxy](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproxies%2FSvObservableProxy.js) - [SvFirewallProxy](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproxies%2FSvFirewallProxy.js) - [SvObservation](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnotification%2Fnotifications%2FSvObservation.js) - [SvPersistentAsyncMap](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fstorage%2FSvPersistentAsyncMap.js) - [SvPoint](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fgeometry%2FSvPoint.js) - [SvEventPoint](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvEventPoint.js) - [ProtoClass_protocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fprotocol%2FProtoClass_protocol.js) - [ProtoClass_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2FProtoClass_store.js) - [ProtoClass_tasks](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproto%2Ftasks%2FProtoClass_tasks.js) - [Protocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fprotocol%2FProtocol.js) - [SvAudioClipDelegateProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Faudio%2FSvAudioClipDelegateProtocol.js) - [SvAudioClipProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Faudio%2FSvAudioClipProtocol.js) - [SvDragDestinationProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvDragDestinationProtocol.js) - [SvDragSourceProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvDragSourceProtocol.js) - [SvRectangle](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fgeometry%2FSvRectangle.js) - [SvSimpleSynth](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Faudio%2FSvSimpleSynth.js) - [SvStackFrame](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fmisc%2FSvStackTrace.js) - [SvStackTrace](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fmisc%2FSvStackTrace.js) - [SvStreamNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fhtml%2FSvHtmlStreamReader%2FSvStreamNode.js) - [SvStreamElementNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fhtml%2FSvHtmlStreamReader%2FSvStreamElementNode.js) - [SvStreamTextNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fhtml%2FSvHtmlStreamReader%2FSvStreamTextNode.js) - [SvStyleSheet](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvStyleSheet.js) - [SvSyncAction](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnotification%2FSvSyncAction.js) - [SvSyncScheduler](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnotification%2FSvSyncScheduler.js) - [SvTask](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproto%2Ftasks%2FSvTask.js) - [SvTasks](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproto%2Ftasks%2FSvTasks.js) - [SvThrashDetector](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvThrashDetector.js) - [SvTimeFormatter](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fformatters%2FSvTimeFormatter.js) - [SvTimePeriodFormatter](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fformatters%2FSvTimePeriodFormatter.js) - [SvTransform](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fgeometry%2FSvTransform.js) - [SvTranslationFilter](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fi18n%2FSvTranslationFilter.js) - [SvViewAnimator](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FAttributes%2FSvViewAnimator.js) - [SvWebBrowserBattery](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvWebBrowserBattery.js) - [SvWebBrowserCookie](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvWebBrowserCookie.js) - [SvWebBrowserNotification](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2Fnotifications%2FSvWebBrowserNotification.js) - [SvWebBrowserNotifications](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2Fnotifications%2FSvWebBrowserNotifications.js) - [SvWebBrowserScreen](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvWebBrowserScreen.js) - [SvWebBrowserTab](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvWebBrowserTab.js) - [SvWebBrowserWindow](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvWebBrowserWindow.js) - [SvWebDocument](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvWebDocument.js) - [SvYouTubePlayerFrame](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FYouTube%2FSvYouTubePlayerFrame.js) - [Range](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fserver-only%2FRangeShim.js) - [Range_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FRange_ideal.js) - [RegExp_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FRegex_store.js) - [SvResourceIndexer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Findex-builder%2FSvResourceIndexer.js) - [SvResourceManager](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvResourceManager.js) - [SvResourcesFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Findex-builder%2FSvResourcesFolder.js) - [SvServiceWorker](../../resources/class-doc/class_doc.html?path=%2Fsource%2FServiceWorker%2FSvServiceWorker.js) - Set - [SvHookedSet](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcollections%2FSvHookedSet.js) - [SvImmutableSet](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FSvImmutableSet.js) - [Set_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FSet_ideal.js) - [Set_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FSet_store.js) - [Slot](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproto%2FSlot.js) - [Slot_promiseWrapper](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproto%2FSlot_promiseWrapper.js) - [SvStoreRef](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2FSvStoreRef.js) - String - [String_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FString_ideal.js) - [String_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2Fliterals%2FString_store.js) - [StrvctFile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FStrvctFile.js) - [StrvctFramework](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fmodule%2FStrvctFramework.js) - [Symbol_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FSymbol_store.js) - [TestRunner](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fserver-only%2Ftests%2FSvIndexedDbTests.js) - [Type](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FType.js) - [URL_promises](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fcategories%2FURL_promises.js) - [SvUrlResource](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvUrlResource.js) - [SvWindowErrorPanel](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvWindowErrorPanel.js) - [XMLHttpRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fserver-only%2FXMLHttpRequestShim.js) --- Source: /docs/Reference/Modules/ # Modules Module hierarchy and file organization. - app/json - [SvAiJsonArchiver](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvJsonArchiver.js) - [SvJsonArchiver](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvJsonArchiver.js) - [SvJsonGroup](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvJsonGroup.js) - boot - [Array_promises](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fcategories%2FArray_promises.js) - [SvBase](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvBase.js) - [SvBootLoader](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvBootLoader.js) - [SvBootLoadingView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvBootLoadingView.js) - [SvGlobals](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2FSvGlobals.js) - [SvHashCache](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvHashCache.js) - [SvIndexedDbFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fserver-only%2FSvIndexedDbFolder.js) - [SvIndexedDbTx](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fserver-only%2FSvIndexedDbTx.js) - [Object_boot](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fcategories%2FObject_boot.js) - [Object_categorySupport](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fcategories%2FObject_categorySupport.js) - [Promise_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fcategories%2FPromise_ideal.js) - [SvResourceManager](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvResourceManager.js) - [StrvctFile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FStrvctFile.js) - [URL_promises](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fcategories%2FURL_promises.js) - [SvUrlResource](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvUrlResource.js) - boot/server-only - [SvIndexedDbFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fserver-only%2FSvIndexedDbFolder.js) - [SvIndexedDbTx](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fserver-only%2FSvIndexedDbTx.js) - browser - stack - SvTile - [SvBreadCrumbsTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvBreadCrumbsTile.js) - [SvHeaderTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvHeaderTile.js) - [SvTile_dragging](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTile_dragging.js) - [SvTile_keyboard](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTile_keyboard.js) - [SvTile_slideGesture](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTile_slideGesture.js) - [SvTile_styling](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTile_styling.js) - [SvTitledTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTitledTile.js) - field_tiles - [SvActionFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvActionFieldTile.js) - [SvPasswordFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvPasswordFieldTile.js) - [SvStringFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvStringFieldTile.js) - framework - [StrvctFramework](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fmodule%2FStrvctFramework.js) - globals - [SvActorMessage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Factor%2FSvActorMessage.js) - [SvActorMessages](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Factor%2FSvActorMessages.js) - [SvActorNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Factor%2FSvActorNode.js) - [SvAiParsedResponseMessage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FParsing%2FSvAiParsedResponseMessage.js) - [SvAiParsedResponseMessage_parsing](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FParsing%2FSvAiParsedResponseMessage_parsing.js) - [SvAiParsedResponseMessage_streaming](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FParsing%2FSvAiParsedResponseMessage_streaming.js) - [AiParsedResponseMessage_tagEvents](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FParsing%2F-unused%2FAiParsedResponseMessage_tagEvents.js) - [SvAiParsedResponseMessage_voiceNarration](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FParsing%2FSvAiParsedResponseMessage_voiceNarration.js) - [SvBasicJsonRepairShop](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fjson%2FSvBasicJsonRepairShop.js) - [SvCliBrowser](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fcli%2Fserver-only%2FSvCliBrowser.js) - [SvCliUserInterface](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2Fui%2FSvCliUserInterface.js) - [ContentBase](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentBase.js) - [ContentCards](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentCards.js) - [ContentImage](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentImage.js) - [ContentKeyValue](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentKeyValue.js) - [ContentOrderedList](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentOrderedList.js) - [ContentTable](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentTable.js) - [ContentText](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentText.js) - [ContentTimeline](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentTimeline.js) - [ContentToc](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentToc.js) - [ContentUnorderedList](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FContentUnorderedList.js) - [SvErrorCatalog](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Ferrors%2FSvErrorCatalog.js) - [SvErrorCatalog_auth](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Ferrors%2FSvErrorCatalog_auth.js) - [SvErrorCatalog_configuration](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Ferrors%2FSvErrorCatalog_configuration.js) - [SvErrorDefinition](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Ferrors%2FSvErrorDefinition.js) - [SvErrorImageResolver](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Ferrors%2FSvErrorImageResolver.js) - [SvErrorReport](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2FSvErrorReport.js) - [SvEvalChecklistItems](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImageEvaluator%2FChecklist%2FSvEvalChecklistItems.js) - [SvFifoMap](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FSvFifoMap.js) - [FileReader](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fserver-only%2FFileReaderShim.js) - [SvFilesToDownload](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FText%2520to%2520Image%2Ffiles%2FSvFilesToDownload.js) - [SvFileToDownload](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FText%2520to%2520Image%2Ffiles%2FSvFileToDownload.js) - [FontFace](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fserver-only%2FFontFaceShim.js) - [SvGeminiVideoPrompt](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FText%2520to%2520Video%2FSvGeminiVideoPrompt.js) - [SvHeadlessUserInterface](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2Fui%2FSvHeadlessUserInterface.js) - [HTMLCanvasElement](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fserver-only%2FImageShim.js) - [Image](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fserver-only%2FImageShim.js) - [SvImage_evaluator](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImageEvaluator%2FSvImage_evaluator.js) - [SvImageEvaluators](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImageEvaluator%2FSvImageEvaluators.js) - [SvImages](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fimages%2FSvImages.js) - [JSON_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FJSON_ideal.js) - [SvMarkdownRelative](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fmarkdown%2FSvMarkdownRelative.js) - [SvMarkdownToc](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fmarkdown%2FSvMarkdownToc.js) - [MinimalIndexedDbFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fserver-only%2Ftests%2FMinimalLevelDbWrapper.js) - [SvModel](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2FSvModel.js) - [SvModelReference](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fjson%2FSvModelReference.js) - [Number_random](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fserver-only%2FNumber_random.js) - [PageIndex](../../resources/class-doc/class_doc.html?path=%2Fstyle%2Flayout%2FPageIndex.js) - [SvPlatform](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvPlatform.js) - [Range](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fserver-only%2FRangeShim.js) - [SvServiceWorker](../../resources/class-doc/class_doc.html?path=%2Fsource%2FServiceWorker%2FSvServiceWorker.js) - [TestRunner](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Fserver-only%2Ftests%2FSvIndexedDbTests.js) - [SvToolDefinition_anthropic](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAnthropic%2FSvToolDefinition_anthropic.js) - [SvUserInterface](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2Fui%2FSvUserInterface.js) - [SvWebBrowserTab](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvWebBrowserTab.js) - [SvWebUserInterface](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2Fui%2FSvWebUserInterface.js) - [XMLHttpRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fserver-only%2FXMLHttpRequestShim.js) - IndexBuilder - [ImportsIndexer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Findex-builder%2FImportsIndexer.js) - [SvResourceIndexer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Findex-builder%2FSvResourceIndexer.js) - [SvResourcesFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2Findex-builder%2FSvResourcesFolder.js) - library - app - [SvBreadCrumbsNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fapp%2FSvBreadCrumbsNode.js) - [SvCredentialManager](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fcredentials%2FSvCredentialManager.js) - [SvCredentials](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fcredentials%2FSvCredentials.js) - audio - [SvSimpleSynth](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Faudio%2FSvSimpleSynth.js) - credentials - [SvCredential](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fcredentials%2FSvCredential.js) - i18n - [SvI18n](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fi18n%2FSvI18n.js) - [SvI18nCache](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fi18n%2FSvI18nCache.js) - [SvI18nEntry](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fi18n%2FSvI18nEntry.js) - [SvI18nService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fi18n%2FSvI18nService.js) - [SvI18nStore](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fi18n%2FSvI18nStore.js) - [SvTranslationFilter](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fi18n%2FSvTranslationFilter.js) - ideal - [Array_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FArray_ideal.js) - [ArrayBuffer_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FArrayBuffer_ideal.js) - [Boolean_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FBoolean_ideal.js) - [Date_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FDate_ideal.js) - [Error_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FError_ideal.js) - [Function_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FFunction_ideal.js) - [Image_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FImage_ideal.js) - [SvImmutableSet](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FSvImmutableSet.js) - [Map_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FMap_ideal.js) - [SvMyArray](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FType.js) - [MyClass](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FType.js) - [SvMyFunction](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FType.js) - [Number_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FNumber_ideal.js) - [Range_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FRange_ideal.js) - [Set_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FSet_ideal.js) - [String_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FString_ideal.js) - [Type](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FType.js) - categories - [Blob_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FBlob_ideal.js) - [Mirror](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2FMirror.js) - collections - [Array_mutator](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcollections%2FSvHookedArray.js) - [SvHookedArray](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcollections%2FSvHookedArray.js) - [SvHookedMap](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcollections%2FSvHookedMap.js) - [SvHookedSet](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcollections%2FSvHookedSet.js) - [SvIndexedArray](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcollections%2FSvIndexedArray.js) - [SvSortedArray](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcollections%2FSvSortedArray.js) - formatters - [SvByteFormatter](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fformatters%2FSvByteFormatter.js) - [SvNumberFormatter](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fformatters%2FSvNumberFormatter.js) - [SvTimeFormatter](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fformatters%2FSvTimeFormatter.js) - [SvTimePeriodFormatter](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fformatters%2FSvTimePeriodFormatter.js) - html - SvHtmlStreamReader - [SvHtmlStreamReader](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fhtml%2FSvHtmlStreamReader%2FSvHtmlStreamReader.js) - [SvStreamElementNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fhtml%2FSvHtmlStreamReader%2FSvStreamElementNode.js) - [SvStreamNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fhtml%2FSvHtmlStreamReader%2FSvStreamNode.js) - [SvStreamTextNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fhtml%2FSvHtmlStreamReader%2FSvStreamTextNode.js) - json - SvJsonStreamReader - [SvJsonStreamReader](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fjson%2FSvJsonStreamReader%2FSvJsonStreamReader.js) - map - [SvAtomicMap](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fmap%2FSvAtomicMap.js) - misc - [SvDocumentation](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fmisc%2FSvDocumentation.js) - [SvNamespaceSearch](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fmisc%2FSvNamespaceSearch.js) - [SvStackFrame](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fmisc%2FSvStackTrace.js) - [SvStackTrace](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fmisc%2FSvStackTrace.js) - networking - [SvHttpResponseCodes](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fnetworking%2FSvHttpResponseCodes.js) - object - [SvMissingSlotError](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_copying.js) - [Object_class](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_class.js) - [Object_copying](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_copying.js) - [Object_ideal](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_ideal.js) - [Object_init](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_init.js) - [Object_mutation](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_mutation.js) - [Object_notification](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_notification.js) - [Object_puuid](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_puuid.js) - [Object_timeouts](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fcategories%2Fobject%2FObject_timeouts.js) - proto - [ProtoClass](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproto%2FProtoClass.js) - [ProtoClass_tasks](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproto%2Ftasks%2FProtoClass_tasks.js) - [Slot](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproto%2FSlot.js) - [SvTask](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproto%2Ftasks%2FSvTask.js) - [SvTasks](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproto%2Ftasks%2FSvTasks.js) - protocol - [ProtoClass_protocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fprotocol%2FProtoClass_protocol.js) - [Protocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fprotocol%2FProtocol.js) - proxies - [SvFirewallProxy](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproxies%2FSvFirewallProxy.js) - [SvObservableProxy](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproxies%2FSvObservableProxy.js) - weak - [SvEnumerableWeakMap](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fweak%2FSvEnumerableWeakMap.js) - [SvEnumerableWeakSet](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fweak%2FSvEnumerableWeakSet.js) - image - [SvImageMosaic](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fimage%2FSvImageMosaic.js) - [SvImageMosaics](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fimage%2FSvImageMosaics.js) - media - mime - [SvMimeTypeDetector](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fmedia%2Fmime%2FSvMimeTypeDetector.js) - node - [SvApp](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2FSvApp.js) - [SvAsyncTimer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fapp%2FSvAsyncTimer.js) - audio - [SvAudioClipDelegateProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Faudio%2FSvAudioClipDelegateProtocol.js) - [SvAudioClipProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Faudio%2FSvAudioClipProtocol.js) - [SvAudioQueue](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Faudio%2FSvAudioQueue.js) - blobs - [SvBlobNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fblobs%2FSvBlobNode.js) - [SvBlobsNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fblobs%2FSvBlobsNode.js) - [SvCloudBlobNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fblobs%2FSvCloudBlobNode.js) - fields - [SvCreatorNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2FSvCreatorNode.js) - [SvField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2FSvField.js) - [SvFieldSetNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2FSvFieldSetNode.js) - json - [SvJsonArrayNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvJsonArrayNode.js) - [SvJsonArrayNode_patches](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2Fpatches%2FSvJsonArrayNode_patches.js) - [SvJsonDictionaryNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvJsonDictionaryNode.js) - [SvJsonIdNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvJsonIdNode.js) - [SvJsonNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvJsonNode.js) - [SvJsonNullField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2FSvJsonNullField.js) - [SvJsonPatchError](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2Fpatches%2FSvJsonPatchError.js) - patches - [SvJsonGroup_patches](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2Fpatches%2FSvJsonGroup_patches.js) - subclasses - [SvActionField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvActionField.js) - [SvArrayField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvArrayField.js) - [SvBooleanField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvBooleanField.js) - [SvColorField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvColorField.js) - [SvDateField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvDateField.js) - [SvIdentityField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvIdentityField.js) - [SvImageField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvImageField.js) - [SvImageWellField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvImageWellField.js) - [SvJsonField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvJsonField.js) - [SvNumberField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvNumberField.js) - [SvPasswordField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvPasswordField.js) - [SvPointerField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvPointerField.js) - [SvStampField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvStampField.js) - [SvStringField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvStringField.js) - [SvTextAreaField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvTextAreaField.js) - [SvUrlField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvUrlField.js) - [SvVideoWellField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2FSvVideoWellField.js) - date - [SvDateNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Fdate%2FSvDateNode.js) - [SvDayNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Fdate%2FSvDayNode.js) - [SvMonthNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Fdate%2FSvMonthNode.js) - [SvYearNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Fdate%2FSvYearNode.js) - options - [SvOptionNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Foptions%2FSvOptionNode.js) - [SvOptionsNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Foptions%2FSvOptionsNode.js) - time - [SvHourNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Ftime%2FSvHourNode.js) - [SvMeridiemNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Ftime%2FSvMeridiemNode.js) - [SvMinuteNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Ftime%2FSvMinuteNode.js) - [SvTimeNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fsubclasses%2Ftime%2FSvTimeNode.js) - json - [SvSyncableJsonGroup](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fjson%2FSvSyncableJsonGroup.js) - node_views - [SvCoachableView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2FSvCoachableView.js) - [SvImageView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2FSvImageView.js) - [SvImageWellView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2FSvImageWellView.js) - [SvNodeView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2FSvNodeView.js) - [SvNodeView_accessibility](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2FSvNodeView_accessibility.js) - [SvVideoView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2FSvVideoView.js) - [SvVideoWellView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2FSvVideoWellView.js) - browser - [SvBrowserView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2FSvBrowserView.js) - stack - [SvNavView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvNavView.js) - [SvScrollContentView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvScrollContentView.js) - [SvScrollToBottomButton](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvScrollToBottomButton.js) - [SvScrollView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvScrollView.js) - [SvStackScrollView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvStackScrollView.js) - [SvStackView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvStackView.js) - [SvTileContainer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTileContainer.js) - SvTile - [SvTextNodeTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTextNodeTile.js) - [SvTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTile.js) - [SvTile_gestures](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2FSvTile_gestures.js) - field_tiles - [SvBooleanFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvBooleanFieldTile.js) - [SvChatInputTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvChatInputTile.js) - [SvChatMessageTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvChatMessageTile.js) - [SvFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvFieldTile.js) - [SvImageWellFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvImageWellFieldTile.js) - [SvPointerFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvPointerFieldTile.js) - [SvTextAreaFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvTextAreaFieldTile.js) - [SvVideoWellFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2FSvVideoWellFieldTile.js) - options - [SvOptionNodeTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2Foptions%2FSvOptionNodeTile.js) - [SvOptionsNodeTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Ffield_tiles%2Foptions%2FSvOptionsNodeTile.js) - subviews - [SvTileNoteButtonView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Fsubviews%2FSvTileNoteButtonView.js) - [SvTileNoteView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Fsubviews%2FSvTileNoteView.js) - [SvTileSubtitleView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Fsubviews%2FSvTileSubtitleView.js) - [SvTileTitleView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTile%2Fsubviews%2FSvTileTitleView.js) - SvTilesView - [SvDragDestinationProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvDragDestinationProtocol.js) - [SvDragSourceProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvDragSourceProtocol.js) - [SvTilesView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView.js) - [SvTilesView_dragViewProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView_dragViewProtocol.js) - [SvTilesView_gestures](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView_gestures.js) - [SvTilesView_helpers](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView_helpers.js) - [SvTilesView_keyboard](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView_keyboard.js) - [SvTilesView_orientation](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView_orientation.js) - [SvTilesView_selection](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView_selection.js) - [SvTilesView_styling](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvTilesView_styling.js) - nodes - [SvFolderNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2FSvFolderNode.js) - [SvImageNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fimage%2FSvImageNode.js) - [SvImagesNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fimage%2FSvImagesNode.js) - [SvLinkNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2FSvLinkNode.js) - [SvPrototypesNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2FSvPrototypesNode.js) - [Slot_promiseWrapper](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fproto%2FSlot_promiseWrapper.js) - [SvSummaryNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2FSvSummaryNode.js) - [SvTextNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2FSvTextNode.js) - [SvVideoNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fvideo%2FSvVideoNode.js) - base - [SvBaseNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fbase%2FSvBaseNode.js) - [SvInspectableNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fbase%2FSvInspectableNode.js) - [SvNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fbase%2FSvNode.js) - [SvStyledNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fbase%2FSvStyledNode.js) - [SvTitledNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fbase%2FSvTitledNode.js) - [SvTranslatableNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fbase%2FSvTranslatableNode.js) - [SvViewableNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fbase%2FSvViewableNode.js) - syncing - [SvCloudSyncSource](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fsyncing%2FSvCloudSyncSource.js) - [SvLocalResourceSource](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fsyncing%2FSvLocalResourceSource.js) - [SvPublicCloudSource](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fsyncing%2FSvPublicCloudSource.js) - [SvSyncableArrayNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fsyncing%2FSvSyncableArrayNode.js) - [SvSyncCollectionSource](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2Fsyncing%2FSvSyncCollectionSource.js) - storage - base - [SvBlobPool](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2FSvBlobPool.js) - [SvObjectPool](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2FSvObjectPool.js) - [SvPersistentObjectPool](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2FSvPersistentObjectPool.js) - [SvStoreRef](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2FSvStoreRef.js) - [SvSubObjectPool](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2FSvSubObjectPool.js) - categories - [SvNode_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2FSvNode_store.js) - [ProtoClass_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2FProtoClass_store.js) - primitives - [Array_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FArray_store.js) - [ArrayBuffer_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FArrayBuffer_store.js) - [BigInt_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FBigInt_store.js) - [Boolean_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2Fliterals%2FBoolean_store.js) - [Date_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FDate_store.js) - [Error_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FError_store.js) - [Image_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FImage_store.js) - [SvJsonObject](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FSvJsonObject.js) - [Map_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FMap_store.js) - [Object_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FObject_store.js) - [RegExp_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FRegex_store.js) - [Set_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FSet_store.js) - [Symbol_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2FSymbol_store.js) - literals - [Boolean_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2Fliterals%2FBoolean_store.js) - [Number_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2Fliterals%2FNumber_store.js) - [String_store](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fbase%2Fcategories%2Fprimitives%2Fliterals%2FString_store.js) - nodes - [SvStorableNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fnodes%2FSvStorableNode.js) - inspectors - [SvDataStore](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fnodes%2Finspectors%2FSvDataStore.js) - [SvDataStoreRecord](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Fnodes%2Finspectors%2FSvDataStoreRecord.js) - SvSubnodesArray - [SvSubnodesArray](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2FSvSubnodesArray.js) - notification - [SvBroadcaster](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnotification%2FSvBroadcaster.js) - [SvSyncAction](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnotification%2FSvSyncAction.js) - [SvSyncScheduler](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnotification%2FSvSyncScheduler.js) - notifications - [SvNotification](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnotification%2Fnotifications%2FSvNotification.js) - [SvNotificationCenter](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnotification%2Fnotifications%2FSvNotificationCenter.js) - [SvObservation](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnotification%2Fnotifications%2FSvObservation.js) - resources - [SvMimeExtensions](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2FSvMimeExtensions.js) - [SvResource](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2FSvResource.js) - [SvResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2FSvResources.js) - files - [SvFileResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ffiles%2FSvFileResources.js) - [SvResourceFile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ffiles%2FSvResourceFile.js) - [SvResourceFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ffiles%2FSvResourceFolder.js) - fonts - [SvFont](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ffonts%2FSvFont.js) - [SvFontFamily](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ffonts%2FSvFontFamily.js) - [SvFontResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ffonts%2FSvFontResources.js) - [SvFontTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ffonts%2FSvFontTile.js) - icons - [SvgIconNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ficons%2FSvgIconNode.js) - [SvIconResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Ficons%2FSvIconResources.js) - [SvResourceGroup](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2FSvResourceGroup.js) - images - [SvImage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fimages%2FSvImage.js) - [SvImageResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fimages%2FSvImageResources.js) - [SvImageTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fimages%2FSvImageTile.js) - [SvURLImage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fimages%2FSvURLImage.js) - json - [SvJsonResource](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fjson%2FSvJsonResource.js) - [SvJsonResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fjson%2FSvJsonResources.js) - sounds - [SvSoundResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fsounds%2FSvSoundResources.js) - [SvWaContext](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fsounds%2FSvWaContext.js) - [SvWaQueue](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fsounds%2FSvWaQueue.js) - [SvWaSound](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fsounds%2FSvWaSound.js) - themes - [SvDefaultTheme](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvDefaultTheme.js) - [SvTheme](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvTheme.js) - [SvThemeClass](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvThemeClass.js) - [SvThemeClassChildren](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvThemeClassChildren.js) - [SvThemeFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvThemeFolder.js) - [SvThemeResources](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvThemeResources.js) - [SvThemeState](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvThemeState.js) - [SvThemeStates](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fresources%2Fthemes%2FSvThemeStates.js) - services - [SvServices](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvServices.js) - AiServiceKit - [SvAiChatModel](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvAiChatModel.js) - [SvAiChatModels](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvAiChatModels.js) - [SvAiConversation](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvAiConversation.js) - [SvAiConversations](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvAiConversations.js) - [SvAiMessage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvAiMessage.js) - [SvAiRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FRequests%2FSvAiRequest.js) - [SvAiResponseMessage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvAiResponseMessage.js) - [SvAiService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvAiService.js) - [SvChatInputNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvChatInputNode.js) - [SvConversation](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvConversation.js) - [SvConversationMessage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvConversationMessage.js) - [SvXhrRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FRequests%2FSvXhrRequest.js) - Composer - [SvAiPromptComposer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FComposer%2FSvAiPromptComposer.js) - ImageEditor - [SvAiImageEditor](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FImageEditor%2FSvAiImageEditor.js) - Requests - errors - [SvAiRequestOverloadedError](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FRequests%2Ferrors%2FSvAiRequestOverloadedError.js) - Tools - [SvAssistantToolKit](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FTools%2FSvAssistantToolKit.js) - Calls - [SvToolCall](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FTools%2FCalls%2FSvToolCall.js) - [SvToolCalls](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FTools%2FCalls%2FSvToolCalls.js) - [SvToolResult](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FTools%2FCalls%2FSvToolResult.js) - Definitions - [SvJsonPatchRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FTools%2FJson%2FSvJsonPatchRequest.js) - [SvToolDefinition](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FTools%2FDefinitions%2FSvToolDefinition.js) - [SvToolDefinitions](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FTools%2FDefinitions%2FSvToolDefinitions.js) - Anthropic - [SvAnthropicRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAnthropic%2FSvAnthropicRequest.js) - [SvAnthropicService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAnthropic%2FSvAnthropicService.js) - Azure - [SvAzureService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2FSvAzureService.js) - locales - [SvAzureLocale](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Flocales%2FSvAzureLocale.js) - [SvAzureLocales](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Flocales%2FSvAzureLocales.js) - speakers - [SvAzureSpeaker](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Fspeakers%2FSvAzureSpeaker.js) - [SvAzureSpeakers](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Fspeakers%2FSvAzureSpeakers.js) - requests - [SvAzureTtsRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Fspeakers%2Frequests%2FSvAzureTtsRequest.js) - [SvAzureTtsRequests](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Fspeakers%2Frequests%2FSvAzureTtsRequests.js) - voices - [SvAzureVoice](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Fvoices%2FSvAzureVoice.js) - [SvAzureVoices](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAzure%2Fvoices%2FSvAzureVoices.js) - DeepSeek - [SvDeepSeekRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FDeepSeek%2FSvDeepSeekRequest.js) - [SvDeepSeekService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FDeepSeek%2FSvDeepSeekService.js) - Firebase - [SvFirebaseFile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FFiles%2FSvFirebaseFile.js) - [SvFirebaseFiles](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FFiles%2FSvFirebaseFiles.js) - [SvFirebaseFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FFolders%2FSvFirebaseFolder.js) - [SvFirebaseFolders](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FFolders%2FSvFirebaseFolders.js) - [SvFirebaseNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FSvFirebaseNode.js) - [SvFirebaseRootFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FFolders%2FSvFirebaseRootFolder.js) - [SvFirebaseService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FSvFirebaseService.js) - [SvFirebaseStoragePermissions](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FSvFirebaseStoragePermissions.js) - [SvFirebaseStorageService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirebaseStorage%2FSvFirebaseStorageService.js) - [SvFirestoreCollection](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FCollections%2FSvFirestoreCollection.js) - [SvFirestoreCollections](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FCollections%2FSvFirestoreCollections.js) - [SvFirestoreDatabaseService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FSvFirestoreDatabaseService.js) - [SvFirestoreDocument](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FDocuments%2FSvFirestoreDocument.js) - [SvFirestoreDocuments](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FDocuments%2FSvFirestoreDocuments.js) - [SvFirestoreNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FSvFirestoreNode.js) - [SvFirestoreQuery](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FSvFirestoreQuery.js) - [SvFirestoreRoot](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FFirebase%2FFirestoreDatabase%2FSvFirestoreRoot.js) - Gemini - [SvGeminiRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FSvGeminiRequest.js) - [SvGeminiService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FSvGeminiService.js) - Image_Editing - [SvGeminiImageEditor](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FImage%2520Editing%2FSvGeminiImageEditor.js) - [SvGeminiImageEditors](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FImage%2520Editing%2FSvGeminiImageEditors.js) - Image_Upscaling - [SvGeminiImageScaler](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FImage%2520Upscaling%2FSvGeminiImageScaler.js) - [SvGeminiImageUpscalings](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FImage%2520Upscaling%2FSvGeminiImageUpscalings.js) - Text_to_Video - [SvGeminiVideoPrompts](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGemini%2FText%2520to%2520Video%2FSvGeminiVideoPrompts.js) - Groq - [SvGroqRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGroq%2FSvGroqRequest.js) - [SvGroqService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FGroq%2FSvGroqService.js) - ImaginePro - [SvEvalChecklistItem](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImageEvaluator%2FChecklist%2FSvEvalChecklistItem.js) - [SvImageEvalChecklistMaker](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImageEvaluator%2FSvImageEvalChecklistMaker.js) - [SvImageEvaluator](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImageEvaluator%2FSvImageEvaluator.js) - [SvImagineProService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FSvImagineProService.js) - Image_Eval_Prompts - [SvImagineProImageEvalPrompt](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImagineProImageEvalPrompt.js) - [SvImagineProImageEvalPrompts](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FImage%2520Eval%2520Prompts%2FSvImagineProImageEvalPrompts.js) - Text_to_Image - [SvImagineProImageGeneration](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FText%2520to%2520Image%2FSvImagineProImageGeneration.js) - [SvImagineProImageGenerations](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FText%2520to%2520Image%2FSvImagineProImageGenerations.js) - [SvImagineProImagePrompt](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FText%2520to%2520Image%2FSvImagineProImagePrompt.js) - [SvImagineProImagePrompts](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FText%2520to%2520Image%2FSvImagineProImagePrompts.js) - Leonardo - [SvLeonardoService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FSvLeonardoService.js) - RefImages - [SvLeonardoRefImage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FRefImages%2FSvLeonardoRefImage.js) - [SvLeonardoRefImages](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FRefImages%2FSvLeonardoRefImages.js) - [SvLeoStyleTransfers](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FStyle%2520Transfers%2FSvLeoStyleTransfers.js) - StyleTransfers - [SvLeoStyleTransfer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FStyle%2520Transfers%2FSvLeoStyleTransfer.js) - Text_to_Image - [SvLeonardoImageGeneration](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FText%2520to%2520Image%2FSvLeonardoImageGeneration.js) - [SvLeonardoImagePrompt](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FText%2520to%2520Image%2FSvLeonardoImagePrompt.js) - [SvLeonardoImagePrompts](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FText%2520to%2520Image%2FSvLeonardoImagePrompts.js) - images - [SvLeonardoImage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FText%2520to%2520Image%2Fimages%2FSvLeonardoImage.js) - [SvLeonardoImages](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FLeonardo%2FText%2520to%2520Image%2Fimages%2FSvLeonardoImages.js) - OpenAI - [SvOpenAiRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FSvOpenAiRequest.js) - [SvOpenAiService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FSvOpenAiService.js) - StyleTransfers - [SvOpenAiStyleTransfer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FStyle%2520Transfers%2FSvOpenAiStyleTransfer.js) - [SvOpenAiStyleTransfers](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FStyle%2520Transfers%2FSvOpenAiStyleTransfers.js) - Text_to_Image - [SvOpenAiImagePrompt](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FText%2520to%2520Image%2FSvOpenAiImagePrompt.js) - [SvOpenAiImagePrompts](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FText%2520to%2520Image%2FSvOpenAiImagePrompts.js) - images - [SvOpenAiImage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FText%2520to%2520Image%2Fimages%2FSvOpenAiImage.js) - [SvOpenAiImages](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FText%2520to%2520Image%2Fimages%2FSvOpenAiImages.js) - Text_to_Speech - [SvOpenAiTtsRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FText%2520to%2520Speech%2FSvOpenAiTtsRequest.js) - [SvOpenAiTtsSession](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FText%2520to%2520Speech%2FSvOpenAiTtsSession.js) - [SvOpenAiTtsSessions](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FOpenAI%2FText%2520to%2520Speech%2FSvOpenAiTtsSessions.js) - Peer - [SvPeerService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvPeerService.js) - SvRzSigServers - [SvRzPeer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzPeer.js) - [SvRzSigServer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServer.js) - [SvRzSigServerPeers](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServerPeers.js) - [SvRzSigServers](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServers.js) - SvRzSigServerConns - [SvRzSigServerConn](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServerConns%2FSvRzSigServerConn.js) - [SvRzSigServerConns](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServerConns%2FSvRzSigServerConns.js) - SvRzPeerConns - [SvRzPeerConn](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServerConns%2FSvRzPeerConns%2FSvRzPeerConn.js) - [SvRzPeerConns](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServerConns%2FSvRzPeerConns%2FSvRzPeerConns.js) - SvRzMsgs - [SvRzMsg](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServerConns%2FSvRzPeerConns%2FSvRzMsgs%2FSvRzMsg.js) - [SvRzMsgs](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServers%2FSvRzSigServerConns%2FSvRzPeerConns%2FSvRzMsgs%2FSvRzMsgs.js) - Spatial - [SvSceneView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSpatial%2FSvSceneView.js) - [SvSceneViewWellFieldTile](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSpatial%2FSvSceneViewWellFieldTile.js) - [SvSpatialModelNode](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSpatial%2FSvSpatialModelNode.js) - SpeechToText - [SvSpeechToTextSession](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSpeechToText%2FSvSpeechToTextSession.js) - [SvSpeechToTextSessions](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSpeechToText%2FSvSpeechToTextSessions.js) - SvSttMessages - [SvSttMessage](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSpeechToText%2FSvSttMessages%2FSvSttMessage.js) - [SvSttMessages](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSpeechToText%2FSvSttMessages%2FSvSttMessages.js) - SvHomeAssistant - [SvHomeAssistantFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FSvHomeAssistantFolder.js) - [SvHomeAssistantGroup](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FSvHomeAssistantGroup.js) - [SvHomeAssistantObject](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FSvHomeAssistantObject.js) - Areas - [SvHomeAssistantArea](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FAreas%2FSvHomeAssistantArea.js) - [SvHomeAssistantAreas](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FAreas%2FSvHomeAssistantAreas.js) - Assistants - [SvHomeAssistant](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FAssistants%2FSvHomeAssistant.js) - [SvHomeAssistants](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FAssistants%2FSvHomeAssistants.js) - Entities - [SvHomeAssistantEntities](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FEntities%2FSvHomeAssistantEntities.js) - [SvHomeAssistantEntity](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FEntities%2FSvHomeAssistantEntity.js) - States - [SvHomeAssistantState](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FStates%2FSvHomeAssistantState.js) - [SvHomeAssistantStates](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FStates%2FSvHomeAssistantStates.js) - SvDevices - [SvHomeAssistantDevice](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FSvDevices%2FSvHomeAssistantDevice.js) - [SvHomeAssistantDevices](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvHomeAssistant%2FSvDevices%2FSvHomeAssistantDevices.js) - SvProxyServers - [SvDefaultProxyServer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvProxyServers%2FSvDefaultProxyServer.js) - [SvProxyServer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvProxyServers%2FSvProxyServer.js) - [SvProxyServers](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FSvProxyServers%2FSvProxyServers.js) - Xai - [SvXaiRequest](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FXai%2FSvXaiRequest.js) - [SvXaiService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FXai%2FSvXaiService.js) - YouTube - [SvYouTubeAudioPlayer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FYouTube%2FSvYouTubeAudioPlayer.js) - [SvYouTubePlayerFrame](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FYouTube%2FSvYouTubePlayerFrame.js) - [SvYouTubeService](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FYouTube%2FSvYouTubeService.js) - MusicPlayer - [SvMusicFolder](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FYouTube%2FMusicPlayer%2FSvMusicFolder.js) - [SvMusicLibrary](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FYouTube%2FMusicPlayer%2FSvMusicLibrary.js) - [SvMusicTrack](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FYouTube%2FMusicPlayer%2FSvMusicTrack.js) - storage - [SvPersistentAsyncMap](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fstorage%2FSvPersistentAsyncMap.js) - view - dom - Attributes - [SvCssAnimation](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FAttributes%2FSvCssAnimation.js) - [SvDomBorderRadius](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FAttributes%2FSvDomBorderRadius.js) - [SvDomTransition](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FAttributes%2FSvDomTransition.js) - [SvDomTransitions](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FAttributes%2FSvDomTransitions.js) - [SvViewAnimator](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FAttributes%2FSvViewAnimator.js) - BrowserDragAndDrop - [SvDataUrl](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FBrowserDragAndDrop%2FSvDataUrl.js) - Helpers - [SvCssColor](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FHelpers%2FSvCssColor.js) - [SvDomCssInspector](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FHelpers%2FSvDomCssInspector.js) - TapeMeasures - [SvCanvasTextTapeMeasure](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FHelpers%2FTapeMeasures%2FSvCanvasTextTapeMeasure.js) - [SvDomTextTapeMeasure](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FHelpers%2FTapeMeasures%2FSvDomTextTapeMeasure.js) - SvDomView - [SvControlDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvControlDomView.js) - [SvCssDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvCssDomView.js) - [SvDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvDomView.js) - [SvDomView_animations](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvDomView_animations.js) - [SvDomView_browserDragAndDrop](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvDomView_browserDragAndDrop.js) - [SvEditableDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvEditableDomView.js) - [SvElementDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvElementDomView.js) - [SvFlexDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvFlexDomView.js) - [SvGesturableDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvGesturableDomView.js) - [SvListenerDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvListenerDomView.js) - [SvResponderDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvResponderDomView.js) - [SvSelectableDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvSelectableDomView.js) - [SvStyledDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvStyledDomView.js) - [SvSubviewsDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvSubviewsDomView.js) - [SvVisibleDomView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2FSvVisibleDomView.js) - subclasses - [SvBooleanView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvBooleanView.js) - [SvButtonView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvButtonView.js) - [SvCloseButton](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvCloseButton.js) - [SvCoachMarkView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2Fcoachmarks%2FSvCoachMarkView.js) - [SvDocumentBody](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvDocumentBody.js) - [SvDragBarView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvDragBarView.js) - [SvDragView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvDragView.js) - [SvgIconCache](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvgIconCache.js) - [SvgIconView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvgIconView.js) - [HTMLElement_textField](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2Fbrowser-only%2FHtmlElement_textField.js) - [SvOverlayBannerView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvOverlayBannerView.js) - [SvPanelView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvPanelView.js) - [SvPasswordView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvPasswordView.js) - [SvScrimView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvScrimView.js) - [SvTextView](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fdom%2FSvDomView%2Fsubclasses%2FSvTextView.js) - [SvWindowErrorPanel](../../resources/class-doc/class_doc.html?path=%2Fsource%2Fboot%2FSvWindowErrorPanel.js) - coachmarks - [SvCoachMarkManager](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnodes%2FSvCoachMarkManager.js) - events - devices - [SvDevice](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvDevice.js) - [SvDevices](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvDevices.js) - [SvEventPoint](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvEventPoint.js) - [SvGamePad](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvGamePad.js) - [SvGamePadManager](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvGamePadManager.js) - [SvKeyboard](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvKeyboard.js) - [SvKeyboardKey](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvKeyboardKey.js) - [SvMouse](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvMouse.js) - [SvTouchScreen](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fdevices%2FSvTouchScreen.js) - gesturing - [SvGestureManager](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2FSvGestureManager.js) - [SvGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2FSvGestureRecognizer.js) - gestures - [SvLongPressGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2FSvLongPressGestureRecognizer.js) - [SvOrientGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2FSvOrientGestureRecognizer.js) - [SvPanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2FSvPanGestureRecognizer.js) - [SvPinchGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2FSvPinchGestureRecognizer.js) - [SvRotationGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2FSvRotationGestureRecognizer.js) - [SvSlideGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2FSvSlideGestureRecognizer.js) - [SvTapGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2FSvTapGestureRecognizer.js) - edges - [SvEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2FSvEdgePanGestureRecognizer.js) - screen - [SvScreenEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fscreen%2FSvScreenEdgePanGestureRecognizer.js) - sides - [SvScreenBottomEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fscreen%2Fsides%2FSvScreenBottomEdgePanGestureRecognizer.js) - [SvScreenLeftEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fscreen%2Fsides%2FSvScreenLeftEdgePanGestureRecognizer.js) - [SvScreenRightEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fscreen%2Fsides%2FSvScreenRightEdgePanGestureRecognizer.js) - [SvScreenTopEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fscreen%2Fsides%2FSvScreenTopEdgePanGestureRecognizer.js) - view - [SvBottomEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fview%2FSvBottomEdgePanGestureRecognizer.js) - [SvLeftEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fview%2FSvLeftEdgePanGestureRecognizer.js) - [SvRightEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fview%2FSvRightEdgePanGestureRecognizer.js) - [SvTopEdgePanGestureRecognizer](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Fgesturing%2Fgestures%2Fedges%2Fview%2FSvTopEdgePanGestureRecognizer.js) - listening - [SvEventListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2FSvEventListener.js) - [SvEventManager](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2FSvEventManager.js) - [SvEventSetListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2FSvEventSetListener.js) - listeners - [SvAnimationListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvAnimationListener.js) - [SvBatteryListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvBatteryListener.js) - [SvClipboardListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvClipboardListener.js) - [SvDocumentListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvDocumentListener.js) - [SvDragListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvDragListener.js) - [SvDropListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvDropListener.js) - [SvFocusListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvFocusListener.js) - [SvGamePadListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvGamePadListener.js) - [SvKeyboardListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvKeyboardListener.js) - [SvMouseListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvMouseListener.js) - [SvMouseMoveListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvMouseMoveListener.js) - [SvScrollListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvScrollListener.js) - [SvSelectListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvSelectListener.js) - [SvSpeechListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvSpeechListener.js) - [SvTouchListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvTouchListener.js) - [SvTouchMoveListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvTouchMoveListener.js) - [SvTransitionListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvTransitionListener.js) - [SvWebSocketListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvWebSocketListener.js) - [SvWheelListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvWheelListener.js) - [SvWindowListener](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fevents%2Flistening%2Flisteners%2FSvWindowListener.js) - geometry - [SvPoint](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fgeometry%2FSvPoint.js) - [SvRectangle](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fgeometry%2FSvRectangle.js) - [SvTransform](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fgeometry%2FSvTransform.js) - webbrowser - [SvStyleSheet](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvStyleSheet.js) - [SvThrashDetector](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvThrashDetector.js) - [SvWebBrowserBattery](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvWebBrowserBattery.js) - [SvWebBrowserCookie](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvWebBrowserCookie.js) - [SvWebBrowserNotification](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2Fnotifications%2FSvWebBrowserNotification.js) - [SvWebBrowserNotifications](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2Fnotifications%2FSvWebBrowserNotifications.js) - [SvWebBrowserScreen](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvWebBrowserScreen.js) - [SvWebBrowserWindow](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvWebBrowserWindow.js) - [SvWebDocument](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fview%2Fwebbrowser%2FSvWebDocument.js) - local-web-server - [Base](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2FBase.js) - [SvMimeExtensions](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2FSvMimeExtensions.js) - WebServer - [AcmeChallengeRequest](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2Frequests%2FAcmeChallengeRequest.js) - [BaseHttpsServer](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2FBaseHttpsServer.js) - [BaseHttpsServerRequest](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2FBaseHttpsServerRequest.js) - [CliWebServer](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2FCliWebServer.js) - [FileRequest](../../resources/class-doc/class_doc.html?path=%2Fwebserver%2Frequests%2FFileRequest.js) - webserver/orm - [SvDatabase](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDatabase.js) - [SvDbCache](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbCache.js) - [SvDbColumn](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbColumn.js) - [SvDbCustomRow](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbCustomRow.js) - [SvDbCustomTable](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbCustomTable.js) - [SvDbDataType](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbDataType.js) - [SvDbRow](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbRow.js) - [SvDbSchema](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbSchema.js) - [SvDbTable](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbTable.js) - [SvDbTx](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Form%2FSvDbTx.js) --- Source: /docs/Reference/Protocols/ # Protocols Protocol definitions and implementations in the STRVCT framework. See [Protocols](../../Programming%20Idioms/Protocols/index.html) for required and optional methods and delegate protocols. - library - ideal - protocol - [SvDelegateProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fprotocol%2FSvDelegateProtocol.js) (the base of every delegate protocol) - html - SvHtmlStreamReader - [SvHtmlStreamReaderDelegateProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fideal%2Fhtml%2FSvHtmlStreamReader%2FSvHtmlStreamReaderDelegateProtocol.js) (implemented by: SvAiParsedResponseMessage) - node - audio - [SvAudioClipDelegateProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Faudio%2FSvAudioClipDelegateProtocol.js) (implemented by: SvAudioQueue) - [SvAudioClipProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Faudio%2FSvAudioClipProtocol.js) - fields - image - [SvProgressiveImageSourceProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Ffields%2Fimage%2FSvProgressiveImageSourceProtocol.js) - storage - records - [SvRecordStoreProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fstorage%2Frecords%2FSvRecordStoreProtocol.js) (implemented by: SvLocalRecordStore, SvMemoryRecordStore, SvCloudRecordStore) - node_views - browser - stack - SvEdgeHandle - [SvCollapsibleRegionProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvEdgeHandle%2FSvCollapsibleRegionProtocol.js) - SvTilesView - [SvDragDestinationProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvDragDestinationProtocol.js) - [SvDragSourceProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fnode%2Fnode_views%2Fbrowser%2Fstack%2FSvTilesView%2FSvDragSourceProtocol.js) - services - AiServiceKit - [SvConversationMessageDelegateProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FSvConversationMessageDelegateProtocol.js) (implemented by: SvConversation) - Requests - [SvAiRequestDelegateProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FRequests%2FSvAiRequestDelegateProtocol.js) (implemented by: SvAiResponseMessage) - [SvXhrRequestDelegateProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FAiServiceKit%2FRequests%2FSvXhrRequestDelegateProtocol.js) (implemented by: SvAiRequest, SvFileToDownload) - ImaginePro - Text to Image - [SvImagineProImageGenerationDelegateProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FImaginePro%2FText%2520to%2520Image%2FSvImagineProImageGenerationDelegateProtocol.js) - Peer - [SvRzPeerConnDelegateProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzPeerConnDelegateProtocol.js) - [SvRzSigServerConnDelegateProtocol](../../resources/class-doc/class_doc.html?path=%2Fsource%2Flibrary%2Fservices%2FPeer%2FSvRzSigServerConnDelegateProtocol.js) --- Source: /docs/Services/ # Services AI, cloud, media, and IoT service integrations. ## Overview Services are not part of the Strvct core — they are optional integrations provided as a convenient way to quickly connect with important external services. The `Services` singleton is the root container for all of them. Each service is a standard Strvct node with slots, persistence, and automatic UI — the same patterns used for domain objects apply to service configuration. Users can inspect and configure services (API keys, model selection, proxy settings) through the generated interface without any custom settings UI. - AI Services - Cloud Storage - Media - Proxies - Home Assistant --- Source: /docs/Services/AI%20Services/ # AI Services Framework architecture for multi-provider AI integration, streaming execution, tool calling, and model-first operability. ## Introduction & The Model-First AI Advantage Strvct provides a comprehensive, multi-provider AI infrastructure built directly into the framework. Unlike traditional applications where AI integration requires writing bespoke API wrappers, per-screen tool specifications, and custom JSON serializers, Strvct's **Naked Objects** architecture makes the entire domain model **natively AI-operable** out of the box. Because every domain class declares instance properties as **slots** with metadata annotations (`slotType`, `canEditInspection`, `isSubnodeField`), Strvct exposes a universal AI tool surface consisting of just two generic, constant-size functions: 1. **`schema-fetch`**: Inspects slot metadata to generate JSON schemas for any domain class or live object instance. 2. **`apply-patch`**: Validates and applies JSON patch payloads to mutate properties or update child relationships on live domain objects. AI Agent / LLM Generates JSON patches Generic Tool Surface schema-fetch & apply-patch Strvct Annotation Bridge Slot metadata annotations UI Tile Updates Live view renders IndexedDB Pool Local persistence Sync Scheduler Deferred notifications This tool surface remains **constant in size** whether an application contains 5 domain classes or 500. When an AI agent generates an invalid patch, the framework's rejected response returns the slot schema, enabling the LLM to self-correct in real time. --- ## Service & Request Factory Architecture AI providers are implemented as paired service and request singletons inheriting from base infrastructure classes: - **`SvAiService`**: High-level provider service singleton (e.g., `SvAnthropicService`, `SvGeminiService`, `SvOpenAiService`). Manages authentication, endpoint resolution, and model capability registries. - **`SvAiRequest`**: Low-level HTTP request wrapper handling message formatting, custom headers, and streaming chunk parsing. SvAiService Base Provider Service SvAnthropicService Pairs with SvAnthropicRequest SvGeminiService Pairs with SvGeminiRequest SvOpenAiService Pairs with SvOpenAiRequest ### Automatic Factory Resolution `SvAiService` resolves its paired request class dynamically using naming conventions (`SvGeminiService` automatically pairs with `SvGeminiRequest`). Adding a new AI provider requires implementing the service and request subclass without registering explicit factory hooks. ### Authentication & Token Flow Authentication is resolved via `apiKeyOrUserAuthToken()`: 1. First checks `SvCredentialManager` for a Firebase bearer token (for production apps proxying requests through Firebase Cloud Functions to protect secrets). 2. Falls back to a client-stored API key (for local development or direct user API key entry). --- ## AI Model Registry (`SvAiChatModel`) `SvAiChatModel` represents a specific LLM model instance (e.g., `claude-3-5-sonnet`, `gemini-1.5-pro`, `gpt-4o`). Each model definition includes: - `modelName`: Standard provider model identifier string. - `inputTokenLimit` / `outputTokenLimit`: Context window limits. - Capability Flags: `supportsTemperature`, `supportsTopP`, `supportsImageGeneration`, `supportsVideoGeneration`, `supportsTools`. The global `Services` node provides global helper methods to query models across all registered providers: ```javascript const models = Services.shared().aiServices().chatModels(); const model = Services.shared().aiServices().chatModelWithName("claude-3-5-sonnet"); ``` --- ## Conversations & Messaging (`SvAiConversation` & `SvAiMessage`) `SvAiConversation` manages conversational state, token counts, system prompts, tool call history, and active LLM chat requests. - **`SvAiMessage`**: Extends standard conversation messages with role designations (`system`, `user`, `assistant`). - **Role Mapping**: Provider services map generic role names to provider-specific conventions automatically (e.g., mapping `assistant` to `model` for Gemini APIs). --- ## The Assistant ToolKit & Function Execution Structured tool calling is coordinated by `SvAssistantToolKit`: AI Response Stream <tool-call name="rollDice"> SvAssistantToolKit Function Dispatcher Streaming Execution Triggers audio & FX inline Completion State Patch Mutates live domain nodes ### 1. Tool Registration Methods on model nodes are marked as toolable during slot setup: ```javascript const tool = this.methodNamed("rollDice"); tool.setDescription("Roll dice for a combat check"); tool.addParameter("notation", "String", "Standard dice notation like 2d6+3"); tool.setIsToolable(true); ``` ### 2. Execution Timing Phases Tools execute at specific points in the response lifecycle: - **Streaming Phase (`onStreamData`):** Executes in real time while tokens arrive (e.g., playing a sound effect or triggering a UI animation). - **Completion Phase (`onRequestComplete`):** Executes after the full response is validated (e.g., applying state mutations to domain nodes). - **Narration Phase (`onPlayback`):** Executes synchronized with Text-To-Speech (TTS) voice audio playback. --- ## Incremental Streaming Response Parser (`SvAiParsedResponseMessage`) AI responses arrive as continuous token streams. `SvAiParsedResponseMessage` parses structured XML tags incrementally during streaming without waiting for full response completion: - ``: Extracted and dispatched immediately to `SvAssistantToolKit`. - ``: Extracted and routed directly to the TTS voice audio queue for zero-latency speech synthesis. - `` / `` / ``: Extracted for structured UI display in chat message views. --- ## Modular Prompt Composition (`SvAiPromptComposer`) `SvAiPromptComposer` builds complex system prompts dynamically using modular text template files without manual string concatenation in JavaScript: ``` [ Template File: SystemPrompt.txt ] "System rules: {{file$Rules.txt}} Current Character: {{$characterSummary}} Available Actions: {{$tableOfContents}}" ``` ### Supported Substitution Directives: 1. `{{file$Path/ToFile.txt}}`: Recursively embeds the contents of a secondary prompt template file. 2. `{{$methodName}}`: Executes a getter method on the target domain object and inserts the string result. 3. `{{$tableOfContents}}`: Generates a structured table of contents from headings in the prompt document. --- ## Provider Support Matrix | Service Class | Provider | Key Capabilities & Models | |---|---|---| | `SvAnthropicService` | Anthropic | Claude 3.5 Sonnet, Claude 3 Opus, native tool use | | `SvGeminiService` | Google | Gemini 1.5 Pro/Flash, text-to-video, multimodal inputs | | `SvOpenAiService` | OpenAI | GPT-4o, DALL-E 3 image generation, TTS voice synthesis | | `SvGroqService` | Groq | Ultra-low-latency inference (OpenAI compatible) | | `SvDeepSeekService` | DeepSeek | DeepSeek V3 / R1 reasoning models | | `SvXaiService` | xAI | Grok 2 models (OpenAI compatible) | | `SvImagineProService`| ImaginePro | Midjourney image generation via proxy API | --- ## Adding a New AI Provider To add a new AI provider, implement two classes following naming conventions: 1. **Service Subclass (`SvNewProviderService.js`):** ```javascript (class SvNewProviderService extends SvAiService { modelsJson () { return [ { name: "new-model-v1", inputTokenLimit: 128000, outputTokenLimit: 4096 } ]; } }.initThisClass()); ``` 2. **Request Subclass (`SvNewProviderRequest.js`):** ```javascript (class SvNewProviderRequest extends SvAiRequest { buildBody () { // Format message payload for API endpoint } readDataChunk (chunk) { // Parse streaming SSE chunks } }.initThisClass()); ``` 3. **Slot Registration:** Declare the new service slot in `Services.initPrototypeSlots()`. The service/request factory automatically binds `SvNewProviderService` to `SvNewProviderRequest`. --- Source: /docs/Services/Cloud%20Storage/ # Cloud Storage Firebase integration for cloud persistence and file storage. ## SvFirebaseService Integrates with Firebase for cloud persistence and file storage. Unlike AI services, `SvFirebaseService` extends `SvSummaryNode` directly and contains two sub-services: - **`SvFirestoreDatabaseService`** — Document and collection access via Firestore. Provides query building, real-time listeners, and CRUD operations through Strvct node wrappers (`SvFirestoreNode`, `SvFirestoreQuery`). - **`SvFirebaseStorageService`** — File upload and download via Firebase Storage, with permission management. Document persistence does not go through these wrappers. Object pools reach the cloud through `SvCloudRecordStore`, which calls the backend's record functions (open, changes, children, commit); see [Cloud Object Pools](../../Persistence/Cloud%20Object%20Pools/). --- Source: /docs/Services/Home%20Assistant/ # Home Assistant IoT device control via Home Assistant's WebSocket API. ## Overview The Home Assistant integration maps an entire Home Assistant instance — areas, devices, entities, and states — into the Strvct node graph. The result is a navigable, inspectable tree of your smart home that uses the same UI patterns as the rest of the framework. No custom views are involved; the generated interface lets you browse areas, drill into devices, see entity states, and inspect raw JSON from HA — all from slot annotations. Multiple Home Assistant instances are supported. Each connection is configured with a host, port, and long-lived access token, all editable through the generated inspector. ## Connection Communication uses the Home Assistant WebSocket API. Because browsers disallow plain `ws://` connections from HTTPS pages, a small WSS-to-WS proxy relays traffic between the browser and HA's local WebSocket endpoint. ### Authentication Flow 1. Browser opens a secure WebSocket connection to the proxy 2. HA sends `auth_required` 3. Client responds with the stored long-lived access token 4. HA replies `auth_ok` or `auth_invalid` 5. On success, a full data refresh begins All subsequent requests use a sequential integer ID with a promise-based response pattern — each outgoing message gets a unique ID, and incoming results are matched to their pending promise by that ID. ## Data Model After authentication, the integration fetches four registries in parallel: | Group | HA WebSocket Command | Node Class | |---|---|---| | Areas | `config/area_registry/list` | `SvHomeAssistantArea` | | SvDevices | `config/device_registry/list` | `SvHomeAssistantDevice` | | Entities | `config/entity_registry/list` | `SvHomeAssistantEntity` | | States | `get_states` | `SvHomeAssistantState` | Each registry response is an array of JSON objects. For each entry, a corresponding Strvct node is created and registered in an ID map for O(1) lookup. ### Object Wiring After all four registries are loaded, a wiring pass connects objects into a hierarchy based on their foreign keys: - **SvDevices** attach to **Areas** via `area_id` - **Entities** attach to **SvDevices** via `device_id` - **States** attach to **Entities** via `entity_id` The result is a tree rooted at a `SvHomeAssistantFolder` node (titled "regions") that mirrors the physical layout of the home: ``` Home Assistant └── regions ├── Living Room (area) │ └── HomePod (device) │ └── volume (entity) │ └── standby (state) ├── Kitchen (area) │ └── ... └── ... ``` ### Display Names Each object computes a short display name by stripping its parent's name as a prefix. For example, a device named "Living Room Speaker" under the "Living Room" area displays as "Speaker". This keeps the tree compact without losing context. ## Class Hierarchy ``` SvHomeAssistants — Collection of HA connections └── SvHomeAssistant — One connection instance ├── rootFolder — Navigable UI tree (regions) ├── SvHomeAssistantAreas ─┐ ├── SvHomeAssistantDevices │ Data groups (hidden, ├── SvHomeAssistantEntities │ used for ID lookup) └── SvHomeAssistantStates ─┘ SvHomeAssistantGroup — Base for the four registry groups ├── SvHomeAssistantAreas ├── SvHomeAssistantDevices ├── SvHomeAssistantEntities └── SvHomeAssistantStates SvHomeAssistantObject — Base for individual HA items ├── SvHomeAssistantArea ├── SvHomeAssistantDevice ├── SvHomeAssistantEntity └── SvHomeAssistantState ``` The four data group nodes (`areasNode`, `devicesNode`, `entitiesNode`, `statesNode`) are hidden from the UI — they exist for ID-based lookup during the wiring pass. The visible navigation tree is the `rootFolder`, which is populated with area nodes after all data is loaded and wired. --- Source: /docs/Services/Media/ # Media YouTube audio playback and browser speech recognition. ## SvYouTubeService Manages YouTube-based audio playback via the IFrame Player API. The service contains a `SvYouTubeAudioPlayer` subnode that wraps a hidden YouTube player element. ### SvYouTubeAudioPlayer The core playback class. Handles player lifecycle, volume, looping, and state tracking. The YouTube IFrame API script is loaded lazily on first use, and playback waits for a user gesture (browser autoplay policy). ```javascript // Create a player and loop background music const player = SvYouTubeAudioPlayer.clone(); player.setTrackName("Ambient Forest"); player.setVideoId("abc123xyz"); player.setShouldRepeat(true); player.setVolume(0.1); player.play(); // Control player.stop(); player.togglePlay(); player.isPlaying(); // => boolean player.stateName(); // => "playing" | "paused" | "buffering" | "ended" // One-shot playback (resolves when video ends) player.setShouldRepeat(false); await player.play(); // Cleanup await player.shutdown(); // destroys the YT.Player and removes the DOM element ``` ### SvMusicLibrary A higher-level layer that manages playlists of `SvMusicTrack` nodes loaded from a JSON resource file. Owns two `SvYouTubeAudioPlayer` instances — one for background music (low volume), one for sound effects (higher volume). ```javascript // Play looping background music by track name library.playTrackWithName("Mystical Forest"); // Play a one-shot sound effect await library.playSoundEffectWithName("Sword Clash"); // Stop background music library.musicPlayer().stop(); // Lookup library.trackWithName("Battle Theme"); // => SvMusicTrack library.playlists(); // => SvMusicFolder[] library.trackNames(); // => String[] ``` Playlist data is a JSON object mapping folder names to track dictionaries: ```json { "Fantasy": { "Mystical Forest": "YouTubeVideoId1", "Battle Theme": "YouTubeVideoId2" }, "Sound FX": { "Sword Clash": "YouTubeVideoId3" } } ``` ### SvMusicTrack Represents a single track with a YouTube video ID. Supports a delegate set for playback notifications: ```javascript track.addDelegate(myObserver); await track.play(); track.stop(); ``` Delegates receive `onSoundStarted(track)` and `onSoundEnded(track)`. ## SvSpeechToTextSessions Wraps the browser's native `SpeechRecognition` API for voice input. Each `SvSpeechToTextSession` tracks recognition state, language settings, and transcription results. Not a cloud service — all processing happens in the browser. ### SvSpeechToTextSession ```javascript const session = SvSpeechToTextSession.clone(); session.setDelegate(myObject); session.setLanguage("en-US"); session.setIsContinuous(true); session.setGetInterimResults(true); session.setInputTimeoutMs(1500); // Start — returns a promise that resolves with the transcript // when the input timeout fires (silence detected after speech) const text = await session.start(); // Manual stop session.stop(); // State session.isRecording(); session.fullTranscript(); // accumulated text session.interimTranscript(); // current partial text ``` ### Delegate Protocol All methods are optional. The session is passed as the first argument. | Method | When | |---|---| | `onSpeechInterimResult(session)` | Partial result received | | `onSpeechFinal(session)` | Finalized segment received, appended to `fullTranscript` | | `onSpeechEnd(session)` | Browser speech recognition ended | | `onSpeechInput(session)` | Input timeout elapsed — transcript is final | | `onSessionEnd(session)` | Recognition service disconnected | | `onSpeechError(session, error)` | Recognition error | ### Usage in SvTextView Any text field supports voice input via Alt+L. Holding the key starts a session; releasing it stops recognition and inserts the transcript at the cursor: ```javascript startSpeechToText () { this._speechSession = SvSpeechToTextSession.clone().setDelegate(this); this._speechSession.start(); } onSpeechEnd (speechSession) { const s = speechSession.fullTranscript(); this.insertTextAtCursorSimple(s); this._speechSession = null; } ``` --- Source: /docs/Services/Proxies/ # Proxies Client-side proxy configuration for routing API calls through intermediary servers. ## Overview These classes do not run proxy servers — they are client-side configuration nodes that store proxy server connection details and rewrite API URLs to route through a proxy. The actual proxy server (e.g. a Firebase Function or local HTTPS reverse proxy) runs separately. The primary use case is routing AI service API calls through a proxy that holds the real API keys, so that browser clients never see provider credentials directly. The client sends a Firebase user auth token to the proxy, and the proxy adds the appropriate API key before forwarding the request. ## SvProxyServers `SvProxyServers` is a singleton collection of `SvProxyServer` entries, accessible via `SvProxyServers.shared()`. In practice, a single `SvDefaultProxyServer` entry handles all routing, accessible via `SvProxyServers.shared().defaultServer()`. Users can add, remove, and reorder proxy entries through the generated inspector UI. All entries are persisted to IndexedDB. ## SvProxyServer Each `SvProxyServer` node stores the connection details for one proxy endpoint: | Slot | Type | Default | Purpose | |---|---|---|---| | `isSecure` | Boolean | `true` | Use `https` or `http` | | `subdomain` | String | `""` | Optional subdomain prefix | | `domain` | String | `""` | Base domain (e.g. `localhost`, `example.com`) | | `port` | Number | `0` | Port number (0 or null omits port from URL) | | `path` | String | `""` | URL path (e.g. `/proxy`) | | `parameterName` | String | `null` | Query parameter name for the target URL | | `isDisabled` | Boolean | `false` | When true, returns target URLs unchanged | All configuration slots are persisted and editable through the generated inspector. ### URL Rewriting The core method is `proxyUrlForUrl(targetUrl)`, which rewrites a direct API URL into a proxied one: ``` Target: https://api.openai.com/v1/chat/completions Proxied: https://localhost:8443/proxy?proxyUrl=https%3A%2F%2Fapi.openai.com%2Fv1%2Fchat%2Fcompletions ``` The target URL is passed as a query parameter (named by `parameterName`), so the proxy server can decode it, forward the request to the real provider, and stream the response back. If `isDisabled` is true, the target URL is returned unchanged — useful for direct API access during development. ## SvDefaultProxyServer `SvDefaultProxyServer` extends `SvProxyServer` and auto-configures itself from the browser's current page URL on startup. For a page served at `https://localhost:8443`, it defaults to: - `isSecure`: `true` - `hostname`: `localhost` - `port`: `8443` - `path`: `/proxy` - `parameterName`: `"proxyUrl"` This means the proxy is assumed to run on the same origin as the application by default. Applications can override these settings programmatically via `setupForConfigDict()` using build-time environment configuration. ## Integration with AI Services `SvAiRequest` has a `needsProxy` slot (default `true`). When making an API call, the request checks this flag and rewrites the URL if needed: ```javascript async activeApiUrl () { let url = this.apiUrl(); // e.g. "https://api.openai.com/v1/chat/completions" if (this.needsProxy()) { url = SvProxyServers.shared().defaultServer().proxyUrlForUrl(url); } return url; } ``` This applies to all AI service requests (chat, image generation, text-to-speech, video generation) and also to image/media downloads that would otherwise be blocked by CORS in production. --- Source: /docs/Slots/ # Slots The property system: declaration, slot annotations, runtime type checks, lifecycle hooks, and metadata consumers. ## Overview Slots are Strvct's property system. In traditional JavaScript objects, instance fields are simple key-value pairs without metadata. In Strvct, declaring a property as a **slot** transforms it into a rich metadata carrier that each framework layer reads independently. Slot Declaration newSlot("name", "Thorin") UI Layer Auto-generates Property Tiles Storage Layer Serializes shouldStoreSlot AI Agent Surface Generates JSON tool schemas Slots decouple business logic from UI, persistence, and AI tools; declare metadata once, every layer benefits automatically. --- ## Declaration Syntax & Slot Maps Slots are declared inside `initPrototypeSlots()` during class registration. Declaring a slot installs a private variable (`_slotName`), an auto-generated getter (`slotName()`), and an auto-generated setter (`setSlotName(value)`) on the class prototype. Each class prototype maintains two slot maps: - **`slotsMap()`**: Map of slots defined directly on this specific class. - **`allSlotsMap()`**: Map of all slots from this class and every ancestor class, accumulated down the prototype chain. ```javascript (class Character extends SvStorableNode { initPrototypeSlots () { { const slot = this.newSlot("name", ""); slot.setSlotType("String"); slot.setShouldStoreSlot(true); // Included in IndexedDB record rows slot.setSyncsToView(true); // Posts didChangeSlot notification slot.setCanEditInspection(true); // Editable field in Property Inspector } { const slot = this.newSlot("ownerNode", null); slot.setIsWeak(true); // WeakRef memory safety slot.setSyncsToView(true); } } }.initThisClass()); ``` --- ## Complete Annotation Setters Table | Setter Method | Default | Purpose / Subsystem Consumer | |---|---|---| | `setSlotType("String")` | `"Object"` | Controls type validation, form field input type, and LLM JSON schema generation. | | `setIsWeak(true)` | `false` | Holds value via `WeakRef` to prevent retain cycles in parent/owner back references. | | `setIsLazy(true)` | `false` | Defers initialization or loading until the first getter call. | | `setShouldStoreSlot(true)` | `false` | Instructs `SvObjectPool` to include property in serialized IndexedDB record rows. | | `setIsInCloudRecord(true)` | `true` | When set to `false`, retains property in local IndexedDB but strips it from cloud commits. | | `setSyncsToView(true)` | `false` | Emits `"didChangeSlot"` notification via `SvNotificationCenter` upon mutation. | | `setCanEditInspection(true)` | `false` | Exposes field for direct editing in the modifier-click (Option+Click) Property Inspector. | | `setIsSubnode(true)` | `null` | Adds slot value automatically to parent's `subnodes` array during `finalInit()`. | | `setIsSubnodeField(true)` | `null` | Generates a navigable field tile (`SvField`) in the UI inspector hierarchy. | | `setFinalInitProto(ClassName)` | `null` | Auto-instantiates default child objects during `finalInit()` if absent from storage. | | `setIsBlobString(true)` | `false` | Long text slot whose payload spills to a SHA-256 text blob in storage. | | `setIsPromiseWrapped(true)` | `false` | Auto-wraps getter return values in a Promise for async interface operations. | | `setDuplicateOp("duplicate")` | `"nop"` | Cloning policy when duplicating nodes (`"nop"`, `"copyValue"`, `"duplicate"`). | | `setValidValues([a, b])` | `null` | Restricts values to an allowed set, rendering dropdown options in the UI. | | `setAllowsNullValue(true)` | `false` | Relaxes runtime validation to permit `null` slot values. | | `setTranslationContext("ui")` | `null` | Declares i18n category for auto-translating string values. | --- ## Slot Constructor Variants - **`newSlot(name, defaultValue)`**: Standard slot constructor with auto getter and setter. - **`newWeakSlot(name, defaultValue)`**: Creates a slot holding a `WeakRef`. The getter unwraps the weak reference automatically; the setter wraps new values in `WeakRef`. Prevents retain cycles in parent-child back references. - **`newSubnodeFieldSlot(name, Class)`**: Convenience constructor for navigable subnode field properties. - **`overrideSlot(name, defaultValue)`**: Overrides a slot inherited from a superclass, preserving metadata while changing the default value. --- ## Slot Change & Getter Hooks Auto-generated getters and setters execute optional lifecycle hooks on the owning object if defined: ```javascript (class Character extends SvStorableNode { initPrototypeSlots () { { const slot = this.newSlot("inventory", null); slot.setSlotType("Inventory"); } } // Optional lazy initialization hook called BEFORE getter returns value willGetSlotInventory () { if (!this._inventory) { this.setInventory(Inventory.clone()); } } // Optional hook called BEFORE setter updates value willUpdateSlotInventory (oldVal, newVal) { console.log("Inventory changing from", oldVal, "to", newVal); } // Optional hook called AFTER setter updates value didUpdateSlotInventory (oldVal, newVal) { this.recalculateTotalWeight(); } }.initThisClass()); ``` --- ## Runtime Type Checking Auto-generated setters enforce **runtime type checks** against `setSlotType()`. When a type mismatch occurs (e.g. attempting to pass a string to a `Number` slot), the setter logs a warning and attempts safe type coercion (e.g. `Number("12")`), protecting object graph state from corrupt data. --- ## Related Guides - [Nodes](../Nodes/index.html): Core `SvNode` domain abstraction. - [Implementation Overview](../../Implementation%20Overview/index.html): Deep dive into slot specs and class lifecycles. - [Slot Change Hooks](../../Notifications/Slot%20Change%20Hooks/index.html): Declarative setter hooks. --- Source: /docs/Technical%20Overview/ # Technical Overview High-level architecture, core design philosophy, and system-wide concepts of the Strvct framework. ## Introduction Strvct is an open-source, local-first **Naked Objects** framework built in client-side JavaScript. Instead of requiring developers to manually author and maintain separate domain models, UI component trees, form layouts, validators, client-side state stores, persistence mappings, localization dictionaries, and AI agent tool specifications, Strvct derives the complete application interface and operational infrastructure automatically from an annotated domain model. Applications built with Strvct operate as single-page web applications (SPAs) executing natively in the browser. The system is designed from the ground up for **local-first execution**: application state is stored locally in IndexedDB object pools, enabling instant, zero-latency user interaction and full offline functionality. When online, local object pools synchronize transparently with versioned cloud stores. Annotated Domain Model (SvStorableNode Subclasses) Single source of truth declaring slots, subnodes, and metadata annotations Auto-Generated UI Miller column stacks, tabs, & doc sections Local & Cloud Sync IndexedDB pools & SHA-256 blob store Headless Execution Runs in Node.js with zero DOM dependencies Native AI Tool Surface Constant tool size: schema-fetch & patch Unlike traditional component frameworks (React, Vue, Svelte, Flutter) or compile-time code generators: - **No Pre-Rendered View Trees:** There is no build step that compiles templates into UI components or static layouts. - **Lazy Runtime View Derivation:** Views are instantiated lazily in response to user navigation through the object graph. Each step inspects target node slot annotations to resolve or create the appropriate `SvNodeView`. - **Bidirectional Live Synchronization:** Active views observe model nodes through deferred, deduplicated notifications. Updates flow bidirectionally between model and view without manual binding logic. - **Complete Decoupling:** Model objects hold zero references to UI classes or browser DOM elements. The entire domain graph runs headlessly in Node.js for testing, batch processing, or server-side workflows. --- ## The Model-First Triad Strvct organizes applications into three distinct layers connected by an asymmetric notification architecture: UI Layer SvNodeView Hierarchy Views Observe node slots; Created lazily on navigation; Discarded when off-screen Model Layer SvNode Object Graph Domain Objects Slots, subnodes, annotations; Zero UI references Storage Layer SvPersistentObjectPool IndexedDB / Cloud Monitors mutations; Batches per-loop changes into atomic transactions mutation notification getter, setter, & action calls mutation notification loads & stores Model is the authoritative source of truth. Views and Storage hold weak references to Model nodes; Model holds zero references to Views or Storage in return. ### Layer Responsibilities 1. **Model Layer (`SvNode` Graph):** - Authoritative source of truth for all domain data and business logic. - Composed of objects inheriting from `SvNode` (or `SvStorableNode`). - Declares instance properties as **slots** enriched with metadata annotations. - Emits change notifications when slots or subnode arrays mutate, but holds no references to views or persistence handlers. 2. **UI Layer (`SvNodeView` Tree):** - Renders visual presentation using lazy, auto-generated master-detail Miller column containers (`SvStackView`, `SvNavView`, `SvTilesView`, `SvTile`). - Observes model notifications and pulls updated values on model mutation. - Sends user edit commands back to the model via standard slot setters. 3. **Storage Layer (`SvPersistentObjectPool`):** - Monitors model mutation notifications automatically. - Batches dirty objects at the end of each browser event loop into transactional IndexedDB operations. - Syncs versioned delta commits with cloud storage for cross-device availability. --- ## The Multi-Reader Annotation Bridge The cornerstone of Strvct's architecture is the **Slot Annotation System**. Instead of raw instance variables, domain properties are declared as slots with metadata annotations. Slot annotations act as a **multi-reader decoupling bridge**. Each framework subsystem reads slot metadata independently to perform its job without cross-system dependencies: ``` +---> UI Generation (Property Tiles & Control Types) | +---> Local Storage & Cloud Sync (IndexedDB Records) | [ Slot Metadata Bridge ] -+---> Notification Engine (Coalesced Sync Passes) | +---> Native AI Tool Surface (JSON Patch Validation) | +---> Accessibility & i18n (ARIA Roles & Translation) ``` | Annotation Settor | Purpose & Subsystem Consumer | |---|---| | `setSlotType("String")` | Selects tile UI input control type, runtime type validation, and AI JSON schema generation. | | `setShouldStoreSlot(true)` | Directs `SvPersistentObjectPool` to include property in serialized storage records. | | `setSyncsToView(true)` | Instructs model setter to post notification triggers to active observing views. | | `setCanEditInspection(true)` | Exposes property in the modifier-click (Option+Click) live Property Inspector. | | `setIsSubnodeField(true)` | Exposes complex properties as navigable child nodes in the UI inspector hierarchy. | | `setFinalInitProto(ClassName)` | Auto-instantiates default child objects during initialization if absent from storage. | --- ## UI Synchronization Engine Strvct enforces an asymmetric, notification-driven synchronization architecture: 1. **Push Phase (User Action):** When a user edits a property in the UI, the view calls the corresponding setter on the model node (e.g., `character.setName("Thorin")`). 2. **Notification Phase:** The generated slot setter verifies the type, updates internal state, and posts a named change notification via `SvNotificationCenter`. 3. **Pull Phase (Deferred View Sync):** Observing views receive the notification and schedule a sync pass with `SvSyncScheduler`. 4. **Coalescing & Loop Avoidance:** `SvSyncScheduler` deduplicates multiple mutations within the same event loop, executing a single UI re-render pass at the end of the loop. If setter values have converged, sync halts automatically, preventing infinite update loops. 5. **Memory Safety:** Notifications use weak-reference observation patterns, allowing unreferenced views and models to be garbage-collected cleanly without manual listener detachment. --- ## Local & Cloud Persistence Strvct combines local-first speed with seamless cloud synchronization: ### 1. Local Object Pools (IndexedDB) - Application data is divided into **Object Pools** (one pool per document/aggregate root). - Each domain object is stored as a JSON row keyed by `poolId` and `puuid` (persistent UUID). - Object references within a pool are stored as `{ "*": puuid }`. - External cross-pool references are stored as `{ "**": poolId }`. - Mutations queue objects automatically for end-of-event-loop atomic IndexedDB commits. ### 2. SHA-256 Content-Addressable Blob Store - Large binary assets (images, audio, files) are stored separately in `SvBlobPool`. - Keys are computed as SHA-256 content hashes, providing automatic binary deduplication. - Records store hash references rather than raw binary data, keeping IndexedDB records lean and fast. ### 3. Versioned Cloud Commits - Cloud persistence mirror the same row format as local IndexedDB. - Saving a document computes delta rows modified since the last acknowledged pool version and posts an atomic commit. - Conflicts are detected deterministically per pool version rather than silently overwriting data. --- ## Content-Addressable Resource Delivery (CAM) Real-world Naked Objects applications load hundreds of domain classes, view handlers, and style assets into the browser. Traditional ES module loading (hundreds of individual HTTP requests) creates severe network latency, while standard Webpack/Vite bundlers invalidate full chunks on minor file edits. Strvct solves this with a **Content-Addressable Memory (CAM)** build and delivery pipeline: ``` [ Build Stage: ImportsIndexer ] Scan _imports.json tree ---> Compute SHA-256 for each file ---> Produce _index.json (path -> hash) & _cam.json.zip (compressed content) [ Runtime Stage: SvResourceManager & SvHashCache ] Fetch _index.json ---> Compare against IndexedDB SvHashCache ---> If delta ratio > 30%: Download _cam.json.zip in 1 request ---> If delta ratio <= 30%: Download only missing hash files ``` ### Key Benefits of CAM Delivery: - **Hash-Based Caching:** Assets are addressed and cached in IndexedDB by SHA-256 hash rather than URL path. - **Zero-Churn Redeployment:** Modifying a single source file invalidates only that file's hash in the cache; returning users download only the edited file. - **Cross-App Shared Caching:** Multiple Strvct applications running on the same origin share the local hash cache for common framework classes. - **Full Debugger Support:** JavaScript source files are evaluated dynamically via `eval()` with embedded `sourceURL` annotations, providing complete DevTools debugger capabilities (breakpoints, stack traces, step execution). --- ## Architectural Capabilities ("For Free") Because Strvct centralizes the pipeline from slot annotations to runtime views, several high-value capabilities fall out of the architecture automatically: 1. **Natively AI-Operable Model:** Every class exposes a constant-size tool surface (`schema-fetch` + `apply-patch`). AI agents inspect schemas and patch live object graphs directly with automatic schema validation. 2. **Headless Execution:** Domain models contain zero DOM dependencies and execute natively under Node.js for ultra-fast unit testing, simulations, or server execution. 3. **Automatic Mobile Responsiveness:** Navigation columns (`SvStackView`) automatically collapse into mobile push/pop stacks with interactive breadcrumb headers on narrow viewports. 4. **Live Property Inspector:** Modifier-clicking (Option+Click) any tile reveals a live inspector displaying all declared slots, storage flags, and validation states. 5. **Type-Safe Cross-Window Drag & Drop:** Tiles support serialization to JSON MIME types for dragging data across browser windows, desktop apps, or Strvct instances. 6. **Universal Accessibility & Localization:** ARIA roles, keyboard navigation, focus management, and AI string translation are applied centrally at the tile primitive level. --- ## Related Documentation - [Implementation Overview](../Implementation%20Overview/index.html): Detailed engineering specifications for classes, slots, views, and persistence. - [Naked Objects](../Naked%20Objects/index.html): Architectural paper detailing theoretical foundations and case studies. - [Comparing to React](../Comparing%20to%20React/index.html): Guide for React developers exploring Strvct's model-first paradigm. --- Source: /docs/Views/ # Views The view layer: auto-generated UI, custom views, and programmatic styling. The entire view system is built from a small number of composable elements: a node, a tile, a column, and a master-detail split. These four pieces nest recursively — a column of tiles where selecting a tile opens another column — so the same structure that displays a flat list also handles arbitrarily deep, mixed-orientation navigation without any additional wiring. The view hierarchy wraps DOM elements rather than extending them. This is deliberate: the DOM API is large and mutable, and subclassing it tightly couples framework code to browser internals that change across engines and versions. Wrapping keeps the boundary clean — each layer in the class chain adds exactly one capability (visibility, event listening, gestures, layout, styling), so any layer can be understood, tested, or replaced independently. text { font-family: 'Inter', system-ui, -apple-system, sans-serif; font-size: 12px; fill: #111; } .b { font-weight: 600; } .dim { fill: #666; } .box { fill: none; stroke: #111; stroke-width: 1; } .fill { fill: #f0ede5; stroke: #111; stroke-width: 1; } .flow { stroke: #111; stroke-width: 1; fill: none; } SvNode model node with slots, subnodes, annotations - Tile renders one node; shows title, subtitle, optional inline editor, selection state, accessibility metadata - Column / Stack ordered list of tiles for a node's subnodes, vertical or horizontal per node preference - Master-Detail Split column on one side, detail view on the other; selecting a tile opens its node as the next column, composing recursively (Miller-columns-style) Tiles, columns, and splits nest recursively, so a single composition handles arbitrary navigation depth and mixed orientations. - Auto-Generated Views - Custom Views - Companion View - Programmatic Styling - Themes and Style States - Responsive --- Source: /docs/Views/Auto-Generated%20Views/ # Auto-Generated Views How the view layer connects to model nodes, resolves view classes, synchronizes state, and provides navigation without hand-authored UI code. ## Overview In STRVCT, every domain node (`SvNode`) automatically receives a visual presentation: the framework discovers the matching view class, instantiates views lazily on demand, wires up observation notifications, and keeps views synchronized as model slots mutate. Domain Model (SvNode) Declared Slots Slot metadata & annotations Ordered Subnodes Child subnode graph Slot Setter Mutation Posts didChangeSlot note View Resolution Engine nodeViewClassName Explicit override check Name Convention Lookup Walks ClassName + "View" SvSyncScheduler Pass Coalesces view.syncFromNode() Generated Miller Column UI SvStackView / SvNavView Master-detail layout column SvTilesView & SvTile Scrollable tile selection list SvFieldTile Controls Type-appropriate field editors --- ## `SvDomView` Single-Inheritance Layering Rather than subclassing raw HTML elements directly, STRVCT wraps DOM elements in a single-inheritance hierarchy where each layer adds one capability: | View Class Layer | Added Capability | |---|---| | **`SvElementDomView`** | Wraps DOM element; manages creation, type, and class attributes. | | **`SvVisibleDomView`** | Visibility toggling (`setIsVisible(bool)`). | | **`SvResponderDomView`** | Responder chain for keyboard and mouse event routing. | | **`SvListenerDomView`** | DOM event listener registration and removal. | | **`SvControlDomView`** | Target/action pattern connecting views to event handlers. | | **`SvSelectableDomView`** | Selection state with styled visual feedback. | | **`SvEditableDomView`** | Content editability and edit mode toggling. | | **`SvGesturableDomView`** | Gesture recognizers (tap, double-tap, pan, long-press, pinch). | | **`SvFlexDomView`** | Flexbox layout properties (direction, wrap, grow, shrink, alignment). | | **`SvStyledDomView`** | State-based styling (unselected, selected, active, disabled) with theme support. | | **`SvSubviewsDomView`** | Parent/child subview hierarchy management. | | **`SvCssDomView`** | Applies CSS variables from dictionaries to element styles. | | **`SvDomView`** | Aggregates all layers above into the complete DOM view wrapper. | | **`SvNodeView`** | Binds model `SvNode` to DOM presentation; handles observation & sync. | --- ## `SvNodeView` Bridge Methods `SvNodeView` is the primary class for application views: - `setNode(aNode)`: Assigns a model node and registers change observations via `SvNotificationCenter`. - `syncFromNode()`: Diffs visible subnodes against active subviews, instantiating, reusing, or purging views as needed. - `subviewProtoForSubnode(aSubnode)`: Resolves which view class to instantiate for a child subnode. - `syncCssFromNode()`: Applies CSS variables defined on the model node to the DOM element. --- ## View Resolution Lookup Algorithm When a node becomes visible, the framework discovers its view class using naming conventions: 1. **Explicit Override:** Check for an explicit `nodeViewClassName` override on the node. 2. **Inheritance Walk:** Walk the node's class hierarchy from most-derived to base (`SvNode`). 3. **Convention Lookup:** For each class ancestor, check for `ClassName + "View"` in global scope. 4. **Fallback:** If no match is found down to the root, fall back to default `SvNodeView`. *Example:* For `Character` extending `SvStorableNode`, resolution checks `CharacterView` $\rightarrow$ `SvStorableNodeView` $\rightarrow$ `SvNodeView`. --- ## Navigation Containers (`SvStackView` & `SvBrowserView`) ### `SvStackView` `SvStackView` is the recursive building block of navigation, splitting into two areas: - **`SvNavView` (Master):** A column containing a header, scrollable `SvTilesView`, and footer. - **`otherView` (Detail):** Content area for the selected tile—typically a child `SvStackView`. Selecting a tile creates a new child `SvStackView` in the detail area. **Orientation** is set per node (`"right"` for horizontal master-left/detail-right, `"down"` for vertical master-top/detail-below). ### `SvBrowserView` Top-level application container managing nested `SvStackView` columns to arbitrary depth. Includes a breadcrumb header that auto-compacts on narrow viewports: - `navigateToNode(aNode)`: Navigates directly to a target node in the graph. - `selectNodePathArray(pathArray)`: Programmatically sets the full navigation path. --- ## Tile Classes & Field Tiles Tiles are individual items rendered inside `SvTilesView` columns: | Tile Class | Purpose & Visual Presentation | |---|---| | **`SvTile`** | Base tile class. Handles selection, long-press reorder, slide-to-delete, and style state cascades. | | **`SvTitledTile`** | Default tile. Displays title, subtitle, and note from `SvSummaryNode`. | | **`SvHeaderTile`** | Non-selectable section header tile. | | **`SvBreadCrumbsTile`** | Compact breadcrumb trail tile. | ### Field Tiles (`SvFieldTile`): Field tiles render key-value property slots as editable controls: | Field Tile Class | Property Control Type | |---|---| | **`SvStringFieldTile`** | Single-line text input | | **`SvTextAreaFieldTile`** | Multi-line text area editor | | **`SvBooleanFieldTile`** | Checkbox toggle control | | **`SvPasswordFieldTile`** | Masked password text input | | **`SvActionFieldTile`** | Button triggering a node method | | **`SvPointerFieldTile`** | Object reference with navigation arrow | | **`SvImageWellFieldTile`** | Image preview well with drag-and-drop support | | **`SvVideoWellFieldTile`** | Video player well with drag-and-drop support | --- ## Related Guides - [Custom Views](../Custom%20Views/index.html): Authoring custom view subclasses. - [Companion View](../Companion%20View/index.html): Docked secondary views. - [Responsive Views](../Responsive/index.html): Column compaction and mobile collapse. --- Source: /docs/Views/Companion%20View/ # Companion View A persistent secondary context docked alongside a node's navigation, collapsing behind an edge handle or disappearing as the viewport narrows. ## Overview A **companion** is a secondary region the view layer displays alongside a node's primary master-detail navigation: a chat panel beside a gaming session, a property inspector beside a document editor, or a reference pane beside a campaign tree. Unlike popovers or modal drawers, a docked companion lives in normal layout flow: it reserves real layout space, causing adjacent navigation columns to compact smoothly without obscuring content. SvStackView / SvDetailView Layout Container Primary Navigation Subchain (SvStackView) SvNavView (Master) • Column 1 Tiles • Column 2 Tiles SvNavView (Detail) • Selected Node Tiles ⋮ SvCompanionView node = nodeCompanionNode() Embedded SvBrowserView Isolated Navigation Context (handlesGlobalNav = false) --- ## Model-View Boundary Protocol (`nodeCompanionNode`) A domain node opts into displaying a companion by answering the optional protocol method: ```javascript nodeCompanionNode () { return this.someOwnedCompanionNode(); // returns the companion root node, or null for none } ``` The node specifies *which* node to show alongside itself, but zero UI details: width, axis, pinning, and collapse state are managed entirely by the view layer. This maintains strict headless testability. --- ## The Three Display States | State | Visual Behavior | Space Allocation | |---|---|---| | **`docked`** | Panel is expanded alongside or beneath navigation columns. | Reserves full length (`companionReservedWidth()`); columns compact to fit. | | **`tab`** | Panel is collapsed into a zero-width tab handle. | Panel occupies 0px. Adjacent `SvNavView` displays expansion handle. | | **`hidden`** | Panel and handle are both suppressed. | Viewport is too narrow to offer companion without breaking primary content. | --- ## Space Arbitration & Keyboard Shortcuts `SvDetailView` arbitrates layout space using `setAvailableLength()`: - **Threshold Check:** If available width falls below `tabLength`, mode switches to `hidden`. - **User Pinning:** Clicking the edge handle toggles between `docked` and `tab`, persisting the choice as `userMode`. - **Shortcut:** Pressing **Meta+\\** (Cmd+\\ or Ctrl+\\) toggles the deepest visible companion in the active navigation chain. --- ## View Class Structure ``` SvStackView └─ SvDetailView (owns space arbitration) ├── childStackView (primary flexible navigation) └── SvCompanionView (node = nodeCompanionNode()) ├── contentView (embedded isolated SvBrowserView) ├── SvEdgeHandleView (collapse/expand handle) └── SvCompanionTabView (internal badge plumbing) ``` --- ## Theming & CSS Variables | CSS Variable | Applies To | |---|---| | `--SvCompanion-bg` | Companion panel background color | | `--SvCompanionTab-color` | Legacy tab text styling | | `--SvCompanionTab-border-color` | Legacy tab border color | --- ## Related Guides - [Responsive Views](../Responsive/index.html): Viewport compaction and column collapse. - [Auto-Generated Views](../Auto-Generated%20Views/index.html): Miller column stack containers. --- Source: /docs/Views/Custom%20Views/ # Custom Views Authoring custom view classes, DOM wrappers, flex shortcuts, and model synchronization for specialized media. ## Overview While auto-generated views handle structured domain data, custom view classes are created for **specialized media** where spatial layout carries irreducible domain meaning: WebGL 3D viewports, canvas drawing, media players, overlay panels, or battle maps. ``` +-------------------------------------------------------------------------+ | Custom View Lifecycle | +-------------------------------------------------------------------------+ | 1. Extend SvNodeView --> 2. Instantiate via clone() --> 3. addSubview | | 4. Chained Setters --> 5. syncFromNode() --> 6. DevTools | +-------------------------------------------------------------------------+ ``` --- ## The Custom View Pattern Custom views extend `SvDomView` (or `SvNodeView`) and perform setup inside `init()`: ```javascript (class MyOverlayView extends SvNodeView { init () { super.init(); this.setPosition("fixed"); this.setTop("0"); this.setLeft("0"); this.setWidth("100vw"); this.setHeight("100vh"); this.makeFlexAndCenterContent(); this.setBackgroundColor("rgba(0, 0, 0, 0.5)"); this.setZIndex(9999); // Create child view via clone() this._label = SvDomView.clone(); this._label.setColor("white"); this._label.setFontSize("24px"); this.addSubview(this._label); return this; } syncFromNode () { super.syncFromNode(); const node = this.node(); if (node) { this._label.setInnerHTML(node.statusText()); } } }.initThisClass()); ``` --- ## View Construction Rules: `clone()` vs `new` - **Always Use `clone()`:** View instances MUST be instantiated via `Class.clone()` rather than `new Class()`. - **Initialization Phases:** `clone()` executes the three-phase lifecycle automatically: `init()` $\rightarrow$ `finalInit()` $\rightarrow$ `afterInit()`. - **View Tree & DOM Tree:** `this.addSubview(childView)` establishes both the internal framework subview hierarchy and appends the underlying DOM element. --- ## `SvFlexDomView` Layout Shortcuts | Shortcut Method | CSS Property Modifications | |---|---| | `makeFlexAndCenterContent()` | Sets `display: flex`, `justify-content: center`, `align-items: center`. | | `makeStandardFlexView()` | Sets `display: flex`, `position: relative`, `overflow: hidden`. | | `fillParentView()` | Sets `width: 100%` and `height: 100%`. | | `newFlexSubview()` | Creates and appends a flex child with `min-width: 0` and `min-height: 0`. | --- ## Related Guides - [Auto-Generated Views](../Auto-Generated%20Views/index.html): View resolution and stack containers. - [Responsive Views](../Responsive/index.html): Viewport compaction and column collapse. --- Source: /docs/Views/Programmatic%20Styling/ # Programmatic Styling Named CSS methods, the chainable API, and why STRVCT avoids CSS files. ## Why No CSS Files? ### The cascade is additive The CSS cascade is designed for documents: you declare rules, the browser resolves conflicts by specificity and source order, and the result is static. You can mutate individual rules through the CSSOM, but the cascade itself is additive — removing a rule doesn't restore a known-good state, it just lets some other rule win, potentially one you didn't intend. This makes the cascade unreliable for UI components whose appearance changes frequently at runtime. ### State combinatorics The deeper problem is combinatorial. Consider the independent states a single view might have: editable or read-only, selected or unselected, highlighted or not, showing an error, previously navigated, disabled. Five boolean states produce 32 combinations, and each combination may need distinct styling. In a stylesheet, each combination requires its own selector or class chain — and the count doubles with every new state. You can try to treat each state independently (`.selected` sets some properties, `.error` sets others), but that only works when the states don't interact visually. When "selected + error" needs to look different from the sum of "selected" and "error" applied separately, you're back to enumerating combinations. ### Theming compounds the problem CSS custom properties can swap values at runtime, but they don't help with the structural problem of *which properties to set in which state combinations*. When a user customizes a theme, or different regions of the UI use different themes simultaneously, every state combination now has a theme axis too. The custom properties handle the value lookup, but the combinatorial selector structure they plug into still has to be authored and maintained by hand. ### The programmatic alternative Programmatic styling sidesteps all of this. Each state applies its visual changes directly to the element, and the results compose naturally — enabling "selected" and "error" at the same time just means both sets of property changes are applied, with explicit logic for cases where they interact. Themes are dictionaries of values that can be swapped or scoped to any subtree at any time — no cascade resolution, just direct assignment. The styling logic lives alongside the view logic that drives it, so the two can't drift apart. ## Named Property Methods Every view inherits named setter/getter pairs for standard CSS properties. These are the primary styling API: ```javascript this.setBackgroundColor("rgba(0, 0, 0, 0.5)"); this.setPosition("fixed"); this.setDisplay("flex"); this.setZIndex(9999); this.setTop("0"); this.setLeft("0"); this.setWidth("100vw"); this.setHeight("100vh"); this.setFontSize("14px"); this.setColor("white"); this.setBorderRadius("8px"); this.setOverflow("hidden"); this.setPadding("16px"); this.setBoxShadow("0 2px 8px rgba(0,0,0,0.15)"); ``` Every setter returns `this`, so calls chain naturally. Each property also has a corresponding getter (e.g. `backgroundColor()`, `fontSize()`). ## Flexbox Methods `SvFlexDomView` adds named methods for every flexbox property: ```javascript this.setDisplay("flex"); this.setFlexDirection("column"); this.setJustifyContent("center"); this.setAlignItems("stretch"); this.setFlexWrap("wrap"); this.setFlexGrow(1); this.setFlexShrink(0); this.setFlexBasis("auto"); this.setGap("8px"); ``` ## Layout Convenience Methods `SvFlexDomView` also provides higher-level shortcuts for common multi-property patterns: | Method | Effect | |--------|--------| | `makeFlexAndCenterContent()` | Sets display flex, centers both axes | | `flexCenterContent()` | Centers content horizontally and vertically | | `makeStandardFlexView()` | Flex display, relative positioning, centered, overflow hidden | | `fillParentView()` | Sets width and height to 100% | | `newFlexSubview()` | Creates and adds a flex child with min dimensions set | ## Sizing Shortcuts Convenience methods for constrained sizing: | Method | Effect | |--------|--------| | `setMinAndMaxWidth(v)` | Sets min-width, max-width, and width to the same value | | `setMinAndMaxHeight(v)` | Sets min-height, max-height, and height to the same value | | `setMinAndMaxWidthAndHeight(v)` | Sets all six sizing properties at once | These are useful for fixed-size elements like icons or thumbnails where you want all constraints to agree. ## Node-Driven CSS Nodes can also request CSS properties that get applied to their view automatically. A node implements `cssVariableDict()` to return a dictionary of CSS key/value pairs: ```javascript cssVariableDict () { return { "color": this.isActive() ? "white" : "gray", "--accent-color": this.themeColor() }; } ``` During the normal sync cycle, `SvNodeView.syncCssFromNode()` picks up this dictionary and applies it to the view's DOM element. This lets model logic influence presentation without the node needing any reference to its view — the node declares what it wants, and the view system handles the rest. In general, prefer keeping styling in the view layer. Node-driven CSS is available for cases where the model genuinely determines a visual property (e.g. a user-chosen color or a status-dependent highlight), but most styling belongs in views or themes, not in model code. ## Low-Level Access For unusual CSS properties that don't have a named method, `SvCssDomView` provides generic accessors: | Method | Description | |--------|-------------| | `setCssProperty(key, value)` | Sets any CSS property by name | | `getCssProperty(key)` | Gets the computed value | | `removeCssProperty(key)` | Removes a property | These should be rare in practice — the named methods cover the vast majority of styling needs. --- Source: /docs/Views/Responsive/ # Responsive Views Automatic viewport compaction, last-column stretching, and per-node width hooks without per-screen layout code. ## Overview Responsive behavior in STRVCT is not a separate rendering mode or set of CSS breakpoints. The same master-detail composition that produces a multi-column Miller view on a wide desktop produces a one-column stack with breadcrumbs on a phone, because `SvStackView` measures available width and automatically collapses columns that would overflow the viewport. This behavior—**automatic collapsing**—falls out of the same primitives used for navigation at any width; there is zero separate "mobile" code path in the view hierarchy. Wide Desktop Viewport (> 800px) Column 1 Expanded Column 2 Expanded Column 3 Expanded Narrow Mobile Viewport (< 480px) Breadcrumbs: Workspace > Projects Column 3 (Active Column - 100% Width) Columns 1 & 2 auto-collapsed (display: none) --- ## The Two Layout Mechanisms ### 1. Compaction (`compactNavAsNeeded`) `SvStackView.compactNavAsNeeded()` walks the stack chain from outermost (leftmost) to innermost (rightmost), summing target widths against available viewport space (`topViewWidth()`): - **Fits:** The column is `uncollapse()`d and displayed. - **Overflows:** Earlier columns are `collapse()`d (`display: none`). The current (deepest) column stays visible as long as possible. ### 2. Last-Column Stretch (`updateWidthForWindow`) `SvNavView.updateWidthForWindow()` determines width for visible columns: - If `targetWidth() >= windowWidth`, the column takes `width: 100%`. - If a column is the last visible column AND `windowWidth < targetWidth * 2`, it stretches to `width: 100%` to fill available slack instead of leaving dead space. --- ## Per-Node Layout Protocol Hooks Domain nodes can influence layout without writing custom view code: | Node Method | Purpose & Behavior | |---|---| | `nodeMinTileWidth()` | Declares a minimum tile width floor for the column. Useful for wide property inspectors. | | `nodeFillsRemainingWidth()` | When `true`, forces the column to stretch to 100% width whenever it is the last visible column. Useful for document editors or chat logs. | --- ## Viewport vs Device Detection - **`SvWebBrowserWindow.shared().width()`**: Returns current viewport width in CSS pixels. Always use this for layout and compaction decisions. - **`SvWebBrowserWindow.shared().isOnMobile()`**: User-agent string match (iPhone/Android). Use *only* for touch-gesture or platform-specific permissions, never for column width sizing. --- ## iOS Safari Visual Viewport Note On iPhone Safari, CSS `100vh` units fail to subtract the animated URL bar area (~40px overflow). The reliable fix is binding root page height to `window.visualViewport.height` during `visualViewport.resize` and `orientationchange` events. --- ## Related Guides - [Auto-Generated Views](../Auto-Generated%20Views/index.html): Navigation containers and tiles. - [Companion View](../Companion%20View/index.html): Space arbitration for docked companions. --- Source: /docs/Views/Themes%20and%20Style%20States/ # Themes and Style States How views resolve their appearance from theme classes, style states, and node configuration. ## Overview Every view has a visual state — selected, active, disabled, or the default unselected. A theme defines what each state looks like for each kind of view. The view asks the theme "what should I look like right now?", applies the answer, and re-asks whenever its state changes. This indirection means swapping a theme changes the appearance of the entire UI without touching any view code, and different subtrees can use different themes simultaneously. ## Style States `SvStyledDomView` tracks three independent boolean properties: `isSelected`, `isActive`, and `isDisabled`. These combine into a single resolved state name with a fixed priority: 1. **disabled** — checked first, takes precedence over all others 2. **active** — the view is the current focus of interaction 3. **selected** — the view has been chosen but isn't the active focus 4. **unselected** — the default when none of the above apply When any of these properties change, the view re-resolves its state and re-applies the corresponding styles from the current theme. ## Theme Architecture The theme system is a hierarchy of named objects: - **`SvThemeResources`** — Singleton that holds the active theme. - **`SvTheme`** — A complete theme containing a set of theme classes. - **`SvThemeClass`** — Defines style values for a particular kind of view (e.g. "SvTile", "TextTile", "Header"). Theme classes form a hierarchy — a class inherits from its parent, so "TextTile" inherits defaults from "SvTile" and only overrides what differs. - **`SvThemeState`** — One state within a theme class (e.g. "selected" within "SvTile"). Contains concrete style values: color, backgroundColor, fontSize, padding, border, and dozens more. ## How a View Resolves Its Style When a view needs to apply its current style: 1. The view reads its `themeClassName` (set on the node via `SvStyledNode`, or inherited from the parent view). 2. It asks the active theme for the `SvThemeClass` matching that name. 3. It determines its current state name (`disabled`, `active`, `selected`, or `unselected`). 4. It retrieves the `SvThemeState` for that state from the theme class. 5. The theme state applies its values to the view via named setter methods (`setColor()`, `setBackgroundColor()`, etc.). Style values resolve up the theme class hierarchy — if "TextTile" doesn't define a `backgroundColor` for its "selected" state, the lookup walks up to "SvTile" and uses its value. ## Node-Side Configuration Nodes control which theme class their view uses through the `themeClassName` slot on `SvStyledNode`. This slot is marked `syncsToView`, so changing it triggers a re-style automatically. The node doesn't know anything about the visual details — it just names the class, and the theme provides the rest. ## Locked Attributes Views can lock individual style attributes via `lockedStyleAttributeSet()`. Locked attributes are skipped when a theme state applies its values, allowing a view to override specific properties that the theme would otherwise control. This is useful for views that need a fixed value regardless of state — for example, a view that must always have a transparent background. ## Switching Themes Because all style values flow through the theme, switching the active theme on `SvThemeResources` and calling `resyncAllViews()` re-styles every view in the hierarchy. No individual view needs to be updated manually. Different regions of the UI can also use different theme class names, so a single theme can provide distinct appearances for different areas (e.g. a sidebar vs. a content panel) without any special-case logic. --- Source: /Example%20App/ # Example App A complete contacts application in four classes, with zero view code. ## Overview This walkthrough builds a working contacts app from scratch to show how the pieces of STRVCT fit together. The app lets you create contacts with name, email, phone, and notes fields — all editable, navigable, and persisted to IndexedDB automatically. The entire application is four small classes and a few configuration files. ## The Model ### Contact A single contact with four fields. Each slot is annotated for storage and editing: ```javascript (class Contact extends SvStorableNode { static jsonSchemaDescription () { return "A person's contact information"; } initPrototypeSlots () { { const slot = this.newSlot("name", ""); slot.setSlotType("String"); slot.setShouldStoreSlot(true); slot.setCanEditInspection(true); slot.setLabel("Name"); } { const slot = this.newSlot("email", ""); slot.setSlotType("String"); slot.setShouldStoreSlot(true); slot.setCanEditInspection(true); slot.setLabel("Email"); } { const slot = this.newSlot("phone", ""); slot.setSlotType("String"); slot.setShouldStoreSlot(true); slot.setCanEditInspection(true); slot.setLabel("Phone"); } { const slot = this.newSlot("notes", ""); slot.setSlotType("String"); slot.setShouldStoreSlot(true); slot.setCanEditInspection(true); slot.setLabel("Notes"); } } initPrototype () { this.setShouldStore(true); this.setNodeCanEditTitle(true); this.setTitle("New Contact"); this.setNodeCanInspect(true); } // The tile in the contact list shows the name as title and email as subtitle title () { return this.name() || "New Contact"; } subtitle () { return this.email(); } }.initThisClass()); ``` That's the entire Contact class. The framework reads the slot annotations and generates: - An editable tile in the contacts list (showing `title()` and `subtitle()`) - An inspector view with labeled fields for each slot when you select it - Automatic persistence to IndexedDB whenever any field changes - Change notifications that keep the tile in sync with the field values ### Contacts A collection that holds Contact items: ```javascript (class Contacts extends SvJsonArrayNode { initPrototype () { this.setTitle("Contacts"); this.setSubnodeClasses([Contact]); this.setShouldStore(true); this.setShouldStoreSubnodes(true); this.setNodeCanAddSubnode(true); this.setNodeCanReorderSubnodes(true); } }.initThisClass()); ``` `setSubnodeClasses([Contact])` tells the framework what kind of objects this collection holds. `setNodeCanAddSubnode(true)` adds an "add" action to the UI. `setShouldStoreSubnodes(true)` persists the list and its contents. New contacts are created by tapping the add button — no handler code needed. ## The App ### ContactsModel The root model node. This is the top of the object hierarchy that becomes the navigation tree: ```javascript (class ContactsModel extends SvStorableNode { initPrototypeSlots () { { const slot = this.newSlot("contacts", null); slot.setFinalInitProto(Contacts); slot.setIsSubnode(true); } } initPrototype () { this.setShouldStore(true); this.setShouldStoreSubnodes(true); this.setTitle("Contacts App"); } }.initThisClass()); ``` `setFinalInitProto(Contacts)` tells the framework to create a `Contacts` instance during initialization — but only if one wasn't already loaded from storage. This is the key mechanism that makes the three-phase lifecycle work: on first run, the `Contacts` node is created fresh; on subsequent loads, it's restored from IndexedDB with all its data intact. `setIsSubnode(true)` places it in the navigation hierarchy. ### ContactsApp The application class — just declares which model and UI to use: ```javascript (class ContactsApp extends SvApp { initPrototypeSlots () { { const slot = this.overrideSlot("model"); slot.setSlotType("ContactsModel"); } } initPrototype () { this.setName("Contacts"); } }.initThisClass()); ``` That's the entire app class. `overrideSlot("model")` tells the base `SvApp` to use `ContactsModel` as the root. The framework handles everything else: opening the store, creating or loading the model, setting up the UI, and wiring synchronization. ## Project Files ### _imports.json The import manifest tells the build system which files to include: ```json [ "Contact.js", "Contacts.js", "ContactsModel.js", "ContactsApp.js" ] ``` A root-level `_imports.json` would reference the framework and this app folder: ```json [ "strvct/_imports.json", "app/_imports.json" ] ``` ### app.html The HTML entry point loads the boot loader: ```html Contacts ``` ### Build Run the indexer to generate the content-addressable resource bundle: ```bash node ./strvct/source/boot/index-builder/ImportsIndexer.js ``` This produces `_index.json` (metadata) and `_cam.json.zip` (compressed bundle). Serve the directory with any static file server and open `app.html`. ## What You Get From these four classes, the framework generates: - A navigable list of contacts with add and reorder support - Editable inspector fields for each contact's properties - Persistent storage — close the browser, reopen, data is still there - Bidirectional sync — edit a field, the tile title updates; changes batch efficiently - Keyboard navigation, breadcrumbs, and responsive column compaction - Slide-to-delete on contacts No view classes were written. No event handlers. No storage code. No routing. The domain model is the application. ## Adding Cloud Sync Assuming you have a Firebase project with Storage enabled, making the contacts collection sync to the cloud is a two-line change. Replace the base class and add a folder name: ```javascript (class Contacts extends SvSyncableArrayNode { initPrototype () { this.setTitle("Contacts"); this.setSubnodeClasses([Contact]); this.setShouldStore(true); this.setShouldStoreSubnodes(true); this.setNodeCanAddSubnode(true); this.setNodeCanReorderSubnodes(true); } cloudFolderName () { return "contacts"; } }.initThisClass()); ``` `SvSyncableArrayNode` extends `SvJsonArrayNode` with cloud sync capabilities. The `cloudFolderName()` method tells the framework where to store this collection's data in Firebase Storage. Everything else — delta tracking, manifest management, retry with backoff, and session locking — is inherited automatically. The collection syncs when the app saves, and loads from the cloud on the next login. --- Source: /FAQ/ # FAQ Frequently asked questions about STRVCT. ## What is the naked objects pattern? The idea that the domain model should be the user interface. Instead of writing separate view code for every screen, you annotate model classes with metadata (which properties are editable, which should persist, how they relate to each other) and the framework generates a complete, navigable UI from those annotations. The pattern was proposed by Richard Pawson in his 2004 PhD thesis. STRVCT's contribution is a set of composable UI primitives — tiles, tile stacks, and nested master-detail views — that make the generated interfaces feel like hand-crafted ones. ## Do I have to use the generated UI? No. The auto-generated views cover the common case, but you can override any node's view by creating a custom view class that follows the naming convention (e.g., `MyNodeView` for `MyNode`). In practice, most applications need very few custom views — undreamedof.ai has ~90 domain classes and 11 custom view and tile classes, mostly for graphical or highly interactive things like 3D dice, the battle map, the chat stage, and print previews. Custom views are also simple work for a coding agent: the node already defines the data, its types and its notifications, so the view only reads, draws and calls methods. It doesn't need to fetch, cache or persist anything, and nothing outside the one node changes. ## Does it use npm or standard ES modules? No. The choice is load-bearing rather than stylistic. **Caching at scale:** For the kind of app STRVCT targets — hundreds of model classes running client-side, long-lived installs, data that stays resident across sessions — mainstream JavaScript tooling delivers a noticeably poor experience. Loading ES modules individually makes cold starts slow once you have a few hundred files. Bundlers solve the request count but invalidate the whole chunk on any change, and browser caches key on URL rather than content, so each deployment makes clients re-download bytes they already have. Code-splitting and cache-busting configurations narrow but don't close that gap. STRVCT uses a content-addressable build instead: resources are keyed by the SHA-256 hash of their content, so unchanged code is never re-downloaded — even across deployments, and even when the same code appears at different paths. You declare dependencies in `_imports.json` files, and the build tools produce a small manifest plus a hash-indexed bundle. The tradeoff is that standard import/export syntax isn't used within the framework, and npm packages can't be used directly. A handful of third-party libraries (pako, htmlparser2, jwt-decode, js-sha256, simple-peer) are included as source files in `external-libs/` rather than managed through a package manager. **Cross-platform:** Vendoring lets the framework ensure every dependency works in both the browser and Node.js, which matters because STRVCT's model layer is designed to run in both. Arbitrary npm packages frequently assume one environment or the other, which would conflict with that goal. **Security:** There are no transitive dependencies, no post-install scripts, and no exposure to supply chain attacks through compromised or malicious npm packages. The entire dependency tree is vendored source in the repository — auditable and version-controlled. ## Why not TypeScript? STRVCT is designed for large client-side projects, with hundreds of model classes loaded in the browser. At that scale, traditional web package systems become too slow, which is why the framework uses a content-hashed caching build instead of standard ES modules. TypeScript would add its own transpiler and type-checker pass on top of that, and getting source-level debugging to work cleanly with both the eval-based loading and a TS pipeline is non-trivial. Slot annotations already carry runtime type information that serves most of TypeScript's validation and documentation roles, so the integration cost looked high relative to the benefit. It's left as potential future work. ## How does persistence work? Mark a class with `setShouldStore(true)` and its slots with `setShouldStoreSlot(true)`. The framework handles everything else: dirty tracking, batched commits at the end of each event loop, and transparent IndexedDB storage. Objects loaded from storage go through the same initialization lifecycle as new objects — no separate code paths. Cloud sync to Firebase Storage is available by extending `SvSyncableArrayNode` and providing a folder name. ## Is it local-first? Yes. Data lives in the browser's IndexedDB by default. The application works fully offline. Cloud sync is opt-in and additive — it backs up data and enables cross-device access, but the local database is always the primary store and serves as a cache for cloud data on subsequent loads. ## How is styling handled? All styling uses named JavaScript methods (`setBackgroundColor()`, `setFlexDirection()`, `setPadding()`) rather than CSS files. Themes are swappable dictionaries that can be scoped to any subtree. This avoids the combinatorial explosion of CSS selectors when views have multiple independent states (selected, disabled, highlighted, error, etc.) that interact visually. See the [Programmatic Styling](docs/Views/Programmatic%20Styling/) docs for details. ## What about routing? There is no router. The object graph is the navigation structure. Nested objects produce drill-down columns. Breadcrumbs, column compaction on narrow viewports, and keyboard navigation are built in. Adding a new object type to the model automatically makes it navigable — no route configuration needed. ## What browsers are supported? Modern evergreen browsers (Chrome, Firefox, Safari, Edge). STRVCT uses contemporary JavaScript features like WeakRef, FinalizationRegistry, and private class fields. There is no transpilation step or polyfill layer. ## Can it run outside the browser? Yes. The model layer, persistence system, and boot sequence all run in Node.js with no DOM — the same application code, the same storage behavior, the same object lifecycle, just without the view layer. This is possible because the model never references views; views observe the model through notifications, not the other way around. Useful for tests, CLI tools, and server-side processing of the same object graphs the client uses. See [Headless Execution](../docs/Lifecycle/Headless%20Execution/) for details. ## Is it production-ready? STRVCT is in active development and used in production by [undreamedof.ai](https://undreamedof.ai), an AI-powered virtual tabletop for D&D with ~90 domain classes, multiplayer sessions, cloud sync, and AI integration. The framework has been in continuous development since 2018. It is not yet widely adopted and the API may still change. ## What happens if the author stops working on this? MIT-licensed, and the entire codebase is readable: plain JavaScript, no transpiler, no opaque build chain, no transitive npm dependencies. The few third-party libraries are vendored source in `external-libs/`. If development stops, a sufficiently motivated user could fork it without needing to reverse-engineer a tooling stack first. It's not a reassuring answer in the sense of "you'll get corporate backing" — but compared to frameworks that lock you into their ecosystem, the escape route is short. ## What kinds of apps is it a good fit for? **App-shell SPAs:** logged-in, state-heavy products where the running application is the product and the marketing surface, if any, is a separate concern. A lot of the highest-valued consumer software being built right now fits this shape: OpenAI, Anthropic, xAI, Perplexity, Cursor (Anysphere), Harvey, Glean, Character.ai, ElevenLabs, Suno, Gamma, Midjourney — and, from the prior generation, Notion, Linear, Figma, Discord. Almost none of these depend on SSR or SEO for their core product. ChatGPT, Claude, Cursor, Figma, Linear, Notion, Discord, Character.ai, Suno, and Midjourney are all app-shell SPAs where the logged-in product is the product. They have marketing pages that need SEO, but those are typically a separate concern, often on a different stack entirely. The app itself is a client-side application with heavy state, real-time interaction, and no meaningful SEO surface. **Where it fits:** heavy client-side state, hundreds of domain classes, local-first persistence, first-class LLM integration, and a UI generated from the model rather than hand-assembled per screen. **Where it doesn't:** content platforms, traditional e-commerce, or marketing sites — categories where SEO and first-paint latency are competitive necessities and where frameworks like Next.js exist precisely to serve. The marketing surface around an app-shell SPA can be handled separately: [undreamedof.ai](https://undreamedof.ai) pairs a static marketing site with a STRVCT app on the same domain, which is usually the right split anyway. **Visual distinctiveness as the pitch:** the auto-generated UI has a consistent look of its own. Custom views can override any piece, but products where the interface is itself a design statement will spend more effort fighting the defaults than riding them. The framework suits products where correctness, data density, and navigation consistency matter more than visual differentiation. ## What's the history of this project? **Origins:** STRVCT began as internal infrastructure, not as a framework project. The earliest code was written in 2016 as part of an application called bitmarkets.js — Miller columns, a node hierarchy, and slot-based persistence — and was carried into a second unrelated application, voluntary.app, starting in 2017. The framework code was progressively separated from application code and extracted into its own repository, strvct.net, in 2020. It has since grown to include the object pool persistence system, gestures and drag-and-drop, content-addressable builds, cloud sync, and internationalization. The [Timeline](../Timeline/) has the full list of milestones. **Public presence:** The project has not been publicly marketed or announced. Its only public presence is the GitHub repository and links from the author's GitHub and Twitter profile subtitles. It is not a commercial product, has no funding or sponsoring organization, and is developed as a personal framework — used in production by [undreamedof.ai](https://undreamedof.ai). ## How do you pronounce STRVCT? Like "struct" — as in *structure*. The V is stylized; the pronunciation is the same. ## How does it work with AI-assisted development? **Less to coordinate:** STRVCT's architecture is well suited to AI-assisted "vibe coding." In a conventional framework, building a feature means coordinating across components, stylesheets, state management, persistence wiring, route definitions, and API layers — an AI has to understand and keep all of these in sync. In STRVCT, a feature is typically a single model class with annotated slots. The AI only needs to describe the domain — what properties an object has, which should persist, which are editable — and the framework handles the rest. **What follows:** An AI can produce working, persistent, navigable applications from high-level descriptions of the domain model without needing to generate or coordinate view code, storage logic, or navigation. The consistent slot annotation pattern is easy to learn from examples, and the same pattern applies to every class in the system. For complex, data-model-driven applications, this can dramatically reduce the amount of code an AI needs to generate and the number of places things can go wrong. ## How do I get help when I'm stuck? The ecosystem is small. There's no Stack Overflow tag, no Discord, no book. What's there: - In-repo docs, regenerated from markdown and linked from the main index - [`llms.txt`](/llms.txt) and [`llms-full.txt`](/llms-full.txt), designed to be pasted into an LLM coding assistant - The framework source itself — vendored, readable, plain JavaScript with no transitive dependencies - [GitHub issues](https://github.com/stevedekorte/strvct.net/issues) for bug reports and questions In practice the recommended workflow is to give an LLM-backed coding agent (Claude Code, Cursor, Codex, etc.) the relevant docs and source as context, then let it reason from first principles. The slot/notification/naked-objects patterns are regular enough that a capable model can internalize them from a few dozen files — which is how the framework author works with it day-to-day. ## How do I get started? See the [Example App](Example%20App/) for a complete working application in four classes, or the [Getting Started](docs/Getting%20Started/) guide for setup and project structure. --- Source: /Timeline/ # Project Timeline Key milestones from the first commit through present day Framework architecture, UI system, persistence, and developer tooling. - **2016-01** — bitmarkets.js: First commit; Miller column browser, node hierarchy, and initial slot-based persistence - **2016-03** — NotificationCenter: Notification system added; node-to-view sync via deferred timeouts - **2016-04** — Framework Separation: Library code separated from app code; CSS split into framework and app layers - **2016-05** — StorableNode: BMStorableNode, IndexedDB persistence with dirty tracking and circular reference handling - **2017-02** — voluntary.app: Continued framework development under the voluntary.app repository - **2017-04** — IndexedDB Rewrite: NodeStore with IndexedDB via SyncDB; automatic dirty marking on slot updates - **2017-07** — Flex Columns: Browser columns moved to flex layout; touch scrolling and mobile orientation support - **2017-08** — Boot System: Boot folder and loading infrastructure; BMStorableNode separated from BMNode - **2018-06** — ES6 Classes: Migration from prototype-based Proto system to ES6 classes throughout the framework - **2019-02** — Gesture System: GestureRecognizer state machine with EventSetListener; TapGestureRecognizer - **2019-03** — Full Gesture Suite: LongPress, Slide, Pinch, and Rotation recognizers; GestureManager arbitration - **2019-09** — Drag and Drop: Drag-and-drop protocol with animations, placeholder views, and column caching - **2019-11** — Slot System: Formal Slot class with newSlot(); ObjectPool persistence; migration from Proto to classes - **2020-01** — strvct.net: New repository created; voluntary.app codebase imported as foundation - **2020-02** — Flex Layout: DomSplitView and flexible layout system for browser columns - **2020-02** — Image & Blob: Image wells, blob drops, MIME type support, and drag views - **2020-03** — Tile System: BrowserRows renamed to Tiles; tile-based navigation pattern solidified - **2020-04** — Content Store: Content-addressable blob storage with hash-based caching - **2020-05** — Themes: Theme system for customizable visual appearance - **2020-08** — WebRTC: PeerJS integration for real-time peer-to-peer communication - **2021-02** — Resource Loader: Rebuilt resource loading system with global compatibility fixes - **2022-01** — Boot Overhaul: Major cleanup of boot process, index building, and eval debugging - **2022-04** — CAM Build: Content-addressable memory build system with hash validation - **2022-05** — Breadcrumbs: BreadCrumbRowView for hierarchical navigation context - **2022-06** — Tile Rename: RowViews renamed to Tiles throughout the framework - **2022-08** — Object Pool: Major fixes for ObjectPool persistence, key handling, and event listeners - **2023-02** — App Bootstrap: Standardized App shared() pattern and resource setup - **2023-03** — Blob Cache: Content-addressable blob cache for efficient binary storage - **2023-07** — Blob Persistence: Full support for persisting blobs with reference tracking and GC - **2023-08** — WebRTC Service: WebRTC service layer for peer connection management - **2023-10** — HaveWords App: First major application built on STRVCT; later became Undreamed Of - **2024-01** — Music Library: Audio playback infrastructure for music and sound effects - **2024-04** — Error Handling: Error.rethrow() for chained error context; improved debugging - **2024-06** — Init Refactor: Split initPrototypeSlots and initPrototype for cleaner class setup - **2024-09** — Documentation: Comprehensive docs site with architecture guides and API reference - **2024-11** — Slot Maps: allSlotsMap fixes; improved slot introspection and enumeration - **2024-12** — AI Services: AI service abstraction layer supporting multiple providers - **2025-02** — Assistant API: Generalized AI Assistant and conversation management system - **2025-04** — Tool Calls: Structured tool calling system for AI function invocation - **2025-05** — Prompt Composer: Template-based prompt composition with file inclusion and variable substitution - **2025-09** — JSON Schema: Schema validation for model classes; AI-compatible type definitions - **2025-10** — Cloud Sync: Firebase Storage sync with write-ahead delta logs - **2025-11** — JSON Patches: RFC 6902 JSON Patch support for incremental model updates - **2026-01** — Image Gen: Image generation pipeline with evaluation and scaling - **2026-02** — Docs Site: Documentation site with layout engine, cards, and markdown support - **2026-03** — Internationalization: AI-powered UI translation with per-language IndexedDB and automatic model-to-view boundary translation - **2026-03** — Anchor Scroll: AI chat anchor scrolling and scroll-to-bottom button - **2026-03** — Battery Aware: Battery level monitoring for performance throttling detection - **2026-04** — AI Image Editor: Gemini-based image editing and scaling class hierarchy - **2026-04** — Accessibility: Automatic ARIA roles, labels, states, and landmarks derived from model annotations and view classes - **2026-04** — Public Cloud: SvPublicCloudSource for serving shared content via Firebase Storage manifests - **2026-05** — Cloud Documents: Read/write cloud filesystem with lease-based document sessions, write-ahead-log JSON-patch deltas, and abort-and-resync conflict handling - **2026-06** — Naked Objects Paper: Naked Objects paper published and compiled to PDF via Tectonic; production case study of undreamedof.ai (~90 classes, 98% derived views) - **2026-07** — Record Store Cloud: SvRecordStore protocol migration: single row schema across local IndexedDB and versioned cloud (SvCloudRecordStore), replacing JSON+WAL with atomic row delta commits - **2026-08** — Staged Commits & Folders: SvStagedRecordCommit for multi-batch transactions (>450 ops/4MB), SvCloudFolder for zero-list document membership via scope root queries, and fractional ordering keys - **2026-10** — Inline Views: Advanced inline placement layouts (anchored tabs, document section flows, section folds, and companion node docking) for rich document composition - **2026-10** — Architecture Docs: Comprehensive documentation rewrite: Technical Overview, Implementation Overview, React Rosetta Stone, AI Services, Getting Started, Persistence, Notifications, and SVG Diagram Conventions