Lona/Lona

This release marks a significant architectural shift, removing the legacy ComponentStudio application and its associated Xcode project and CocoaPods dependencies. The core compiler has been substantially expanded with new features including a Logic language compiler pipeline, TypeScript type definitions, and improved support for Swift, React, and XML generation. The Lona Studio application has been completely restructured, introducing a modernized UI, Logic language editing capabilities, and deep integration with GitHub and Sketch. Additionally, the release introduces comprehensive test coverage across all generated platforms and adds new examples for Material Design and web-based viewers.

The Logic language now supports defining UI elements such as views, text, and stacks with parameters like padding, dimensions, and colors. This enables users to write logic that constructs UI components, which are then rendered in the editor with visual decorations (e.g., color swatches) and documentation popovers. The change introduces new files for element definitions, builder extensions, decoration rendering, documentation views, suggestion providers, and thumbnail generation, along with a library of pre-defined device configurations for previewing components on different screen sizes.

studio/LonaStudio/Logic · medium confidence

The Logic/Views directory now includes new Swift source files: LogicCompilerConfigurationInput.swift, LogicInput.swift, and LogicNumberInput.swift. These introduce UI components that allow users to edit compiler configuration (target and framework), numeric values, and general logic expressions using the Logic language. The compiler configuration input specifically supports setting the compilation target and framework, while the number input handles numeric value editing with suggestions and validation.

studio/LonaStudio/Logic/Views · medium confidence

Introduces a new Webpack loader that compiles .component files and specific JSON files (colors, textStyles, shadows, types) using the Lona compiler. The loader parses imports, resolves relative paths, and handles utils and JSON files directly. It also supports a custom compiler path and framework options.

compiler/webpack-loader · high confidence

The compiler now includes a new React component analyzer that parses React Native component files and converts them into Lona component files. This tool extracts component properties, styles, and element structure, outputting a structured JSON representation that can be used by the Lona framework. An example conversion of a React Native View component is included to demonstrate the transformation.

compiler/react-component-analyzer · high confidence

The Lona Studio models now include support for accessibility properties. A new Accessibility.swift file introduces types for accessibility roles (such as button, link, checkbox), states (disabled, selected), and elements containing label, hint, and value. The AccessibilityType enum and related structs allow defining whether an element is auto, none, an element, or a container of elements. This enables users to configure accessibility attributes for components in the studio.

studio/LonaStudio/Models · high confidence

The Lona Studio generated code now includes new components to support image resizing modes (scale-to-fill, aspect-fill, aspect-fit) and a TextStyle class that manages font attributes, paragraph styles, and baseline offsets for text rendering. Additionally, pre-defined text styles (titles, subtitles, body text) and color constants are generated to standardize the UI's appearance.

studio/LonaStudio/Generated · high confidence

The Lona Studio generated components now include three new UI elements: ControlledDropdown, MultipleSelectionButton, and NumberInput. These generated Swift files provide the underlying view implementations and data models, enabling the studio to render and interact with these specific control types in the canvas and inspector.

studio/LonaStudio/Generated/ghosts · high confidence

Added generated token examples for React (ESM and legacy JS), Swift (UIKit models and extensions), and MDX-based documentation pages. This includes color, shadow, and text style tokens across these platforms, enabling developers to see how tokens are applied in each environment.

examples/generated/tokens · high confidence

The Sketch plugin now prompts the user to configure the output file path and apply component filters (include or exclude by regex) before generation. This introduces a new \requestUserParameters\ module that collects these settings via a dialog, allowing users to specify where to save the generated Sketch file and which components to include or exclude from the output.

studio/plugins/sketch/lib · high confidence

The studio now includes a new markdown editor component located at studio/embedded-sites/markdown-editor. This component provides a split-pane interface that allows users to edit markdown source code and see a live preview simultaneously. It integrates a CodeMirror-based editor with syntax highlighting, auto-closing brackets, and inline error highlighting, while rendering the markdown into HTML for the preview pane. The editor supports configurable modes for editing, previewing, and fullscreen display via query parameters.

studio/embedded-sites/markdown-editor · high confidence

The compiler now supports shadow and text style token types, expanding the range of design tokens that can be processed. Shadow tokens include x, y, blur, radius, and color properties, while text style tokens include font name, font family, font weight, font size, line height, letter spacing, and color. These new token types are handled in the conversion pipeline, allowing users to define and export these more complex token values.

