Stackadia User Guide

Getting Started

Stackadia is a visual authoring environment combining cards, shared backgrounds, objects, Stackadia Script 1.2, media, vector graphics, Physics 1.0, Scene3D, local and external data, and XStack 3 packaging.

Supported release targets

Stackadia targets desktop and tablet-class layouts, with desktop macOS the primary qualification target. Consult the release notes for tested browsers and devices. Phone Portrait is a layout preview reference; phones are not supported release targets.

Basic workflow

1. Use Author mode to build and edit.
2. Create or select a card. Use Project Browser for structure and Storyboard for visual card navigation/reordering.
3. Choose a tool and place an object.
4. Settings → Authoring Defaults controls the application New Object Profile and Compact Desktop text size; 14 pt is the standard desktop default.
5. Edit frequent properties with Quick Properties or use the full Inspector.
6. Attach common behavior on the Actions page; use Advanced Actions or the Script IDE when you need more control.
7. Switch to Browse to use and test the project.

Reader is the distraction-free use state. Author exposes every creator capability. Maker, Designer, and Developer are authoring profiles that change interface emphasis and local Advanced disclosure only; they never unlock or remove features. Author/Browse still controls interaction with the card.

Current application pair

The Lightweight Player opens XStacks for playback. Use the full Standalone to create and edit them. This documentation covers Stackadia 1.4.4 Final. Standalone and Lightweight Player are qualified as a matched pair. Desktop macOS remains the primary tested authoring environment; tablet behavior is qualified separately and phones remain outside the release target.

Authoring Cards

Use the Card and Background layers to decide whether an object belongs only to the current card or is shared through its background.

Project Browser and Storyboard

The Project Browser is a separate resizable authoring window for cards, backgrounds, object ownership, and project structure. Storyboard provides visual card navigation and card reordering without replacing the Project Browser. Select a card to edit its name, destination, and background properties in Inspector.

Shift-click and marquee selection support multi-object edits. Use Edit → Select Objects… for filtered selection. Arrange → Alignment Palette opens the compact contextual align/distribute/match-size palette; Arrange → Align & Distribute… provides the full controls. The shared “Align to” reference can use selection bounds, the first selected object, or the card.

Quick Properties and Inspector

Quick Properties is the fast modeless surface for frequent edits. Use More Properties… to reach the full Inspector, including Basic, Appearance, Behavior, Actions, Data, and Advanced pages, plus Search and All Properties.

Layout presets

Window provides Authoring Layout, Scripting Layout (Developer), Paint & Media Layout, and Clean Preview Layout. Layout presets do not change the project runtime mode.

Useful shortcuts

• Command/Ctrl+Z — Undo
• Command/Ctrl+Shift+Z — Redo
• Command/Ctrl+C/X/V — Copy, cut, paste
• Delete — Delete selection
• Arrow keys — Nudge selection

Responsive direct manipulation

In Author mode, dragging, resizing, arrow-key nudging, alignment, distribution, and size matching update the active responsive rule. Percentage positions and sizes update their percentages; trailing anchors update their margins. Manually moving a centered axis converts that axis to an explicit percentage position. Children in horizontal, vertical, or grid flow remain controlled by their parent group layout.

Move or dock Project Browser

Open Project Browser from Window. Use its Float / Dock Right control to choose a movable window or the right dock. In floating mode drag the header and resize the window; it stays modeless so you can work on the card. Its placement is remembered locally. Smart Objects has its own scrolling content area, including when All Smart Objects is selected.

Project Properties

Choose File → Project Properties… to open the project Inspector directly. You can also select the project in Project Browser. Right-clicking the card normally targets the card, so use the File command for project dimensions and project-wide properties.

Preview and Responsive Layout

Base Design is the project’s canonical authoring coordinate system. The Preview control can show Base Design, Desktop 1440 × 900, Tablet Landscape, Tablet Portrait, Phone Portrait, or a Custom size without changing authored coordinates.