compiler/core/src/tokens · high confidence

A new React application has been added to the Lona web viewer example, providing a browser-based interface for viewing generated components. The app includes accessibility-focused navigation between nested components, with focus management and a visible focus ring. Additionally, the example now integrates Cypress and Applitools for visual regression testing, allowing users to verify the visual appearance of the viewer across different states.

examples/LonaViewer/web · high confidence

Users can now connect their projects to GitHub repositories directly within Lona Studio. This includes automatic SSH key generation and configuration, allowing the IDE to push code to remote repositories and clone existing projects. The new Git client handles repository initialization, commit tracking, and remote URL validation, while the SSH module manages host key verification and local key management to facilitate secure connections to GitHub.

studio/LonaStudio/VersionControl · high confidence

The Studio app now includes the full GraphQL schema definitions and auto-generated Swift API clients for both the internal Lona API and the external GitHub API. This enables the application to interact with GitHub repositories, including creating private repositories, fetching organization details, and monitoring deployment statuses via GitHub Actions check suites. Additionally, the Lona API integration allows users to add repositories, create organizations, and manage repository settings such as documentation visibility.

studio/LonaStudio/GraphQL · high confidence

Added new UI components for the Material Design example, including Card, ListItem, and a Team screen. These components utilize the newly added foundation styles for colors, shadows, and typography, and are configured with specific device dimensions for previewing the layout.

examples/material-design · high confidence

The compiler now includes new ReasonML modules for handling XML structures. The \xmlAst.re\ file defines the abstract syntax tree for XML documents, including prolog, elements, and content types. The \xmlRender.re\ module provides logic to serialize the AST into formatted XML strings, handling elements, attributes, and comments. Additionally, \xmlColor.re\ generates XML output for color resources. These changes introduce the core infrastructure for XML processing within the compiler.

compiler/core/src/xml · high confidence

New JavaScript utilities have been added to improve accessibility: \createActivatableComponent\ enables keyboard activation of components via Enter or Space keys; \createFocusWrapper\ manages focus traversal between nested components; and \focusUtils\ provides helper functions to programmatically focus first, last, next, or previous elements in a list. These changes enhance keyboard navigation and activation for users relying on assistive technologies.

compiler/core/src/static/javaScript · high confidence

Users can now pick colors and shadows via new ColorSuggestionEditor and ShadowSuggestionEditor components in the suggestions area, enabling direct editing of these visual properties within the studio interface.

studio/LonaStudio/Generated/suggestions · high confidence

The studio now includes a new embedded Markdown editor, allowing users to edit Markdown files directly within the studio environment. This change moves the markdown-editor into the studio/embedded-sites directory, providing a dedicated interface for creating and modifying Markdown content.

studio/embedded-sites · high confidence

Introduced new Swift files (LogicEditor+Suggestions.swift, LogicSuggestions.swift) that provide auto-completion suggestions for primitive and token types, as well as boolean, integer, float, and string literals within the Logic editor. This adds structured suggestion items for type annotations and expression literals, enhancing the code completion experience for these specific data types.

studio/LonaStudio/Logic/Suggestions · high confidence

A new \appkitPressable.re\ file was added to the compiler core, introducing support for pressable UI elements. This change implements mouse tracking via \NSTrackingArea\ to detect when the cursor enters or exits a layer's bounds, and manages press states (e.g., \pressed\, \clicked\) to enable interactive feedback for user actions.

compiler/core/src/swift/appkit · medium confidence

The compiler now includes Swift source files for iOS and macOS that implement core UI components and utilities. This adds support for image resizing modes (scale, aspect fill, aspect fit) via new \CGSize\ extensions and \NSImage\ helpers. It introduces a \TextStyle\ class for managing font attributes like family, weight, size, and line height, and provides \LNAImageView\ and \LNATextField\ implementations that support corner radius, baseline offset, and intrinsic content size. Additionally, it adds \LonaControlView\ for handling highlight states and accessibility activation, and a \LonaViewModel\ protocol with an \id\ property.

compiler/core/src/static/swift · high confidence