Release target note: Desktop and tablet-class layouts are intended targets; consult the release notes for actual tested environments. Phone Portrait is a preview reference, not a supported release target.

Background Designer can use Randomize Preview to audition temporary background combinations without changing the project until you apply a choice.

Fit to Workspace, Zoom In/Out, manual zoom, pan, pinch zoom, rotation, view history, transition canvases, and project-menubar height handling share the retained viewport architecture. Custom sizes use the inline Width × Height panel rather than blocking browser prompts.

Changing the project canvas

File → Project Properties… → Card Canvas changes the stored card width and height. Fixed, Scale and Responsive layout choices affect presentation; resizing does not rewrite authored object positions to squeeze them into a smaller canvas. Objects outside a smaller canvas may be clipped and reappear when its original size is restored. Responsive constraints can change displayed placement without changing base coordinates.

In Browse mode, a dimension change applied through Project Properties sends resizeCard to the current card with width, height and the active preview breakpoint. No separate button is needed. An unchanged size does not generate this event. Author-mode changes do not run the Browse handler. Browser-window resizing and zoom are not equivalent to changing stored card dimensions.

Controls & Events

Use Browse mode to operate controls. Specific native change messages run before controlChanged. Checkbox and radio controls send controlChanged; fields send textChanged when committing text; popup, list, tabs and accordion send selectionChanged with a one-based index and selected value/title.

Numeric, date/time and visual-toggle controls send valueChanged. Slider and scrollbar changes provide frame-coalesced live values and a final committed value. Intermediate pointer samples can be coalesced; the final value is authoritative. For multi-select lists, controlChanged carries the selected-value array, while the specific selection event describes the active item. Extension controls retain their own change-event record.

on valueChanged pValue
  put pValue into field "Range Result"
end valueChanged

The example needs a field named Range Result on the card. See Dictionary entries for the individual messages.

HTML Object Import

Stackadia 1.4.4 introduces the ability to import HTML objects into xStacks. This lets you place a self-contained HTML/CSS/JavaScript application directly inside a Stackadia project rather than recreating every behavior with native objects.

What it is for

• Embedding standalone browser games or interactive demos
• Including custom controls or visualizers built in HTML/Canvas/WebGL
• Reusing existing web-based learning tools, simulations, or media widgets
• Pairing Stackadia navigation and presentation structure with a specialized embedded HTML experience

General workflow

1. Prepare the HTML app and confirm it runs correctly on its own.
2. Import the app as an HTML object inside the target xStack.
3. Size and position the object within the card or layout.
4. Test startup, focus, interaction, and shutdown behavior.
5. Retest after saving and reopening the project, then verify playback in the Lightweight Player.

Design guidance

Use Stackadia for surrounding structure: card flow, labels, buttons, instructions, media, and launch/return behavior. Use the HTML object for the specialized embedded experience. This keeps projects understandable and easier to maintain.

Vector Graphics

Open the Vector Graphics group in the Tools palette to create scalable rounded rectangles, lines, arrows, polylines, polygons, regular polygons, editable cubic Bézier lines, and arcs. Vector objects remain ordinary Stackadia content and can be selected, grouped, scripted, animated, localized, and saved in XStacks. A visible vector can be used directly as an interactive control; its Browse hit region follows the vector geometry automatically. Use a linked transparent Button only when Button-specific states/content or a separate overlay are needed.

Edit points directly

1. Select a graphic in Author mode. Linked transparent hotspots are click-through here; Command-click cycles overlapping objects.
2. Double-click the vector, right-click and choose Edit Vector Points, or use the Inspector Shape family.
3. Drag vertex, Bézier-control, or arc handles directly on the card.
4. For polylines and polygons, select a point and use Add Point or Delete Point.

Advanced appearance

Use linear or radial fill gradients, linear stroke gradients, dash patterns, line caps and joins, and configurable triangle, open, diamond, or circle arrowheads. Copy and paste vector appearance between graphics.

Groups and Nested Groups

Groups use local child coordinates and can be nested. Parent movement, visibility, opacity, and rotation affect descendants while nested groups retain their own local transform. Clipping can restrict child rendering to group bounds.

Messages route Object → nested Group(s) → Card → Background → Project. Use the Project Browser’s Current Card Objects section, Inspector, group-focus controls, and contextual Properties to understand ownership before editing deeply nested structures.

Surface Fills, Styles & Readability

Authoring interface appearance

Stackadia 1.4.4 Final includes Light, Dark and High Contrast application appearance modes. These modes affect the authoring interface, not the authored project’s own theme. The User Guide provides matching reader modes separately; the guide’s color tokens are intentionally higher-contrast than the earlier Alpha so body text, muted text, links, code, callouts, navigation, and controls remain legible in all three reader modes.

Select a supported Button, Field or closed shape. In Inspector → Fill & Border → Surface fill · gradients, choose the fill and edit its stops. Each stop has a color, position and opacity. Linear fills have an angle; radial fills have center and radius controls. The checkerboard preview reveals transparency. Background Designer offers a matching shared-fill mode.

Reuse

Use a project surface style when several objects should share edits. Object overrides remain local. Button state fills can change the appearance for interaction states. Theme-linked colors follow the project theme. Templates captured from objects contain independent appearance copies; they do not keep a live link to the original project style. Cross-project paste carries appearance dependencies.

Translucent surfaces

Pearl, Blue and Smoke each offer translucent and opaque presets. These are editable gradients, not backdrop blur or native Apple glass. Text and background contrast still need visual checking, especially over moving content.

Opaque surface fills is a browser-local display preference: it changes shared-fill rendering without rewriting saved stop opacity. Follow system restores authored transparency unless system or project contrast settings request opacity. No fill stays unfilled. Whole-object opacity, image transparency and Effects are separate; this option does not remove every kind of transparency. The contrast advisory is a sample, not an accessibility certification.

Undo/Redo applies to committed appearance edits. Save, reopen and test in both Author and Browse before sharing a project. Paint pixels and unsupported surfaces are not automatically recolored by this system.

Media and Animation

Assets may contain images, paint layers, audio, and video. Objects can use timelines, keyframes, and regular sprite sheets. For high-density realtime 2D motion, use an Animation Stage; see the dedicated Animation Stages Help topic for Actors, local image assets, Canvas/rAF presentation, Script control, and native fixed-step simulation. Paint Studio provides brush, erase, fill, shape, text, selection, undo, flip, and rotation tools. The Media Production workspace groups the higher-level media authoring surfaces without creating a separate runtime.

Fast desktop placement

In Author mode, drag supported image files or plain-text content from the desktop, Finder, or another application directly onto the card. Images become project assets and proportionally scaled Image objects. Plain-text files and dragged text become populated multiline Fields at the drop point, using the active Field template and normal scrolling when the text exceeds the visible field. Text up to 256 KiB imports immediately; larger text through 1 MiB requires confirmation, and text over 1 MiB is refused to protect XStack and recovery size. Rich-text formatting is not interpreted. Browse mode does not accept project-mutating external drops.

Sound and music

Audio objects provide visible media controls. Stackadia Script 1.2 also supports named project or built-in sounds, synthesized note phrases, channels, looping, overlap, transport, and master volume.

Transitions and Navigation

Open Studio → Transition Editor… or Go → Edit Card Transition…. Preview showcase artwork or current project cards, then save an outgoing profile to one card or apply it to all cards.

Declarative navigation and authored project-menu actions can inherit the card transition, use no transition, or use a custom effect, duration, and easing. Show / Hide Actions can use the same effect catalog on the target object’s rendered region. Stackadia Script 1.2 can also use show / hide ... with transition ... and may supply within region x, y, width, height for an explicit card-space clip. Directional effects reverse automatically for backward navigation; reduced-motion preferences substitute a brief crossfade or cut.

Testing the playback pair