The logic for generating a Sketch library from a Lona workspace has been moved into a new, separate \compiler/sketch-library\ package. This new package, written in TypeScript, provides a \generateSketchLibrary\ function that compiles workspace components and assets into a \.sketch\ file. It includes dedicated modules for handling device presets, measuring component dimensions, rendering document layers, and modifying the final Sketch template.

compiler/sketch-library · medium confidence

The Lona Studio generated components now include new UI elements for color management and canvas headers. This includes \ColorPicker\, \ColorWellPicker\, \CoreColorPicker\, and \CoreColorWellPicker\ for color selection and display, as well as \CanvasTableHeaderExtra\ and \CanvasTableHeaderItem\ for the canvas table header. Additionally, preview components like \ComponentPreview\, \ComponentPreviewCard\, and \ComponentPreviewCollection\ have been added to support component browsing and selection.

studio/LonaStudio/Generated/components · high confidence

The Sketch plugin has been added to the studio/plugins/sketch directory, introducing a new capability to generate Sketch libraries from workspace data. The plugin entry point (index.js) orchestrates the generation process by requesting user parameters and utilizing the @lona/workspace-to-sketch-library module. Configuration is defined in lonaplugin.json, and the directory includes a .gitignore file to exclude build artifacts and dependencies.

studio/plugins/sketch · high confidence

Added a new compiler module for the 'Logic' language, including an AST definition, a type unification system, an evaluation engine, and code generators for JavaScript and Swift. This enables the compiler to parse, type-check, and emit native code for Logic files, supporting features like variable declarations, function calls, and namespace scoping.

compiler/core/src/logic · high confidence

Added LogicListView, a new UI component that provides a list editor for managing LogicNode items. It supports adding, removing, and duplicating nodes, and automatically updates function arguments and types when values change.

studio/LonaStudio/LogicList · high confidence

The studio now includes a new LogicModule that handles the compilation and evaluation of logic files within a workspace. This module manages the loading, caching, and compilation of logic programs, including error detection for undefined identifiers, unification, and cycle detection. It also provides static methods to update and invalidate caches for logic files, ensuring that the workspace's logic state is kept up-to-date.

studio/LonaStudio/Module · high confidence

The compiler/core directory now contains the core implementation of the Lona Compiler, a CLI tool for generating cross-platform UI code from JSON definitions. The project is written in ReasonML and compiled to JavaScript via BuckleScript (bsconfig.json), with a webpack configuration (webpack.config.js) that bundles the compiler for npm distribution as 'lonac'. This includes build artifacts (.bs.js files), a .nvmrc file specifying Node.js version 12, and a .gitignore to exclude build outputs and dependencies. The README provides usage instructions for generating Swift, JS (React Native, React DOM, React SketchApp), and XML code, as well as contributing guidelines for building from source.

compiler/core · high confidence

Plugins can now communicate with the host application via an RPC service, enabling features such as displaying alerts and requesting custom parameters from the user. The new PluginAPI handles requests for workspace and compiler paths, device presets, and custom parameters, with the ability to persist user-provided values in workspace or global storage. This replaces previous synchronous or ad-hoc communication methods with a structured JSON-RPC interface.

studio/LonaStudio/Plugins · high confidence

Added three new files in the compiler's Reason backend: \reasonAst.re\ defines the internal abstract syntax tree for Reason code, \reasonRender.re\ handles the pretty-printing of that AST into source code, and \reasonTypeSystem.re\ manages the mapping between the compiler's internal type system and Reason's type system, including JSON encoding/decoding logic. This change adds the foundational infrastructure for generating Reason code, though the specific record type generation logic was subsequently fixed in a follow-up commit.

compiler/core/src/reason · high confidence

The compiler now generates Swift code for iOS (UIKit) and macOS (AppKit) applications. This includes the core AST definitions, component rendering, constraint handling, and helper classes. The generated Swift code supports both iOS and macOS targets, with specific implementations for views, layouts, and interactions.

compiler/core/src/swift · high confidence

The Canvas area now uses a view-based rendering system (CSView, CSRendering) that supports opacity, shadows, and border styles, replacing the previous layer-based approach. An AccessibilityOverlay view has been added to visually indicate the bounding boxes of accessible elements on the canvas. Additionally, the CanvasAreaView now supports panning and zooming, and the canvas table allows dragging to reorder headers and delete canvases with the delete key.