Declarative and Script navigation use the card lifecycle in both applications. Test transitions with actual project assets and test the final card reached, not just the effect. Reduced Motion and browser rendering can affect the presentation.

Interaction and Simulation

Use Studio → Interaction & Simulation… to configure drag constraints, drop and snap zones, collisions, proximity, boundaries, motion, follow behavior, keyboard movement, touch gestures, multi-controller gamepad movement, named Standard Mapping controls, analog values, state, score, progress, and countdown actions on ordinary editable objects.

Controller Studio maps keyboard and controller input onto named Game Actions such as Move Left, Jump, Fire and Pause, supports reusable profiles and live remapping, and can test haptics when a controller/browser exposes them.

These features use project interaction metadata. Their events remain available to Advanced Actions and Stackadia Script.

Physics 1.0

Open Studio → Physics Studio… to author the physics world, bodies, materials, impulses, joints, snapshots, and diagnostics. Physics supports dynamic, static, and kinematic bodies; gravity; restitution; friction; sensors; collision layers/masks; sleeping; fixed-step control; pin, distance, breakable distance, and spring constraints.

Scripted impulses publish live velocity before render synchronization, and contact restitution uses the higher participating restitution. These behaviors are protected by the current Standalone regression suite.

Physics 1.0 is translational: it does not yet provide angular rigid-body rotation, torque, revolute limits, or a dedicated rotational motor.

3D Scene Editor

Open Studio → 3D Scene Editor… for Scene3D authoring. Stackadia retains pinned Three.js r185 locally, so the qualified Scene3D path works without Internet access. Packaged GLB or embedded-resource glTF models can provide named nodes, PBR materials, model transforms, picking, selection bounds, camera framing, and animation clips. For the most portable offline projects, prefer GLB or glTF with embedded buffers/images.

Author transforms

In Author mode, use Move, Rotate, and Scale directly on the selected model. Axis constraints, snapping, Undo, and Local/World transform space are available. Dragging the Scene3D object itself continues to use normal Stackadia object selection/movement semantics.

Browse camera

In Browse mode, authored permissions can allow Orbit, Zoom, and Pan. Lock User View disables manual camera movement. Auto Rotate is an authored camera behavior with configurable speed.

Performance guardrails

The editor reports advisory model/scene complexity guidance and live Three.js draw-call, triangle, and FPS metrics when available. Guardrails never block Apply, save, or playback; they identify potentially expensive choices so authors can decide.

Script 3D controls

Stackadia Script 1.2 exposes additive Scene3D host functions without changing the language grammar. Use scene3DModelNames() and scene3DModelInfo() to inspect model instances; set position, rotation, scale, and visibility with the corresponding scene3DSetModel… functions; and use scene3DCameraInfo(), scene3DSetCamera(), scene3DSetAutoRotate(), and scene3DSetBrowseControls() for authored camera behavior. Model rotation and camera yaw/pitch values are expressed in degrees at the Script boundary.

Animation Stages

An Animation Stage is Stackadia's high-performance Canvas 2D object for games, simulations, particles, sprite scenes, and other workloads with many rapidly changing entities. It complements ordinary Stackadia SVG controls rather than replacing them.

Why use an Animation Stage?

Ordinary buttons, fields, graphics, Timeline, Motion Path, and moderate Script animation remain appropriate for normal stack interfaces. Animation Stages are intended for high-density realtime motion where dozens or hundreds of entities need to update every display frame.

Canvas and rAF

The stage owns one persistent HTML Canvas. Its runtime uses requestAnimationFrame (rAF), the browser callback scheduled immediately before a display repaint, so presentation follows the browser's native visual cadence rather than a guessed millisecond timer. HiDPI backing-store sizing follows the displayed stage while authored Stackadia geometry remains in card coordinates.

Actors

Actors are lightweight records owned by the stage, not separate SVG/DOM card objects. Actor kinds are circle, rectangle, and image. Core actor properties include name/id, x/y, width/height, velocityX/velocityY, rotation/angularVelocity, opacity, zIndex, visible, active, metallic, fill/stroke/strokeWidth, image assetId/fit, and boundary behavior (bounce, wrap, drain, or none). Image actors bind to image/paint assets packaged with the XStack.

Authored state versus runtime state

Author mode edits the starting actor records stored in the project. Browse mode creates lightweight runtime copies. Continuous actor motion, collision resolution, pooling, and deactivation modify the runtime copies without generating ordinary project Undo transactions or rewriting authored starting coordinates. Returning to Author and re-entering Browse starts from the authored state unless Script or authoring explicitly changes it.

Native simulation

Enable native simulation in the Animation Stage Inspector to choose a fixed simulation frequency of 60, 120, or 240 Hz. The fixed step is independent of rAF/display refresh. Dynamic bodies respond to gravity and drag; static bodies participate in collision without moving; kinematic bodies move from authored/runtime velocity without gravity. Actor simulation properties include bodyType, gravityScale, restitution, boundaryRestitution, drag, mass, collisionEnabled, collisionLayer, and collisionMask. Circle and axis-aligned box collision shapes use a spatial-cell broad phase. Stage-level settings include gravity, maximum substeps, optional simulation bounds, collision cell size, restitution jitter, and tangential jitter.

Script control

Compatibility: Animation Stage is the user-facing object name. The persisted object type remains animationSurface, and existing Script 1.2 function/event names containing surface remain valid. New command examples prefer animation stage; the legacy phrase animation surface remains accepted.

Do not drive dense animation by sending one interpreted Script message per frame. Let Canvas/rAF and native simulation own realtime updates, and use Stackadia Script for commands, queries, state changes, controls, and discrete events. Query with actorNames(surface), actorExists(actor, surface), actorProperty(actor, property, surface), actorState(actor, surface), animationSurfaceState(surface), and animationSurfaceProperty(property, surface). Change runtime actor state with set actor "Name" property "velocityX" to 120 in animation stage "Stage", setActorProperty(), setActorState(), activateActorFromPool(), and deactivateActors(). setAnimationSurfaceProperty() currently changes the live boolean properties showStats, showGrid, simulationEnabled, and collisionEnabled.

Input events

Animation Stage object scripts may handle actorMouseDown, actorMouseUp, and actorClick for actor hits, plus surfaceMouseDown, surfaceMouseUp, and surfaceClick for the surface itself. Event arguments include actor name/id when applicable, local stage x/y coordinates, mouse button, and pointer type.

Project schema

Animation Stage was introduced in schema 44 and remains supported in the current schema 47. A runtime must support the file’s schema; future schemas are rejected instead of silently reinterpreted.

Playback

The renewed Lightweight Player includes Animation Stage and Actor playback, including native simulation. Export your project as an XStack and open it in the Player. The frozen Web App builder is outside this qualification and still blocks projects containing Animation Stages.

Reduce Motion

Reduce Motion may suppress decorative empty-stage preview motion, but it does not freeze essential authored actors, games, or simulations. Authors should still provide clear controls, accessible naming, and alternate explanatory content where an animated state carries important meaning.

Project Data Sources

The current project schema (47) stores project data in one canonical dataSources[] model. Each source owns tables; every table uses the same field, record, validation, relationship, key/index, computed-field, cursor/page, and audit capabilities.

Object bindings use one dataBinding object with sourceId, tableId, and optional field. The earlier collection/database split and mirrored legacy properties are not part of the current runtime.

Data Studio is the single local-data authoring surface. Use the Inspector’s Data page to bind selected objects to project data. Query composition, indexing, cursors, reactive binding, and master/detail binding all use the canonical schema.

External Data

Data Studio / External Data Connectors can read REST/JSON and published CSV/Google Sheets-style sources into the canonical project data model. Published-sheet access is read-only.

Refresh and resilience

Connectors can refresh manually, on project open, or on an interval from 1–1440 minutes. Stale thresholds also use 1–1440 minutes. Successful responses can be cached so a project can continue showing the last known data when a later refresh is offline or fails.