studio/LonaStudio/Canvas · high confidence

The Lona Studio controls directory now includes a suite of new UI components, including an Alert dialog helper, a CodeEditor for displaying generated code and compiler commands, a ControlledDropdown for managing selection states, and specialized pickers for colors and component editing. These additions provide the underlying interactive elements for the studio's inspector and output panes.

studio/LonaStudio/Controls · high confidence

Users can now undo changes made to logic files, with the new UndoManager providing the underlying mechanism to track and revert these edits.

studio/LonaStudio/Workspace · high confidence

The Xcode project file (project.pbxproj) for Lona Studio has been added to the repository, establishing the build configuration and file references for the macOS application. This change includes the initial set of source files, resources, and framework dependencies required to build the Lona Studio application.

studio/LonaStudio.xcodeproj · high confidence

The macOS LonaViewer application is now fully scaffolded with a new project structure, including an AppDelegate, a ViewSelectionVc for displaying components, and a Generated.swift file that maps each Lona component to its corresponding Swift view. This enables users to browse and interact with all supported components, including nested buttons, vector graphics, shadows, opacity, and text alignment, directly within the macOS viewer.

examples/LonaViewer/MacOS · medium confidence

The workspace UI is expanded with new components to support the publishing flow and template selection. A new OrganizationList component enables users to select an organization during the publishing process. The workspace now includes a suite of UI elements for color management, including ColorPicker, ColorWellPicker, ColorPreviewCard, and ColorPreviewCollection, allowing users to select and preview colors. Additionally, the workspace features new components for project navigation and management: OpenProjectButton, RecentProjectItem, and a set of header and row components (EditorHeader, FileNavigatorHeader, IconRow, LabeledDropdownRow) that enhance the workspace's visual structure and interactivity.

studio/workspace/components · high confidence

The Preferences window now includes an Account pane for managing GitHub and Google sign-in status, and a Workspace pane that lets users customize the workspace name, icon, compiler path, and paths for colors, text styles, and the canvas background color. A new CSPreferencesFile protocol and supporting classes (CSUserPreferences, CSWorkspacePreferences, CSColors, CSShadows, CSGradients, CSTypography, CSUserTypes) centralize preference storage and reloading, while SettingRow and ValueSettingRow provide reusable UI controls for these settings.

studio/LonaStudio/Preferences · high confidence

The Lona Studio inspector panel now includes dedicated UI components for configuring canvas properties (size, device preset, background color), layout (direction, horizontal/vertical alignment), dimensions (width, height, aspect ratio), text styles (font, size, line height, letter spacing), colors (name, value, description), and accessibility (role, label, hint, elements). A shared \InspectorSectionHeader\ component provides a collapsible header for each section. These generated Swift classes enable users to edit these specific design system properties directly within the studio interface.

studio/LonaStudio/Generated/inspector · high confidence

The InspectorView now supports editing logic function calls and custom component parameters. A new LogicInspectorView allows users to add, remove, and edit expressions within logic function calls. Additionally, a new CoreComponentInspectorView and CustomComponentInspectorView provide dedicated UI for editing core component properties and custom component parameters respectively, replacing previous generic inspector implementations.

studio/LonaStudio/Workspace/InspectorView · high confidence

Added new Swift source files (LogicEditor+ParametersView.swift and LogicEditor+TypesView.swift) that provide specialized logic editors for editing function parameters and type declarations. These editors include validation rules (e.g., parameter names cannot start with numbers), auto-suggestions for default values and type names, and contextual documentation. This enables users to define and configure component parameters and type structures directly within the studio interface.

studio/LonaStudio/Logic/Editors · high confidence

Added three new UI components in the LabeledInputs directory: LabeledInput as a base class, LabeledLogicInput for general value editing with drag-and-drop support, and LabeledColorInput for color selection. These components integrate with the Logic library to provide expression-based editing, auto-completion, and formatting, replacing previous static input implementations with a unified, logic-driven approach.

studio/LonaStudio/Logic/Views/LabeledInputs · high confidence

A new ParameterListEditorView has been introduced to handle the editing of parameter lists. This component bridges the internal Logic representation with the UI, allowing users to edit parameters and their default values. The editor supports type annotations and default value expressions, providing a dedicated interface for managing function parameters within the studio.

studio/LonaStudio/ParameterList · high confidence