Network access is permission-gated and begins conservatively. A failed refresh should report an error without damaging the previously cached project data.

Stackadia Script IDE

Scripts belong to objects, groups, cards, backgrounds, or the project. Messages travel Object → Group → Card → Background → Project; use pass to continue along that path.

Use Script → Script Dictionary… for human-facing syntax and behavior summaries, Script Examples… for runnable examples, and Host Functions Guide… for browser, media, storage, permission, and secure-library functions. The Script IDE provides editing, validation, project search, definitions/references, rename refactoring, parameter hints, diagnostics, watches, call stack, variables, console, formatting, and folding. Its Float / Dock control moves the same live editor session between the bottom dock and a resizable modeless window without recreating the editor.

Animation Stage actor scripting

Browse-mode Canvas actors can be queried with actorNames(surface), actorExists(actor, surface), actorProperty(actor, property, surface), and actorState(actor, surface). Change live actor state with set actor "Name" property "velocityX" to 120 in animation stage "Stage" or setActorProperty(actor, property, value, surface). Animation Stage scripts may handle actorMouseDown, actorMouseUp, and actorClick; each receives actor name, actor id, local x/y, button, and pointer type. Animation Stage scripts also support surfaceMouseDown, surfaceMouseUp, and surfaceClick plus pooled-actor helpers setActorState(), activateActorFromPool(), deactivateActors(), animationSurfaceState(), and runtime surface-property accessors.

Animation Stage native simulation

Animation Stages can run fixed-step native 2D simulation independently from browser display frames. Actors may use dynamic, static, or kinematic bodies with gravity scale, restitution, drag, mass, collision layer/mask, and Canvas-boundary behavior. Circle and axis-aligned box collision shapes use a spatial-cell broad phase; rAF presents the latest simulation state without running Stackadia Script on every physics step.

Editor keys

Ctrl/Command+Space  Completion
Ctrl/Command+F      Find
F1                  Quick dictionary help
F2                  Rename symbol
F12                 Jump to definition
Shift+F12           Find references
Tab                 Two-space indentation
Command/Ctrl+S      Save script

Timers and asynchronous operations

A named repeating send keeps one pending occurrence while the runtime is busy; it waits its interval after the handler finishes instead of accumulating missed ticks. Delayed sends return an ID through the result. Use Script for discrete animation commands, not one interpreted message per actor per display frame.

Library calls can return structured values. Use tValue["status"] to read a returned record key and list(1, 2, 3) to create a numeric list. JavaScript object-property or array-literal syntax is not the Stackadia Script syntax.

Script Editing & Strict Compilation

Open the Script IDE for the selected object, card, background or project. Start with Check and the Problems list when a script does not compile. Click a problem or its gutter marker to select the source; navigation can reveal a folded handler. F8 moves to the next current problem; Shift+F8 moves backward. Some Mac keyboards require Fn with function keys.

Syntax coloring is case-insensitive. When suggestions appear, use Up/Down to choose, Tab to insert, and Escape to dismiss. Suggestions can use declarations from an unfinished script; they do not guarantee compilation.

Optional strict declarations

In Script IDE → Tools, enable Strict compilation to require variable declarations for this project. It defaults to off, is saved with the XStack, and applies to checking and execution, including enabled modules and the Message Box. Stop a running script before changing the policy.

on mouseUp
  local tValue
  put 1 into tValue
end mouseUp

Parameters, loop counters, catch bindings and supported implicit variables have defined bindings. Prefixes such as t and g are naming conventions, not declarations. Changing tValue to tVaule in the assignment above produces an undeclared-variable diagnostic in strict mode. Correct the source; completion does not silently declare variables. Turning strict mode off restores permissive compilation.

Debugging

Click a gutter line to add a breakpoint. Debug execution can continue, step into, step over, step out, or abort. The IDE shows the call stack, variables, watches, current statement, diagnostics, and message trace.

Editable local, global, and script-local values are applied when execution resumes. Constants remain read-only.

Signed Extensions: SDK 2 & 3

SDK2 adds contributed commands and assets, dependencies, package self-tests and package-management metadata. SDK3 adds typed library operation metadata. The bundled Safe Utility Sample and Typed Text & Numbers Sample are genuine signed, capability-free examples.

Install a bundled sample

1. Open Example Exchange and use Verified Isolated Extension Sample (SDK2 version 1.0.1), or Signed SDK 3 Typed Library Sample.
2. In Extensions, verify the installed package is disabled and awaiting approval.
3. Choose Test. A successful test verifies the signature and executes the declared package self-test.
4. Choose Approve Selected, then Enable. Approval and enabling remain separate from verification.

SDK2 exposes Sample Status and a Ready Icon asset. SDK3 exposes uppercase (string to string) and sum (numeric list to number). External .bcext packages use the same verification boundary; an arbitrary publisher key is not automatically trusted.

Save and reopen

Standalone clears imported extension trust. Test each imported package again, then Approve Selected and Enable. Player verifies required packages on open and prompts for approval. Test may run a package self-test while disabled; it does not authorize ordinary project calls.

Failure and cleanup

Modified workers and invalid signatures fail verification. Standalone can open a project for inspection with unverified extensions disabled; Player refuses playback when a required provider fails. An older saved SDK2 placeholder cannot become trusted by retaining a verified flag. Use the current bundled sample instead; user copies are not silently rewritten. Closing or replacing the project releases extension workers.

Publisher scope

The sample publisher is approved only for the two bundled sample extension IDs. This is not a general signing or publisher-enrollment service. Keep the published signed sample packages intact.

Signed Library Examples

Install, test, approve and enable the samples described in Signed Extensions first. Allow any library permission request. These snippets are handler examples and need the named output fields on the current card. Locals are declared so the examples can also be checked with strict declarations.

SDK2 status

on mouseUp
  local tValue
  put libraryCall("org.stackadia.samples.safe-utility", "sampleStatus", "") into tValue
  put tValue["status"] into field "SDK2 Result"
end mouseUp

Expected: ready.

SDK3 text

on mouseUp
  local tValue
  put libraryCall("org.stackadia.samples.typed-text", "uppercase", "  hello   stackadia  ") into tValue
  put tValue into field "SDK3 Text Result"
end mouseUp

Expected: HELLO STACKADIA.

SDK3 numeric list

on mouseUp
  local tValue
  put libraryCall("org.stackadia.samples.typed-text", "sum", list(1, 2, 3)) into tValue
  put tValue into field "SDK3 Sum Result"
end mouseUp

Expected: 6. Passing a number to uppercase is invalid; catch the error with try/catch. Package 03 includes the accepted ordinary XStack demonstrating these calls and expected rejection.

Project Check

Use Window → Project Check… before distributing or archiving a project. Project Check reviews duplicate IDs, references, scripts, assets, navigation/action targets, group integrity, dependencies, Physics references, Scene3D assets, XStack package/compression expectations, objects outside Base Design bounds, likely field clipping, and cramped button labels.

Project Check reports findings and recommendations; it does not silently rewrite the project.

Permissions

Projects ask before using online services, files, the clipboard, location, camera, microphone, or saved browser data. Review permissions before relying on browser/device capabilities.

Network access is conservative by default. External Data connectors require the project’s network-access capability to be allowed before they can refresh remote data. Keep permission needs visible in Project Check and release documentation.

Extension trust is separate

A valid signature identifies an approved publisher and unchanged package; it does not grant project or device permission. Installed extensions must be verified, approved and enabled before ordinary calls run. Browser permission can also be required for a device operation. Denial should be handled by the project rather than treated as a successful result.

Player permissions belong to its current session. Reset Permissions revokes approval and stops extension execution; reopen the XStack to approve again. Standalone clears imported extension trust so reopening an XStack requires Test, Approve Selected and Enable for its extensions.