The Lona Studio interface now includes dedicated screens for creating and editing colors (AddColorSheet), text styles (AddTextStyleSheet), and components (ComponentBrowser). Users can also browse and select colors (ColorBrowser), view images (ImageViewer), and choose repositories (OpenChooseRepo) directly within the generated UI. These additions support a more structured workflow for defining and organizing design tokens and UI elements.

studio/LonaStudio/Generated/screens · high confidence

Added build and distribution tooling for the Lona Studio macOS application. This includes a script to generate the appcast for Sparkle updates, a configuration file for the DMG layout, and a script to convert the app icon. These changes enable the automated creation of the signed, distributable DMG package.

studio/dmg · high confidence

The workspace and publishing flows now feature a suite of new UI components, including screens for opening and syncing workspaces (OpenWorkspace, OpenSyncLocation, OpenChooseRepo), managing repository creation and selection (PublishCreateRepo, PublishExistingRepo, PublishChooseOrg, PublishInfo, PublishDone), and browsing or editing workspace content (ColorBrowser, ComponentBrowser, GeneratedOutputPreview, ImageViewer, NoDocument). Additionally, the update introduces a CustomParametersEditorSheet for requesting custom parameters from the user and an AddColorSheet/AddTextStyleSheet for managing design tokens, alongside a NoDocument placeholder for empty directories.

studio/workspace/screens · high confidence

The compiler now ships with a new \compiler/core/types/index.d.ts\ file that exports TypeScript type definitions for styling and token structures. This includes types for font weights, color values, text styles, shadows, and token representations (color, shadow, and text style). The file also defines types for converted file contents and workspaces, providing static typing support for the compiler's output and internal structures.

compiler/core/types · high confidence

The iOS example application (LonaViewer) has been added to the project, providing a native iOS interface for browsing and inspecting generated UI components. This includes the app entry point (AppDelegate), a main screen listing all available component examples (ViewSelectionVC), and a detail view (DetailVC) that renders each component. The implementation includes a generated enum (Generated.swift) that maps to specific Swift view classes for each example, such as accessibility tests, vector graphics, nested components, and layout variations. The workspace configuration has also been updated to reference the new LonaViewer project.

examples/LonaViewer/iOS · high confidence

The LonaViewer example app now includes an iOS UI test suite that captures screenshots of each component and compares them against baseline images using Applitools Eyes. This enables visual regression testing for the iOS viewer, ensuring that UI changes are detected and reviewed. The test suite is integrated into the Xcode project and workspace configuration.

examples/LonaViewer/LonaViewer.xcodeproj · high confidence

The ComponentStudio application's user interface and associated logic have been removed. This includes the main application entry point (AppDelegate), the canvas rendering and layout system (CanvasCollectionView, CanvasView, RenderSurface), the canvas list editor (CanvasListEditor, CanvasListView), and various UI controls (Button, CSValueField, ColorPickerView, TextStylePickerView). The removal of these files eliminates the previous implementation of the component studio environment.

ComponentStudio · high confidence

The project has removed the \Pods\ directory, which previously contained the CocoaPods dependency manager and its managed libraries. Specifically, the diff shows the deletion of the \LetsMove\, \lottie-ios\, \MASPreferences\, \Sparkle\, \SwiftyJSON\, and \Yoga\ pod sources, along with the \Pods/Manifest.lock\ and \Pods/Pods.xcodeproj/project.pbxproj\ files. This indicates a shift away from using CocoaPods for managing third-party dependencies in this part of the codebase.

Pods · high confidence

The React code generator and all associated transform scripts, utility modules, and configuration files have been removed from the generators directory. This eliminates the ability to generate React components from design specs using this tooling.

generators · high confidence

The compiler's internal structure has been refactored to expose a public API via \compiler/core/src/api.js\, which now organizes code generation logic for Swift, JavaScript, XML, and Reason targets. Additionally, static logic definitions for colors, shadows, and text styles have been moved into dedicated \.logic\ files (e.g., \Color.logic\, \Shadow.logic\), and the main compiler entry point (\main.re\) has been updated to use this new modular structure.

compiler/core/src · high confidence

The markdown editor has been split into its own dedicated HTML and JavaScript bundle (markdown-editor.html and bundle.js), separating it from the main application. This structural change allows the editor to be used independently or integrated more flexibly within the studio environment, improving modularity and potentially load times by isolating the editor's dependencies.

studio/LonaStudio/Web · high confidence

The JavaScript code generation logic has been reorganized into distinct modules (e.g., \javaScriptComponent.re\, \javaScriptStyles.re\, \javaScriptFocus.re\) to improve maintainability and separation of concerns. This refactoring introduces a new AST structure (\javaScriptAst.re\) and separates concerns for rendering, logic, colors, and formatting, resulting in cleaner and more manageable compiler output for React DOM, React Native, and React Sketchapp targets.

compiler/core/src/javaScript · high confidence

The compiler's core utility functions have been reorganized into specific, modular files within the \compiler/core/src/utils\ directory. This includes dedicated modules for command-line argument parsing (\commandLine.re\), layout constraint handling (\constraint.re\), SVG conversion (\convertSvg.js\), CSS color parsing (\css.re\), file searching (\fileSearch.re\), code formatting (\format.re\), data structures like dictionaries and ranges (\jet.re\), monadic operations (\monad.re\), sequence manipulation (\sequence.re\), serialization wrappers (\serialization.re\), and UUID generation (\uuid.re\). This structural change improves code maintainability and separation of concerns within the compiler's internal logic.

compiler/core/src/utils · high confidence

The ComponentStudio.xcodeproj/project.pbxproj file has been deleted from the repository. This change removes the Xcode project configuration that defined the build structure and file references for the ComponentStudio application, likely as part of a larger migration or restructuring of the project's build system.

ComponentStudio.xcodeproj · high confidence

The compiler now includes formal type definitions for MDX nodes (such as text, headings, links, and pages) and a utility function to extract child page URLs from the AST. This enables the compiler to identify and process child pages during documentation generation.

compiler/core/src/mdx · medium confidence

The repository now enforces code quality and PR standards through new configuration files. A pre-commit hook (pre-commit-swift.sh) runs SwiftLint on staged files, while a Dangerfile (Dangerfile.swift) automates pull request reviews by warning about large PRs, missing test updates, and incomplete descriptions. A .prettierignore file was also added to exclude examples from formatting checks.

config · medium confidence

Added new Swift source files in the Logic/Types directory to handle conversions between internal Logic AST nodes and concrete UI input types. This enables richer autocomplete suggestions for color pickers, text style selectors, and URL fields, while also providing better serialization and deserialization of these specific types within the studio's logic layer.

studio/LonaStudio/Logic/Types · medium confidence

The compiler now correctly handles numeric values in styles by automatically appending 'px' units for React DOM output, ensuring that unitless numbers are properly converted to pixel-based CSS values. Additionally, new translator modules for React DOM and React Native have been introduced to map component types, style properties, and accessibility attributes (such as 'aria-checked' and 'role') to their respective DOM and native equivalents.

compiler/core/src/javaScript/utils · medium confidence

The compiler's core logic has been refactored into a set of new, dedicated modules. This includes \parameterKey.re\ and \parameterMap.re\ to manage component parameters and their mappings, \config.re\ to handle workspace and file discovery, and \types.re\ to define the internal type system. Additionally, new modules for \accessibility.re\, \color.re\, \shadow.re\, \textStyle.re\, and \svg.re\ provide structured representations for UI properties, while \layer.re\ and \layout.re\ handle the component tree and styling. These changes consolidate how the compiler parses, validates, and generates code for various platform targets.

compiler/core/src/core · high confidence

The Lona Studio utility classes have been moved from the ComponentStudio directory into the studio/LonaStudio/Utils folder. Several files were renamed or refactored, including the addition of new utility classes such as CSConstraint, Emitter, Fetch, FileSearch, FileUtils, FlippedView, History, ImageCache, RESTClient, and VirtualFileSystem. The codebase was also updated to use modern Swift and AppKit APIs, such as replacing NSFontWeight with NSFont.Weight and using NSAttributedStringKey instead of legacy NSFontAttributeName. Additionally, the LRUCache class was renamed and refactored to be more generic, and the AttributedFont class was updated to support NSCopying.

studio/LonaStudio/Utils · high confidence