Saving & XStack Packaging

XStack format 3 is a ZIP package containing project data, scripts and assets. The current project schema is 47 and the language is Stackadia Script 1.2. An XStack does not contain the Stackadia application just because it is an XStack.

Save your work

Use Save or Save As to write an external XStack. Browser recovery and registered-stack copies are useful local state but do not replace an external backup. Reopen the saved file to verify that assets, scripts and behavior are present.

Share with Player

1. Save or export the project as an XStack.
2. Use Export Player to obtain the universal Lightweight Player HTML. It is identical to the separately supplied Player for this build.
3. Supply the Player and XStack as separate files. Opening the Player does not automatically open or embed your current project.
4. Open the XStack in Player, review permissions and test it.

The full Standalone is the authoring application and the source of the playback core. The renewed Player supports playback, including Animation Stage, media, Scene3D and approved signed extensions within their documented boundaries. Web App and PWA export remain frozen development references, outside this release qualification.

Distribution notices

Stackadia is distributed under GPL-3.0-or-later. Keep the supplied license, corresponding-source materials and third-party notices with the application distribution. Project content licensing is separate from the application license. Consult the supplied license text for its terms; the public-testing package will include the corresponding source and notices.

Regression Suite

The canonical Standalone regression series and focused phase qualification packs are the release foundation for Stackadia. Before promotion, run the current consolidated automated pack and the release hands-on checklist against the accepted Standalone baseline.

Automated checks cover package format, schema, Script version, integrity, IDs, references, dependencies, groups, targeted runtime structures, and phase-specific preservation gates. Hands-on visual and pointer qualification remains required when runtime or presentation behavior changes.

Built-in Demo Stack

Choose Help → Open Built-in Demo… to open Stackadia's built-in demonstration stack. In the current final application this command appears in the Help menu under Start Here; it is not a File-menu command.

Switch between Browse and Author modes to operate controls, inspect scripts, and study ordinary editable objects. The Demo is protected core example content and may also appear among Stackadia's registered core stacks; it is not a hidden runtime.

Lightweight Player

Open the downloaded Player HTML in your desktop browser and select an XStack. The Player runs the project in Browse mode; use Standalone for authoring and Inspector editing. Navigation, project scripts, media, Scene3D, Animation Stage, and supported imported HTML objects participate in the retained playback core for the 1.4.4 line.

Opening and permissions

Review prompts for required signed extensions and host capabilities. Required providers must verify and be approved before the stack can play. A corrupt package, unsupported future schema, or rejected required extension produces an error; an already open valid stack should remain usable.

Save Copy and Home

Save Copy downloads an XStack with the current persisted project state. It does not capture every transient animation or device state. Reopen the copy to verify it. Home closes the playback session and returns to the launcher, stopping its timers and workers.

Offline use

Local assets and bundled playback libraries can run offline. Remote connectors, external media and network services still need their resources and permission; an offline Player does not make a remote service local. Browser device availability and permissions vary by environment.

Limits

Compatibility covers documented playback behavior in qualified stacks. It does not promise every third-party extension, every service or every browser/device combination. Desktop and tablet results are recorded separately; phones are excluded. The frozen Web builder is not the renewed Player.

Dictionary & Release Scope

The Script Dictionary contains 505 reference entries with syntax, behavior summaries and search. Open it from Script → Script Dictionary…; F1 gives word help from the editor. Examples that refer to named objects require those objects in your project. Placeholder identifiers and values must be supplied by the author.

Script version badges indicate language history, not application release status. Legacy availability metadata in the source catalog is not a certification of the frozen Web runtime. The current playback qualification covers the Standalone and Lightweight Player within the release record’s limits.

This standalone edition incorporates the 1.4.4 Final reference material and updated release terminology, including the merged-branch HTML object feature. When reporting a problem, use documentation that matches the application build and include the application filename, browser/OS, XStack, steps, expected result, and observed result. Do not include private credentials or confidential project content in a public feedback package.