The LonaStudio application code has been reorganized and modernized. The main entry point (AppDelegate) now manages the welcome window, preferences, and URL handling. A new Colors+Appearance.swift file provides theming support for light and dark modes. ForeignTypes.swift introduces type aliases for color and text style handlers, and updates to CSStatementView migrate from deprecated NSFontAttributeName to NSAttributedString.Key, while also adding support for function selection in statements.

studio/LonaStudio · high confidence

The \studio/LonaStudio/Extensions\ directory has been populated with a suite of Swift extensions that provide core utility and UI helper functions. This includes new implementations for color conversion (e.g., \Color+Conversions\), string manipulation (e.g., \StringExtensions\ with \sanitizedFileName\ and \camelCasedComponents\), and process execution (\Process+Execute\). Several existing extensions (such as \NSColorExtensions\, \NSImageExtensions\, and \NSViewExtensions\) have been moved from \ComponentStudio\ to \LonaStudio\, with updates to reflect the new location and minor behavioral improvements, such as adding a \stopEditing\ method to \NSOutlineViewExtensions\ to prevent crashes during text field editing.

studio/LonaStudio/Extensions · high confidence

The LonaStudio Xcode project has been reorganized by moving it into the studio subdirectory. This change updates the workspace configuration to reflect the new file structure, ensuring that the project builds correctly from the updated location.

studio/LonaStudio.xcodeproj/project.xcworkspace · medium confidence

The \Documents\ directory was restructured to improve window management and file handling. A new \BaseDocument\ class was introduced to centralize window creation and frame restoration logic. \DocumentController\ was refactored to manage document history for back/forward navigation, handle directory opening (redirecting to README.md), and clean up window states. Specific document types like \ComponentDocument\, \LogicDocument\, \MarkdownDocument\, \ImageDocument\, and \JSONDocument\ were reorganized to inherit from \BaseDocument\ and implement their own read/write/save behaviors, enabling features like autosaving and undo support where appropriate.

studio/LonaStudio/Documents · medium confidence

The list editors for dictionary and case types have been restructured to use modern Swift 5 syntax and AppKit APIs. This includes migrating from the SwiftyJSON library to native Swift types, updating the \ListEditor\ to use \NSUserInterfaceItemIdentifier\ instead of raw strings, and replacing deprecated \NSTableColumn\ resizing masks. Additionally, the \CaseList\ now uses \CSUnitValue\ for case type selection, and the \DictionaryEditor\ has been moved to the \studio/LonaStudio/ListEditors\ directory.

studio/LonaStudio/ListEditors · medium confidence

The shell scripts responsible for building the macOS DMG, generating the Sparkle appcast, creating the zip archive, and converting the application icon have been removed. This eliminates the local tooling used to package and distribute the application via DMG and appcast updates.

dmg · high confidence

The macOS application has been renamed from ComponentStudio to Lona Viewer. This change updates the application title, menu items (About, Hide, Quit, Help), and the associated custom class module from ComponentStudio to MacOS/Lona Viewer, reflecting the project's rebranding and directory move to examples/LonaViewer.

examples/LonaViewer/MacOS/Base.lproj · high confidence

SVG conversion in LonaStudio has been refactored to use a bundled JavaScriptCore-based compiler (LonaJS) instead of relying on an external Node.js process. This change simplifies the execution model by removing the need to spawn a separate Node process for SVG processing, which improves reliability and performance. The new implementation uses a bundled \svg-model.umd.js\ library and a \LonaJS\ Swift wrapper to handle SVG conversion directly within the app, eliminating the previous dependency on the \node\ binary for this specific task.

studio/LonaStudio/Scripting · high confidence

The Xcode project's shared scheme files for the main LonaStudio application and its test bundle have been regenerated or updated. These changes update the build, test, launch, profile, and archive configurations to align with the current Xcode environment (indicated by the LastUpgradeVersion 1020), ensuring that developers can correctly build, run, and test the application within the IDE.

studio/LonaStudio.xcodeproj/xcshareddata · high confidence

The Lona Studio workspace now includes new component definitions for file navigator icons, specifically for Book, File, and Folder types. These components define how icons appear in the UI, including their layout, color logic (using iconFill and iconFillAccent), and selection states. This change improves the visual consistency and interactivity of the file navigator icons.

studio/workspace/icons · medium confidence

The generated icon components for files, books, and folders in the file navigator have been regenerated with updated vector graphics. These changes update the visual appearance of these specific icons in the Lona Studio interface, ensuring they reflect the latest design specifications.

studio/LonaStudio/Generated/icons · high confidence

The Main.storyboard file was replaced with a new version that updates the application's main menu structure. Specifically, the 'File' menu now includes a 'New' submenu with options for 'Page' and 'Workspace', and the 'Edit' menu retains standard editing commands. This change reflects an update to the user interface layout and menu configuration for the LonaStudio application.

studio/LonaStudio/Base.lproj · high confidence

Added AppKit component tests for nested layouts and optionals; Added AppKit interactivity test components for accessibility and press states; Added AppKit layout tests for multiple layout configurations; Added AppKit logic component tests; Added AppKit snapshot tests for image rendering components; Added AppKit style test components; Added AppKit test fixtures for image resizing, text styling, and shadows; Added React DOM test components and foundation utilities; Added React Native test suite for generated components and layouts; Added React-Sketchapp snapshot tests for layout, interactivity, and asset components; Added Swift layout test cases for flexbox and constraint generation; Added Swift logic component tests for Assign, If, Optionals, RepeatedVector, and VectorLogic; Added Swift snapshot tests for interactivity components; Added Swift test components for UI style properties; Added Swift test components for nested layouts and UI elements; Added Swift test snapshots for image cropping, local assets, and vector graphics; Added Swift test utilities and generated test files; Added accessibility and interactivity test components; Added component test cases for nested structures and parameters; Added foundation test data for colors, shadows, sizes, text styles, and logic declarations; Added generated test files for brand colors and sizes; Added initial test coverage for command parsing; Added layout test cases for flexbox axis and fit behaviors; Added logic test cases for conditional rendering and state management; Added style test components for border, shadow, opacity, and text alignment; Added test components for image and vector asset rendering; Added tests for the webpack loader.

Lona Studio now includes a \.ruby-version\ file pinning Ruby 2.4.3, a \.swiftlint.yml\ configuration for the \LonaStudio\ target, and a \Cartfile\ defining dependencies on \Lona/FileTree\, \Lona/ControlledComponents\, \Lona/ColorPicker\, and \Lona/Logic\. The project also introduces new component definitions for color and shadow suggestion editors (\ColorSuggestionEditor.component\, \ShadowSuggestionEditor.component\) and moves the \Info.plist\ for the \LonaStudioTests\ target to the \studio\ directory.

studio · high confidence

This update refreshes the project's dependency and build configurations. In the root, a new package.json and linting configuration (ESLint, Prettier) were added to standardize code quality checks. The compiler core was updated to version 0.9.1, and the React component analyzer was introduced as a new package. Additionally, the CocoaPods dependency for the studio was upgraded to version 1.9.0, and the iOS example project was updated with new Podfile configurations for iOS and macOS targets.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 34 → 37 (+3.2)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 66 → 69 (+2.8)
• Architecture 67 (new)
• Maturity 57 → 53 (-4.0)
• Readiness 14 → 38 (+23.8)
• Security 48 → 25 (-22.6)
• Domain Modelling 91 (new)
• Accessibility 48 (new)

• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/sketch-library/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (studio/embedded-sites/markdown-editor/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (studio/embedded-sites/markdown-editor/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (studio/embedded-sites/markdown-editor/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (studio/embedded-sites/markdown-editor/yarn.lock)
• Critical CVE: [GHSA redacted] (studio/embedded-sites/markdown-editor/yarn.lock)
• …and 70 more

• Assertions commented out: testExample (studio/LonaStudioTests/LonaStudioTests.swift)
• Coverage not measured — JavaScript/TypeScript suite
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/sketch-library/yarn.lock)
• Critical CVE: [GHSA redacted] (studio/embedded-sites/markdown-editor/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/webpack-loader/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/sketch-library/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/sketch-library/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/react-component-analyzer/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/react-component-analyzer/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/sketch-library/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/sketch-library/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/sketch-library/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/webpack-loader/yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (studio/embedded-sites/markdown-editor/yarn.lock)
• Critical CVE: [GHSA redacted] (compiler/core/yarn.lock)
• Critical CVE: [GHSA redacted] (studio/embedded-sites/markdown-editor/yarn.lock)
• …and 236 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Lona/Lona was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.