0.8.27 - Empty packs and canonical integrated-pack environments

Editable packs can now remain completely empty: creating a pack or deleting its final environment no longer creates General. Integrated starter packs also preserve their own root environment. For example, adding Qt creates or reuses QT, then places the selected Qt Language, Qt QML, Qt Multimedia, Qt SQL & Test, and Qt for Python (PySide6) libraries underneath it. The same model is enforced across the other embedded pack families, including Embedded, SDL, and Windows API / Devices. The starter audit also restores the split Web and DevOps libraries and adds the Meson library to the complete Build family.

0.8.26 - Lua pack hierarchy normalization

The embedded Lua pack now follows the same integrated hierarchy as the other structured packs: one top-level Lua environment, then dedicated libraries for Lua standard 5.4, Lua industriel / banc de test, MPT Studio / MPTLua (Lua 5.2.4), and Stormworks Lua microcontroller. The LuaFileSystem helpers added in 0.8.25 remain available inside the standard Lua library under the LuaFileSystem (lfs) category.

0.8.25 - Lua filesystem utilities pack enrichment

This release enriches the embedded Lua pack with a dedicated LuaFileSystem (lfs) library: file existence checks, attributes, file/directory detection, directory listing and recursive traversal, current directory management, mkdir/rmdir, touch/link and locking helpers. It also adds standard Lua fallback snippets based on io.open/os.rename for projects where lfs is not installed.

0.8.24 - Digital filter coefficient parser runtime fix

The Digital filter designer now correctly parses the generated b and a coefficient textareas inside the real VS Code webview. This fixes the case where Bode / phase, canonical forms and stability could display b = [0] and a = [0] even though valid scientific-notation coefficients were visible in the textareas.

0.8.21 - Digital filter designer

• Added JC LIB > Utilities > Signal / filter tools > Open digital filter designer.
• Added IIR biquad and FIR coefficient design, Bode/phase plots, pole-zero unit-circle stability check, canonical forms, C skeleton generation, filter family comparison, and Z-transform reference.

JC Lib 0.8.10 — context color picker

The editor context menu now includes JC LIB → Utilities → Insert color value. It opens an integrated color selector and can insert colors as #RRGGBB, 0xRRGGBB, 24-bit decimal RGB integer, CSS rgb()/rgba(), decimal channel lists, SDL_Color, VBA RGB() or Qt QColor(). Library packs are unchanged.

0.8.19 update

• Number / bit converter: multi-byte arrays now parse correctly (0xFF 0xFF, 0xFF, 0xFF, { 0xFF, 0xFF }).
• Base conversion now includes Gray code output and Gray-code input decoding.

JC Lib 0.8.3 — Arduino Mega 2560 / ATmega2560 embedded coverage

JC Lib 0.8.7 context-menu label cleanup

Editor context-menu actions are grouped under JC LIB; labels inside that root are now shorter: Insert snippet, Save as snippet, Insert file header, Insert header change line, and Insert comment section. Library packs are unchanged.

• Added Arduino Mega 2560 / ATmega2560 embedded library with register bit-field builder, Timer1/3/4/5 coverage, USART0..3, ADC16, XMEM, linker scripts and bootloader recipes.

JC Lib 0.7.92 — native Explorer launcher focus correction

The JC Lib Activity Bar launcher now opens VS Code's built-in Explorer and explicitly reveals the first JC Lib environment in the contributed JC Lib Libraries view. This ensures that the library browser is visible and focused below the standard workspace file explorer instead of leaving the user on the file explorer alone. The native vertical splitter remains managed by VS Code.

JC Lib 0.7.91 — native Explorer integration

JC Lib Libraries now lives inside VS Code's built-in Explorer container. The standard workspace file explorer remains at the top of the sidebar and the library browser is displayed below it. VS Code provides the vertical splitter, so both sections can be resized and reordered with the native sidebar interaction. The JC Lib Activity Bar icon remains available as a launcher and redirects to this composite Explorer layout.

JC Lib 0.7.81 — generated HTML-preview escaping fix

This maintenance release corrects the HTML empty-attribute normalizer inside generated symbol-detail webviews. Clearing id, className, name, value, or another quoted optional HTML attribute now removes the complete attribute fragment from the live preview. The previous runtime could leave malformed remnants such as id="" or cla. The Web pack remains 1.5.0; Build and Scripting / System are unchanged.

JC Lib 0.7.79 — comprehensive structured HTML elements

This pass upgrades data/web_language_pack.json to 1.4.0. The HTML category now covers the complete conforming HTML-element baseline organized by purpose: document metadata, semantic sections, text, lists, inline semantics, media, embedded content, scripts, templates, Web Components, tables, forms, buttons, inputs, disclosure widgets and dialogs. High-use markup cards expose editable IDs, CSS classes, constrained enum choices and an optional global-attribute fragment for data-*, ARIA and other documented attributes. Twenty-two <input> presets are included. Experimental <fencedframe> and <geolocation> cards are isolated from the conforming baseline. <selectedcontent> is included with form controls because it is present in the current WHATWG conforming-elements index. Bundled metadata advances to 2.19.0; runtime behavior is unchanged.

JC Lib 0.7.78 — SSH Device Manager interface cleanup

This maintenance release removes the temporary PowerShell/Bash routing reminder card from the visual SSH Device Manager. Shell-aware terminal routing remains enabled: Bash cards are still sent to WSL or Git Bash under Windows, PowerShell cards to PowerShell, and Batch cards to CMD. The standalone Scripting / System catalog remains 1.9.0; Visual Studio 2026 compatibility is unchanged.

JC Lib 0.7.77 — visual SSH Device Manager and shell-aware terminal routing

This pass adds a dedicated JC Lib: Open SSH Device Manager webview. It loads explicit OpenSSH aliases from ~/.ssh/config, shows local resolver aliases from the system hosts file, scans known local neighbours through arp -a on Windows or ip neigh show on Linux/WSL, and exposes visual add, edit, delete, connect, inspect, key-test, Ed25519-generation and public-key-enrollment actions. Shell-specific execution is now routed to managed terminals: Bash cards use WSL or Git Bash on Windows, PowerShell cards use PowerShell, and Batch cards use CMD. The standalone Scripting / System catalog remains 1.9.0; Visual Studio 2026 import compatibility is unchanged.

JC Lib 0.7.76 — environment paths, local resolver aliases and key-backed OpenSSH aliases

This pass extends Scripting / System to version 1.9.0. CMD, PowerShell and Bash now expose direct cards for environment values, persistent user or machine variables and known system paths. Windows hosts, Linux /etc/hosts and DNS-cache helpers make local IP-to-name mappings discoverable. The standalone OpenSSH library adds resolved-alias inspection, alias listing, parameterized Host templates and Bash/PowerShell enrollment recipes that generate a local Ed25519 key, deploy only its public half and bind the private identity to a reusable alias such as myraspi. Persistent mutations require confirmation before terminal execution.

JC Lib 0.7.75 — SSH password-prompt helpers and terminal execution

This pass extends Scripting / System to version 1.8.0. The standalone OpenSSH library now exposes an explicit ssh login with password prompt card, a parameterized ssh remote command, a direct ssh-copy-id install public key card and a safety reference explaining that OpenSSH passwords must be typed interactively rather than embedded in command lines. The symbol-details webview adds an Execute in terminal action for command cards and Scripting / System recipes. It reuses the active VS Code terminal or creates a JC Lib terminal when needed. Potentially destructive and multi-line commands require confirmation.

JC Lib 0.7.74 — Scripting / System standalone Git, SSH, Docker and DevOps libraries

This pass reorganizes the Scripting / System pack to version 1.7.0. The previous mixed Git, SSH, Docker & DevOps library is split into four independent libraries: Git Version Control, OpenSSH & Secure Remote Access, Docker & Containers, and DevOps, CI & Release Automation. Redundant SSH/SCP cards formerly exposed by Bash, CMD and cross-platform groups are removed in favor of canonical commands in the standalone SSH library. Integrated-pack generation remains VS Code only.

JC Lib 0.7.73 — Scripting / System redirection, device inventory and networking expansion

This pass extends the Scripting / System pack to version 1.6.0. It adds CMD, PowerShell and Bash output-redirection cards, Windows USB and COM inventory through PnPUtil, Get-PnpDevice and Win32_SerialPort, Linux USB and tty inventory, and broader Windows/Linux networking diagnostics. Integrated-pack generation remains VS Code only.

JC Lib 0.7.72 — Scripting / System direct-command closure audit

The second Scripting / System audit removes residual historical command snippets, clearly labels retained recipes and templates, expands direct parameterized Git stash/recovery/remotes/worktrees/submodules, OpenSSH, Docker, PowerShell, CMD, Bash and systemd cards, and keeps integrated-pack generation exclusive to VS Code.

JC Lib 0.7.70 — Build & Toolchains audit phase 2

The Build pack now covers CMake, Meson, GCC/G++, Clang/LLVM, MinGW, MSVC, Make, Ninja, pkg-config, vcpkg, Conan 2, cross-compilation, binary inspection, debugging, coverage, documentation, and CI with structured conditional parameters. Integrated-pack generation remains a VS Code-only workflow.

JC Lib 0.7.69 — create-pack ergonomics and structured SCP

This version keeps the environment-first explorer and adds a post-creation integrated-pack prompt, separates LabWindows/CVI from the C pack family, and improves SCP command cards with conditional -P and -i parameters.

JC Lib 0.7.69 — environment folders restored in the main explorer

The main JC Lib explorer now mirrors the Visual Pack Editor hierarchy: Environment → Library → Category → Group → Symbol. Environment and library names are no longer flattened into labels such as Build / GCC & G++. The environment-first import behavior and validated multi-select parameters introduced in 0.7.67 remain unchanged.

JC Lib 0.7.67 — environment-first pack hierarchy restored

JC Lib now keeps the intended Environment → Library → Category → Group → Symbol hierarchy for editable packs. New packs no longer request a default language, but they do preserve environments as the top visible level. Family-level starter imports create a dedicated environment and add the selected sub-packs as libraries: Add all Build creates Build, while Add all Lua creates Lua with the four Lua libraries. Structured multi-select validation from 0.7.66 remains active.

Version 0.7.64 — Webview runtime escaping fix

A generated-webview JavaScript escaping regression introduced in 0.7.63 has been corrected. Live parameter previews, structured parameter pickers and the Visual Pack Editor are restored. A dedicated regression test now parses the JavaScript emitted inside both webviews before packaging.

Version 0.7.63 — Build command preview correction

Build-tool cards are rendered as commands. For example, gcc shared library now previews a shell command such as gcc -Wall -Wextra -O2 -fPIC -shared src/mylib.c -o "libmylib.so" -Llib -lm, rather than a synthetic C-style function call.

Build link-argument clarification — JC Lib 0.7.62

GCC, G++ and MinGW Build cards now separate header search paths (-I), library search paths (-L), linked libraries (-lfoo) and free-form linker options. The folder browser row associated with -I or -L is conditionally disabled until its documented prefix is selected. This avoids ambiguous commands such as a raw libraries field mixing unrelated compiler and linker switches. See docs/BUILD_LINK_ARGUMENTS_AUDIT_0.7.62.md.

Transversal structured-pack audit — JC Lib 0.7.60

All distributed JSON packs have been rechecked with a cross-pack validator. The audit repairs stale hierarchy metadata in Embedded, Qt and Web cards, removes remaining C++ and QML duplicate cards, disambiguates the two C json_object_get APIs, makes Python frame_signal parameters effective, converts conflicting Vue moustache examples to v-text, documents the SDL2-to-SDL3 migration path and completes the missing ordinary-parameter help text in the SDL2 and Windows API / Devices packs. The reusable validator is available under scripts/audit-packs.py. See docs/TRANSVERSAL_PACK_AUDIT_0.7.60.md.

OpenCV standalone structured C++ pack — phase 1

The historical hard-coded OpenCV starter has been migrated to data/opencv_pack.json. OpenCV C++ now exposes parameterized direct cards for matrices, codecs, color conversion, transforms, filters, morphology, contours, drawing, HighGUI callbacks, camera backends, video writing, motion analysis, features, matching, calibration, modern ArUco / ChArUco detection, QR decoding, DNN inference, CMake, pkg-config, vcpkg and runtime diagnostics. File and folder paths use native browser metadata where appropriate. Architectural camera and robotics workflows remain separated under Recipes — groups. See docs/OPENCV_CPP_STRUCTURED_AUDIT_PHASE1.md.

Embedded USB, FDCAN, Modbus and bootloader structured pack

The Embedded pack now includes STM32 HAL1 FDCAN, STM32 USB Device CDC/HID, Arduino-ESP32 native USB CDC, ESP-Modbus v2, AVRDUDE, stm32flash, dfu-util and OpenOCD cards in addition to the previous direct APIs and preserved examples.

Embedded advanced peripherals structured pack

The Embedded pack now includes STM32 HAL / STM32CubeProgrammer, Arduino-ESP32 ESP-NOW, RMT, I2S, ESP-IDF TWAI, esptool and Raspberry Pi libmodbus RTU cards in addition to the phase-1 direct APIs and preserved examples.

Audited Embedded structured API pack

The Embedded pack now adds ATmega328P register-configuration blocks, GNU ld / bootloader memory templates, and dedicated Microchip PIC and Texas Instruments MSP environments. The Embedded pack now exposes direct parameterized cards for FreeRTOS task coordination, Arduino AVR Core APIs, ESP32 Arduino peripherals and Raspberry Pi Linux GPIO / bus commands. Existing snippets remain available as complete workflow examples.

Audited CMD / Batch language building blocks

The System scripting pack now exposes direct CMD / Batch cards for quoted set assignments, positional-argument transformations such as %~1, %~f1 and %~dp1, numeric and textual if forms, for, for /d, for /r, for /l, for /f, setlocal, shift, call, goto, exit /b and choice. Existing snippets remain available as complete workflow examples.

Audited System scripting command parameters

The System scripting pack now exposes parameterized direct command cards for PowerShell, CMD, Bash, systemd, Git and Docker. Compatible command-line switches use documented space-separated multi-selection fields, while mutually exclusive policies remain separate selectors. GNU chmod now exposes recursive, output, symbolic-link, root-preservation, traversal and mode controls. Use data/system_scripting_pack.json for the complete bundle.

Audited Lua / MPTLua advanced parameters

The Lua pack now exposes documented advanced pickers for Lua 5.4 standard-library modes, native boolean controls, file and folder browsers, MPTLua operator helpers, DHV runtime controls and Stormworks text alignment. Use data/lua_pack.json for the complete Lua, MPTLua and Stormworks bundle.

Audited SDL2 pack and obsolete Platform starter removal

The SDL pack is now distributed as data/sdl_pack.json. SDL2, SDL_image, SDL_ttf, SDL_mixer and SDL2_net expose direct cards with documented enum and bitmask pickers. The obsolete Platform pack starter family has been removed because its Win32 and serial content is superseded by the audited Windows API / Devices pack.

JC Lib

JC Lib is a Visual Studio Code extension for browsing, inserting, creating, importing, exporting, and visually editing reusable programming-assistance packs. It is inspired by the LabWindows/CVI visual library browser: a developer can navigate libraries and symbols, inspect prototypes or snippets, fill parameters, and insert generated content into the active editor.

Main features

• Native Explorer integration: workspace files above a resizable Environment -> Library -> Category -> Group -> Symbol JC Lib section.
• Symbol details and parameterized insertion from the main view.
• Visual Pack Editor for creating, editing, moving, reordering, exporting, and deleting content.
• Workspace-specific and global reusable packs.
• Source/header import for functions, structs, typedefs, enums, enum class, classes, and methods.
• Header generation and scoped content export.
• Starter packs for native development, Qt, web, databases, scripting, embedded targets, and examples.
• Special LabWindows/CVI-oriented import workflows and editable custom packs.

Installation

Install the packaged .vsix from VS Code:

1. Open the Extensions view.
2. Open the ... menu.
3. Select Install from VSIX....
4. Select the jc-lib-0.7.64.vsix file.
5. Run Developer: Reload Window.
6. Run JC Lib: Reload Library Packs if an already-open workspace still displays cached content.

Daily workflow

1. Click the JC Lib Activity Bar icon. JC Lib redirects to the native Explorer container, with workspace files above the resizable JC Lib Libraries section.
2. Run JC Lib: Add Library Pack to create an editable pack in the workspace or global storage.
3. Run JC Lib: Add Content To Library Pack to add starter packs, environments, libraries, categories, symbols, imports, or snippets.
4. Run JC Lib: Open Visual Library Pack Editor for structural editing.
5. Select a symbol in the sidebar to inspect it, parameterize it when applicable, and insert its generated call or snippet into the active editor.

Pack locations

Workspace packs are stored in:

.vscode/jc-lib/packs/*.json

Global packs are stored under the VS Code extension global-storage directory in:

packs/*.json

Use workspace packs for project-specific assistance committed with a repository. Use global packs for personal reusable libraries.

Pack catalog

The bundled starter families include:

• C, C++, preprocessor, DLL helper patterns, SDL, and LabWindows/CVI-oriented content
• Qt C++ and Qt for Python / PySide6
• OpenCV
• CMake, GCC, G++, and MinGW build helpers
• Win32, Windows Devices, serial, and platform helpers
  • Windows bitmask parameters can use an advanced multi-select popup that documents each flag and generates expressions such as SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW.
• Cross-platform automation, PowerShell, Windows CMD/Batch, Bash/POSIX shell, Linux systemd administration, Git, SSH, Docker, Compose, and CI helpers
• Python, Java, JavaScript / HTML / CSS, C# / .NET, PHP, Kotlin, TypeScript, and Lua
• SQL fundamentals, SQLite, PostgreSQL, MySQL/MariaDB, SQL Server, DuckDB, MongoDB, and Redis
• Embedded and example packs

See docs/PACK_CATALOG.md for the detailed family list.

C++ concurrency and asynchronous programming

The bundled C++ environment contains a dedicated concurrency branch:

C++
└── C++ Language
    ├── Concurrency
    │   ├── Concurrency quick reference
    │   ├── Threads & lifecycle
    │   ├── Mutexes & locking
    │   ├── Condition variables & producer-consumer
    │   ├── Futures, promises & async
    │   ├── Atomics & memory ordering
    │   ├── C++20 synchronization primitives
    │   ├── Parallel algorithms & execution policies
    │   └── Practical concurrent patterns
    ├── Coroutines (C++20)
    └── Modern Standard Utilities

The branch includes std::thread, std::jthread, std::future, std::promise, std::async, std::packaged_task, std::shared_future, mutex variants, condition variables, atomics, semaphores, latches, barriers, execution policies, worker queues, coroutine fundamentals, and selected modern standard-library utilities. See docs/CPP_PACK_AUDIT.md.

Structured C++ standard-library fiches

The C++ pack now uses the same richer presentation model as the Lua and CVI packs for the standard-library core. Direct calls such as std::async, future.wait_for, std::filesystem::copy_file, std::sort, std::this_thread::sleep_for, std::make_unique<T>, and atomicValue.store expose typed parameters, optional return targets, default values, presets, and contextual pickers. Type entries such as std::vector<T>, std::map<Key, T>, std::thread, std::future, and std::atomic<T> document their main methods without duplicating the former pedagogical snippets. File opening modes and concurrency policies use drop-down selectors. See docs/CPP_STRUCTURED_REFACTOR_PHASE1.md.

Structured C++ platform and Qt fiches

The second C++ refactor pass applies the same presentation model to platform-oriented APIs without creating parallel trees. Serial I/O, USB, TCP/UDP, HTTP, IPC, dynamic-library loading, coroutines, Qt signals, timers, dialogs, files, settings, processes, network requests, QThread, QLibrary, and QPluginLoader now expose typed parameters, optional return targets, presets, and contextual selectors where relevant. Multi-step workflows remain available inside detailed descriptions. See docs/CPP_STRUCTURED_REFACTOR_PHASE2.md.

MPTLua API coverage

The bundled Lua pack now includes an expanded MPT Studio / MPTLua branch derived from the supplied API sources. In addition to the high-level PUT helpers, it indexes advanced mpt.api.* wrappers for instruments, switching, ISM cards, LCOM execution, IO, runtime inspection, and published constant tables. A curated mpt.lib.* helper branch covers switching, product tare, engineering-unit conversion, DMC256, trace, probe, learning, self-test, and Zebra label printing. See docs/MPTLUA_API_AUDIT.md.

A second runtime-object branch indexes navigable state tables and methods under mpt.env, mpt.hw_setup, and mpt.app, including mpt.env.switching.card_list, mpt.hw_setup.switching.card_list, switching point tables, DHV host/master relay managers, instrument runtime objects, and switching databases. See docs/MPTLUA_RUNTIME_OBJECTS_AUDIT.md.

JavaScript operators

The JavaScript / HTML / CSS starter family is split into independent JavaScript, HTML, and CSS libraries. The HTML library contains a dedicated section:

Web
├── JavaScript
│   └── JavaScript Language & Modules
│       └── Core syntax & data structures
├── HTML
└── CSS

The section includes dedicated entries for:

• strict and loose equality: ===, !==, ==, !=
• relational comparisons and Object.is
• logical operators, short-circuit evaluation, ??, ||, and logical assignment
• arithmetic, increment/decrement, compound assignment, and ternary expressions
• bitwise flags: &, |, ^, ~
• shifts: <<, >>, >>>
• bit-mask helpers and wide-mask BigInt examples
• in, delete, void, instanceof, and operator-precedence guidance

For Number, JavaScript bitwise operators convert operands to signed 32-bit integers. Use the dedicated BigInt example when a mask exceeds that range.

Qt dialogs, popups, and notifications

The Qt starter content now contains a dedicated Widgets dialog section with ready-to-insert examples for:

• QMessageBox::information, warning, critical, question, detailed messages, and About popups
• QFileDialog open, multi-open, save, and directory selection
• QInputDialog text, multiline text, integer, floating-point, and item selection
• QColorDialog, QFontDialog, and synchronous or modeless QProgressDialog
• lightweight feedback with QStatusBar, QToolTip, widget tooltips, QSystemTrayIcon, and context menus

The QML branch also includes MessageDialog, FileDialog, FolderDialog, ColorDialog, FontDialog, custom Popup, Dialog, and attached ToolTip examples. PySide6 equivalents are bundled in the Qt for Python pack.

Documented Qt for Python / PySide6 advanced parameter choices

The PySide6 pack now applies the same documented advanced-picker model as the Windows API / Devices, C, C++, Python and Qt C++ packs. Enum values display contextual explanations, native boolean fields no longer retain redundant False / True arrays, and compatible QFlags parameters expose controlled multi-selection with | composition.

Detailed coverage is documented in docs/QT_PYSIDE_ADVANCED_PARAMETER_CHOICES_AUDIT_PHASE7.md.

Structured Qt for Python / PySide6 application utilities, plugins and deployment fiches

The sixth PySide6 refactor pass converts Application Utilities, Plugins & Deployment into editable fiches. Command-line parsing, translations, locale handling, runtime diagnostics, plugin search paths, shared libraries, Qt plugins and QML integration now expose typed parameters, return values, selectors and file or folder browsers. Deployment commands remain explicit recipes, with pyside6-project documented around the current pyproject.toml format and pyside6-deploy retained as the official desktop bundle wrapper.

Detailed coverage is documented in docs/QT_PYSIDE_STRUCTURED_REFACTOR_PHASE6_UTILITIES_DEPLOYMENT.md.

Structured Qt for Python / PySide6 threading and graphics fiches

The fifth PySide6 refactor pass converts Threads, Concurrency & Async and Painting, Graphics & Imaging into editable fiches. QThread worker lifecycles, pools, synchronization primitives, QtConcurrent, the technical-preview QtAsyncio bridge, QPainter drawing, image I/O, SVG rendering, graphics scenes and property animations now expose typed parameters, return values, enum selectors, boolean selectors and file browsers. Architecture recipes remain explicit where a complete class or lifecycle is clearer than an isolated call.

Detailed coverage is documented in docs/QT_PYSIDE_STRUCTURED_REFACTOR_PHASE5_THREADS_GRAPHICS.md.

Structured Qt for Python / PySide6 device and networking fiches

The fourth PySide6 refactor pass converts Serial, Bus & Device I/O and Networking, Web & IPC into editable fiches. Qt SerialPort, CAN, Modbus, Bluetooth discovery, BLE controller lifecycle, TCP, UDP, local IPC, HTTP, DNS, TLS, WebSocket, WebChannel and WebEngine calls now expose typed parameters, return values, enum selectors, boolean selectors and contextual backend notes. Raw USB limitations and deployment-sensitive TLS or BLE caveats remain explicit references.

Detailed coverage is documented in docs/QT_PYSIDE_STRUCTURED_REFACTOR_PHASE4_DEVICE_NETWORK.md.

Structured Qt for Python / PySide6 models, files and process fiches

The third PySide6 refactor pass converts Models, Views & Delegates and Files, Settings & Processes into editable fiches. Standard list, table, tree and filesystem models, model notifications, proxy filtering, selections, delegates, persistent settings, standard paths, file watchers, lock files, Qt JSON helpers and asynchronous QProcess operations now expose typed parameters, return values, selectors, and native file or folder browsers where useful. Custom-model subclasses, delegate overrides, stream operators and blocking-process caveats remain contextual recipes where complete syntax is clearer.

Detailed coverage is documented in docs/QT_PYSIDE_STRUCTURED_REFACTOR_PHASE3_MODELS_FILES.md.

Structured Qt for Python / PySide6 widgets and Designer fiches

The second PySide6 refactor pass converts Widgets & Windows and Designer & UI Forms into editable fiches. Main windows, generic widgets, common inputs, item-based tables, layouts, docks, splitters, actions, menus, shortcuts, standard dialogs, tray notifications, runtime .ui loading, resources, and translations now expose typed parameters, return values, enum selectors, boolean selectors, and native file or folder browsers where useful. Complete assembly patterns remain recipes when sequencing matters.

Detailed coverage is documented in docs/QT_PYSIDE_STRUCTURED_REFACTOR_PHASE2_WIDGETS_DESIGNER.md.

Structured Qt for Python / PySide6 fiches

The first PySide6 in-place refactor pass converts the QtCore foundation into editable fiches instead of snippet-only workflows. QObject lifetime, signal blocking, URL and byte-array helpers, application metadata, signal connections, event posting, QTimer, QElapsedTimer, QDeadlineTimer, QBasicTimer, QApplication, event processing, and repaint calls now expose typed parameters, return values, enum selectors, boolean selectors, and a native file browser for local URLs. The obsolete Qt Industrial Dashboard library has been removed from the Qt C++ standalone pack, compatibility copies, generator choices, and example-pack menu.

Detailed coverage is documented in docs/QT_PYSIDE_STRUCTURED_REFACTOR_PHASE1.md.

Structured Qt C++ fiches

The first Qt in-place refactor pass converts the most frequently reused Qt Core and Widgets calls into editable fiches instead of parallel snippet-only references. QObject, typed signal-slot connections, queued invocation, QTimer, QElapsedTimer, QDeadlineTimer, QBasicTimer, standard dialogs, status-bar feedback, widget tooltips, desktop notifications, and context menus now expose typed parameters, return values, presets, and contextual selectors.

The Qt starter-pack generator now loads data/qt_pack.json directly. The bundled default pack remains synchronized for compatibility, but newly generated Qt packs are sourced from the standalone structured JSON file. Detailed coverage is documented in docs/QT_STRUCTURED_REFACTOR_PHASE1.md.

Qt timers, delays, and scheduling

The Qt starter content now exposes a dedicated, easy-to-find branch:

QT
└── Qt Language
    └── Timers, Delays & Scheduling

It contains ready-to-insert examples for periodic and single-shot QTimer callbacks, reusable one-shot timers, start() / stop() control, remaining-time inspection, accuracy modes, zero-delay incremental work, QChronoTimer, QElapsedTimer, QDeadlineTimer, QObject::startTimer(), QBasicTimer, and worker-thread-only blocking sleeps. A parallel QML branch documents Timer, and the PySide6 pack contains equivalent Python examples.

Qt structured multimedia, SQL, and testing fiches

The sixth Qt in-place refactor pass structures the remaining high-value APIs in the Qt Multimedia and Qt SQL & Test libraries. Playback, camera capture, microphone routing, recorder setup, audio-device selection, sound effects, SQL connections, prepared queries, transactions, SQL models, and Qt Test macros now expose typed parameters, return values, presets, and file selectors where relevant. Complete media pipelines, SQL workflows, and asynchronous test examples remain attached to the direct-call fiches as detailed examples. See docs/QT_STRUCTURED_REFACTOR_PHASE6.md.

Main commands

• JC Lib: Refresh Libraries
• JC Lib: Find Symbol — opens directly in text-entry mode with no initial result list. The quick search is transient: accepting with Enter or closing with Escape restores the complete sidebar tree. Default shortcut: Ctrl+Alt+P (Cmd+Alt+P on macOS), configurable from VS Code Keyboard Shortcuts.
• JC Lib: Clear Filter
• JC Lib: Reload Library Packs
• JC Lib: Manage Library Packs
• JC Lib: Import Library Pack
• JC Lib: Add Library Pack
• JC Lib: Open Visual Library Pack Editor
• JC Lib: Generate Header From Library Pack
• JC Lib: Import Source/Header Into Library Pack
• JC Lib: Add Content To Library Pack
• JC Lib: Export Content From Library Pack
• JC Lib: Delete Content From Library Pack
• JC Lib: Show Symbol Details
• JC Lib: Insert Symbol Call

Minimal editable pack

{
  "id": "my-pack",
  "name": "My Pack",
  "language": "cpp",
  "version": "1.0.0",
  "readOnly": false,
  "environments": []
}

The complete format is described in docs/PACK_FORMAT.md.

Rebuild locally

From the extracted extension source directory:

npm install
npm run compile
vsce.cmd package

On Windows PowerShell, prefer vsce.cmd package if script execution policy blocks vsce.ps1.

Documentation

• docs/USER_GUIDE.md: daily operation and common workflows
• docs/PACK_CATALOG.md: starter-pack families
• docs/PACK_FORMAT.md: JSON structure and manual authoring
• docs/TROUBLESHOOTING.md: common installation, cache, build, and pack-display issues
• CHANGELOG.md: version history

Symbol kinds

JC Lib distinguishes executable calls from navigable data symbols. Supported kinds include function, method, table, property, variable, reference, struct, typedef, enum, enum_class, class, constant, operator, metamethod, macro, command, concept, attribute, keyword, snippet, and pitfall. A table is rendered as a navigable object with known fields and methods rather than as a function call.

C++ structured pack 2.2.0

The C++ pack now includes structured templates and concepts, JSON/configuration APIs, exceptions and error codes, testing helpers, and target-oriented CMake commands.

C++ structured utilities phase 4

The JSON-backed C++ pack also includes parameterized fiches for text parsing, std::regex, locale-independent std::from_chars / std::to_chars, mathematical functions, random engines, bit manipulation, filesystem paths, advanced std::chrono, RTTI, process termination helpers, and modern optional / expected accessors. Workflow-oriented examples remain available in the long descriptions instead of being duplicated in parallel trees.

C++ structured utilities phase 5

The JSON-backed C++ pack also includes parameterized fiches for advanced std::ranges views, std::span, smart-pointer lifecycle methods, raw-memory algorithms, PMR resources, cooperative cancellation with std::stop_token, reader-writer mutexes, timed locks, shared futures, atomic compare/exchange operations, C++20 synchronization primitives, coroutine protocol objects, nested exceptions, stack traces, and std::source_location accessors. API-shaped snippets were converted in place; workflow-oriented examples remain available where their full sequence is more useful than an isolated call.

C++ structured utilities phase 6

The JSON-backed C++ pack also includes in-place structured fiches for everyday STL composition: vector and string lifecycle methods, bitset operations, std::pair, std::tuple, std::apply, reference wrappers, numeric prefix scans, stream manipulators, dynamic formatting helpers, filesystem status and permissions, directory-entry metadata, path operations, chrono timezone database objects, and thread_local. The redundant simplified std::span<T> entry was removed in favor of the richer std::span<T, Extent> fiche.

C++ structured utilities phase 8

The C++ pack 2.7.0 completes common sequential-container methods, classic and ranges algorithms, heap and permutation algorithms, type traits, callable adapters, modern wrapper accessors, complex-number utilities, modules, standard attributes, preprocessor feature detection, and associative lookup helpers. The editor also exposes attribute as a first-class symbol kind. Parameterized insert templates allow attributes, module declarations, and preprocessor directives to keep editable fields without being rendered as artificial function calls.

The C++ pack 2.8.0 adds a ninth structured pass for advanced stream state, file cursors, filesystem links and recursive traversal, richer path transformations, allocator traits, raw-storage construction helpers, PMR resource operations, portable error conditions, partition algorithms, std::move / std::forward / std::exchange, numeric limits, and native file or folder picker metadata on relevant path parameters.

C++ structured utilities phase 10

The C++ pack 2.9.0 extends the same in-place structured hierarchy with iterator access helpers, advanced C++20/C++23 std::views adaptors, additional type traits and concepts, advanced smart-pointer ownership helpers, civil-date std::chrono types, mathematical functions, safe signed/unsigned integer comparisons, and tuple metadata. C++23 ranges views are identified explicitly because practical support depends on the standard library version used by the project.

C++ structured utilities phase 11

The C++ pack 2.10.0 completes additional everyday standard-library surfaces without creating duplicate branches: direct lifecycle helpers for sequential and associative containers, missing C++20 std::ranges algorithms, ownership-aware lock controls, atomic bitwise and wait/notify methods, duration and calendar accessors, random distributions, and std::match_results inspection helpers. Existing native file and folder picker metadata remains unchanged.

C++ Basic fundamentals

The C++ pack groups core language material under Basic: keywords, snippets, generic control flow, logical and comparison operators, arithmetic operators, bitwise operators, scope examples, and operator-overloading patterns. Container-specific loops remain under Iterators & Traversal so the pack avoids duplicate navigation entries.

C++ Basic design foundations

The C++ Basic category also includes compact, parametric references for labels and goto, exception handling, structures, scoped and unscoped enums, aliases, constructors, initializer lists, destructors, function overloads, parameter-passing styles, inheritance, virtual overrides, abstract bases, and composition. Existing introductory examples are relocated into Basic; advanced branches retain the more specialized APIs.

Structured Qt C++ fiches — phase 2

The second Qt in-place refactor pass restructures file I/O, settings, JSON, child processes, filesystem helpers, HTTP, TCP, UDP, local IPC, TLS, WebSockets, worker threads, thread pools, futures and synchronization primitives. Direct calls expose typed parameters, return values, enum choices and path selectors. Event-driven workflows remain available as retained examples in detailed descriptions. Coverage is documented in docs/QT_STRUCTURED_REFACTOR_PHASE2.md.

Structured Qt C++ fiches — phase 3

The third Qt in-place refactor pass restructures Qt Widgets and model/view programming. Direct fiches now cover widget visibility, enabled state, window titles, focus, labels, buttons, line edits, validators, combo boxes, spin boxes, sliders, progress bars, layouts, splitters, tabs, stacked pages, docks, actions, menus, toolbars, standard item models, abstract model access, proxy filters, selections, mappings, QListWidget, QTableWidget, and QTreeWidget. Multi-step construction and signal-wiring workflows remain available as retained examples in detailed descriptions. Coverage is documented in docs/QT_STRUCTURED_REFACTOR_PHASE3.md.

Structured Qt C++ fiches — phase 4

The fourth Qt in-place refactor pass restructures event delivery, keyboard and mouse input, drag-and-drop, MIME data, clipboard access, QPainter primitives, reusable painter paths, QImage, QPixmap, QMovie, widget screenshots, Graphics View scenes and items, zoom controls, and animation helpers. Direct API calls expose typed parameters, enum choices, boolean toggles, and native image-path selectors. Complete event-filter, custom-painting, graphics-view, and animation workflows remain attached to converted cards as detailed examples. Coverage is documented in docs/QT_STRUCTURED_REFACTOR_PHASE4.md.

Structured Qt C++ fiches — phase 5

The fifth Qt in-place refactor pass restructures industrial device I/O and application-extension helpers. Direct fiches now cover QSerialPort, QSerialPortInfo, CAN frames and devices, Modbus clients and data units, Classic Bluetooth sockets, BLE controllers, QCoreApplication identity and plugin paths, QCommandLineParser, Qt logging, translations, QLibrary, and QPluginLoader. Existing multi-step communication, DLL-loading, and plugin workflows remain attached to converted cards as detailed examples. Coverage is documented in docs/QT_STRUCTURED_REFACTOR_PHASE5.md.

Qt QML declarative templates

The Qt pack includes editable QML templates for language fundamentals, visual items, anchors, layouts, Qt Quick Controls, models and views, timers, dialogs, states, transitions, animations, dynamic components, and C++ integration. QML templates are inserted with declarative syntax rather than being formatted as C++ function calls.

Qt QML advanced declarative templates

The Qt pack also includes editable QML templates for advanced Controls, menus, toolbars, tab and swipe navigation, gestures, drag-and-drop, table and tree views, persistent QtCore.Settings, standard paths, asynchronous HTTP, WebSockets, WorkerScript, local SQLite storage, Canvas drawing, vector shapes, and shader effects. Declarative QML syntax is preserved throughout the generated snippets.

JC Lib 0.5.4 — C structured pack phase 1

The C pack now has a standalone data/c_language_pack.json route, matching the C++ and Qt generation strategy. The first C refactor phase adds a Basic category for control flow, operators, bit masks, declarations, pointers, functions, preprocessor and error handling, plus structured ANSI C library calls for stdio, string/memory, stdlib, ctype, math and time APIs.

JC Lib 0.5.5 — C structured pack phase 2

The C standalone pack now exposes advanced ISO C and C11 forms for stream state, scanning, variadic formatting, strings, tokenization, conversions, locale, signals, portable integer macros, complex numbers, atomics, threads, mutexes and condition variables. The standalone data/c_language_pack.json route remains synchronized with the bundled default pack.

JC Lib 0.5.6 — C structured pack phase 3

The C pack now exposes direct POSIX and Win32 system APIs for files, processes, IPC, sockets, native threads, synchronization and shared libraries. Historical end-to-end snippets are preserved inside detailed descriptions while direct visual forms provide typed parameters, return values, selectors and path browsers.

JC Lib 0.5.8 — C structured pack phase 4

The C pack now exposes embedded and low-level forms for explicit binary serialization, MMIO registers, ring buffers, CRC helpers, POSIX UART, Windows COM ports, Linux ioctl buses, ISR-safe flags and compiler portability attributes.

JC Lib 0.5.9 — generated C pack hierarchy and return-value fix

The bundled structured-pack importer now preserves the actual JSON category hierarchy instead of allowing stale per-entry metadata to flatten the generated tree. Parameterized direct calls such as strtod({{nptr}}, {{endptr}}) also retain their real return type, support assignment targets and generate terminated C statements. Existing generated workspace or global packs must be removed and recreated after installation.

JC Lib 0.6.0 — C third-party libraries and Linux event integration

The standalone C pack now exposes direct visual forms for cJSON, Jansson, libcurl, HIDAPI, libusb, inotify, epoll, eventfd and timerfd. Historical end-to-end snippets remain attached to the direct calls as detailed workflow examples. The generated C language pack route still imports Standard and C Language while keeping DLL helpers separate.

JC Lib 0.6.1 — C runtime services, SQLite and reliability helpers

The standalone C pack now exposes direct visual forms for POSIX and Windows runtime paths, environment variables, CLI parsing with getopt_long, SQLite prepared statements, the inih INI parser, advanced local-socket helpers, additional libcurl options, syslog, debugger hooks, checked-size arithmetic, and POSIX timers. The corrected generated-pack hierarchy and return-value forms remain covered by regression tests.

JC Lib 0.6.2 — C compression, regex, OpenSSL digest and TLS helpers

The standalone C pack now exposes direct visual forms for POSIX regex/glob/fnmatch, zlib memory and gzip APIs, OpenSSL EVP hashing and Base64 helpers, cryptographically secure random bytes, and a version-flexible OpenSSL TLS client lifecycle.

JC Lib 0.7.0 — Python structured refactor phase 2

The standalone Python pack now exposes editable Python-native forms for control flow, exceptions, comprehensions, functions, classes, operators, list/dict/set methods, strings, open, pathlib, JSON serialization, regex, context managers, command-line parsing, logging, collections, itertools, heaps, filesystem services, CSV, INI, archives, datetime, clocks, time zones and subprocesses. Python direct calls are rendered without artificial C-style semicolons, while None return types do not display an assignment target.

JC Lib 0.6.5 — unified C library navigation

The generated C pack now contains one C Language library. The former separate Standard library is available under C Language / Standard Library, and duplicate example-only snippets have been folded into the detailed descriptions of their corresponding structured entries.

JC Lib 0.6.6 — C quality audit and timer cleanup

The C pack navigation was audited against the C++ pack quality baseline. The timer branch is now focused on structured POSIX and Win32 APIs, obsolete delay notes have been removed, overlapping callback and pointer examples have been folded into detailed descriptions, and misplaced device-I/O workflows have been relocated.

JC Lib 0.6.7 — Visual Pack Editor large-pack render fix

The Visual Pack Editor now loads large packs lazily instead of expanding the complete tree during the first render. A webview-script escaping regression that could leave the editor blank has been fixed, stale expanded-tree UI state is invalidated, pack and library summaries are capped at 120 visible symbols, and a regression script executes the generated inline editor against the complete C pack.

JC Lib 0.6.8 — C navigation audit

The C pack navigation was simplified again after the Visual Pack Editor repair. Project skeletons, keyword groups, preprocessor probes, and compatibility keywords now live under C Language -> Basic; redundant standalone notes are folded into detailed descriptions; and structure-copy examples are grouped with memory ownership.

JC Lib 0.6.9 — C canonical normalizer fix

The runtime normalizer now recognizes the audited C hierarchy as canonical. Basic, Standard Library, and Time, Timers & Delays are no longer rerouted into Snippets & Project Skeletons / Legacy imported entries when a C pack is generated. Same-name symbols are deduplicated only inside the exact destination group, so third-party APIs such as Jansson and json-c can coexist.

JC Lib 0.7.1 — Python structured refactor phase 3

The standalone Python pack now also exposes editable Python-native forms for asyncio, threads, synchronized queues, futures, process shared memory, sockets, selectors, TLS contexts, standard-library HTTP requests, Requests, HTTPX, pickle, Base64, XML, SQLite, pytest, unittest, logging handlers and profiling. Historical workflows remain available in the detailed descriptions of the corresponding direct APIs.

JC Lib 0.7.2 — Python scientific and data-analysis structured refactor phase 4

The standalone Python pack now also exposes editable Python-native forms for NumPy arrays, FFT helpers, linear algebra, SciPy filtering, spectral analysis, ODE integration, interpolation, optimization, WAV I/O, pandas dataframes and time-series operations, and Matplotlib figures. Historical scientific workflows remain available in the detailed descriptions of their canonical direct APIs.

JC Lib 0.7.3 — Python quality audit phase 5

The standalone Python pack now exposes direct editable calls for mmap, struct, YAML, TOML, glob, POSIX file locks, platform metadata, signals, ctypes, statistics, sparse SciPy matrices and SymPy. Redundant workflow-only entries have been folded into the detailed descriptions of their canonical fiches while Python-native rendering remains unchanged.

JC Lib 0.7.4 — Python device-I/O quality audit phase 6

The standalone Python pack now exposes editable Python-native direct calls for pySerial, PyVISA, python-can, Bleak BLE, hidapi, PyUSB, smbus2 and spidev. Redundant device-I/O workflows are folded into the detailed descriptions of their canonical fiches so the navigation tree remains compact while preserving complete examples.

JC Lib 0.7.5 — Python GUI, HMI and dashboards audit phase 7

The standalone Python pack now exposes direct GUI and HMI forms for Tkinter, PySide6 / PyQt6, embedded plotting widgets, Streamlit, Dash, NiceGUI, FastAPI WebSocket helpers and thread-safe HMI patterns. Historical GUI recipes remain attached to canonical direct entries as detailed documentation.

JC Lib 0.7.6 — Python AI, vision and model-deployment audit phase 8

The standalone Python pack now exposes editable direct forms for ONNX Runtime, OpenCV, PyTorch, scikit-learn, TensorFlow / Keras, TensorFlow Lite and MLflow. Model paths, image paths, checkpoints and artifacts use file-browser metadata where appropriate. Workflow-oriented examples remain available in detailed descriptions without cluttering the navigation tree.

JC Lib 0.7.7 — Python automation, test benches and robotics audit phase 9

The standalone Python pack now exposes direct editable forms for distributed acquisition servers, Ray, ZeroMQ, cocotb, pyvcd waveform generation, calibration lookup tables, Excel report generation, realtime acquisition primitives, ROS 2 rclpy, pytest fixtures and reusable test-bench helpers. Historical bench recipes remain attached to canonical direct entries as detailed documentation, and duplicate queue navigation entries have been consolidated.

JC Lib 0.7.8 — Python data analysis, visualization and notebooks audit phase 10

The standalone Python pack now exposes direct editable forms for Dask DataFrame, DuckDB, Polars lazy pipelines, PyArrow datasets and scanners, SQLAlchemy, pandas SQL export and validation, IPython display helpers, ipywidgets, papermill and notebook run configuration. Historical recipes remain attached to canonical entries as detailed documentation. The old virtual-environment shell recipe has also been replaced with Python-native venv.EnvBuilder forms.

JC Lib 0.7.9 — Python networking, web APIs and industrial protocols audit phase 11

The standalone Python pack now exposes direct editable forms for FastAPI, Starlette static files and streaming responses, Pydantic API schemas, Flask, HTTPX, aiohttp, the current websockets.asyncio implementation, asyncua OPC UA, Eclipse Paho MQTT and PyModbus. The PyModbus fiches use the current device_id keyword. Historical HTTP, WebSocket and industrial-protocol recipes remain attached to canonical entries as detailed documentation.

JC Lib 0.7.10 — Python signal processing, control and instrumentation audit phase 12

The standalone Python pack now exposes editable direct forms for SciPy state-space models, continuous and discrete simulation, discretization, frequency-response helpers, pole placement, coherence and cross-spectral density. It also adds the modern ShortTimeFFT API, focused NumPy feature helpers, scikit-learn DSP diagnostics, random forests and PyWavelets denoising primitives. Historical DSP, ONNX and serial-instrument recipes remain attached to canonical entries as detailed documentation. Procedural STFT helpers stay available for compatibility but point new code toward ShortTimeFFT.

JC Lib 0.7.11 — Python residual direct-API normalization phase 13

The remaining Python snippets were audited globally after the focused library refactors. Twelve workflow-only entries are now represented by editable direct APIs for Tenacity, gpiozero, PyFtdi, RPi.GPIO, CFFI, dataclass serialization, SQLAlchemy ORM and importlib.resources. The 108 retained snippets are deliberate syntax examples, architecture patterns, commands or configuration templates rather than unprocessed API calls.

Windows API / Devices guided selectors

The Windows API / Devices pack provides documented advanced selectors for Win32 bitmasks and common finite-value constants. Bitmask pickers combine compatible flags with |, while single-choice pickers expose API constants with contextual descriptions. The Visual Pack Editor validates case-sensitive C symbols correctly, so legitimate Win32 pairs such as ChooseColor and CHOOSECOLOR do not produce false duplicate warnings.

Windows threads and window automation

The Windows API / Devices pack includes native Kernel32 thread and synchronization helpers, User32 window-discovery functions such as FindWindowA/W, FindWindowExA/W, EnumWindows, GetParent, GetAncestor, and structured BM_CLICK helpers for standard Win32 buttons. Custom UI frameworks may require Microsoft UI Automation instead of HWND-based messages.

Winuser window-control coverage

The Windows API / Devices pack now includes guided cards for window styles and placement, coordinate mapping, cursor capture, standard control messages, synthetic input with SendInput, hotkeys, hooks, menus, scrollbars, monitors and process inspection associated with discovered HWND handles. SendInput is subject to UIPI and standard-control messages are not a replacement for Microsoft UI Automation on custom UI frameworks.

Specialized winuser.h coverage

The Windows API / Devices pack now includes guided cards for DPI awareness, window properties, window stations and desktops, scroll descriptors, cursor and icon resources, foreground and GUI-thread diagnostics, touch and pointer input, and hook callback structures. Desktop switching and cross-process property changes are subject to access checks, session boundaries and UIPI.

Windows system-integration APIs

The Windows API / Devices pack now includes clipboard-change notifications, shell notification-area icons, terminal-services session notifications, access-token and privilege helpers, and Service Control Manager operations. These APIs are security-sensitive: request the smallest access masks required, release allocated memory and handles, and check session boundaries and privilege assignment results.

Windows registry, IPC and hardware notifications

The Windows API / Devices pack includes structured registry access, classic event logging, named pipes, advanced process creation and Toolhelp enumeration, plus targeted device and power-setting notifications. Paths exposed by these APIs use the native file or folder browser when applicable.

Windows files, shared memory and system helpers

The Windows API / Devices pack includes structured file and directory operations, simple and detailed directory monitoring, mapped files or paging-file-backed shared memory, named synchronization objects, system information, high-resolution timing and power-state helpers. Applicable file and folder parameters open native path browsers.

Windows diagnostics, Winsock2, serial and WinUSB helpers

The Windows API / Devices pack includes structured Win32 last-error formatting, debug output, application-oriented minidump generation, native Winsock2 initialization and socket lifecycles, extended serial-port configuration and diagnostics, modern SetupAPI property inspection, and WinUSB endpoint recovery / policy helpers. The current-process minidump recipe exposes a native file browser for its destination path.

Windows industrial-system closure helpers

The Windows API / Devices pack now includes secure dynamic-library loading, environment-variable helpers, logical-drive and volume inspection, mailslots, supervised child-process groups through job objects, IP Helper adapter / route monitoring, ICMP reachability, and PSAPI process / module inspection. Relevant DLL, directory and volume parameters use the JC Lib native path browser.

Python documented advanced parameter choices

The standalone Python pack now uses documented advanced selectors for genuine multi-choice parameters. File modes, encodings, regular-expression flags, socket families, serial framing, CAN backends, scientific modes, plotting options, dataframe policies, OpenCV constants, model settings, Tkinter layout values, ZeroMQ socket types and pytest fixture scopes expose contextual descriptions in the advanced popup. Native boolean fields remain compact boolean editors instead of displaying redundant False / True lists. Compatible masks such as re flags, selector readiness events and selected ZeroMQ send flags support multi-selection. See docs/PYTHON_ADVANCED_PARAMETER_CHOICES_AUDIT_PHASE15.md.

Build & Toolchains structured pack

JC Lib 0.7.42 adds data/build_pack.json, a structured build-tool pack covering CMake, CTest, CPack, GCC, G++, Clang, LLVM, MinGW, MSVC Build Tools, Make, Ninja, pkg-config, vcpkg and Conan. Build commands expose documented parameters, advanced selectors, safe multi-option composition and file or directory browsers where appropriate.

Specialized Build tooling — phase 2

JC Lib 0.7.43 extends the standalone Build pack to 1.1.0 with CMake toolchain files, linker-script templates, GNU Binutils, Arm GNU cross-compilation helpers, GDB, LLDB, GCC and LLVM coverage workflows, cppcheck, Doxygen, MSBuild diagnostics and CI skeletons. The Build menu adds dedicated cross-toolchain and quality-tool routes while keeping the full Build bundle deduplicated.

JavaScript / Web structured direct API pack

JC Lib 0.7.44 upgrades data/web_language_pack.json to version 1.1.0. The existing contextual recipes remain available, while a structured direct layer now covers JavaScript operators and built-ins, DOM and events, Fetch, storage, workers, realtime APIs, Canvas, HTML, CSS, Node.js, Express, npm, Vite and test tooling.

JavaScript / Web frameworks and specialized browser APIs

JC Lib 0.7.45 upgrades data/web_language_pack.json to version 1.2.0. The second Web pass adds direct parameterized cards for React, Vue, Svelte, Web Components, Service Workers, CacheStorage, IndexedDB, WebGL, Electron and VS Code webviews while retaining the original contextual recipes.

JC Lib 0.7.46 — Web quality reorganization

JC Lib 0.7.46 upgrades data/web_language_pack.json to 1.3.0. The Web pack now separates direct JavaScript cards into operators, objects, arrays, strings, regular expressions, numbers, JSON, dates and module declarations. Redundant elementary snippets have been removed while architectural recipes remain available in groups explicitly labelled Recipes — .... DOM, HTML, CSS, Node.js and Express direct cards are also grouped by responsibility.

JC Lib 0.7.47 — TypeScript structured quality audit

JC Lib 0.7.47 upgrades data/typescript_language_pack.json to 1.1.0. The TypeScript pack now exposes structured direct cards for the language type system, narrowing, generics, modules, strict TSConfig, typed browser APIs, frameworks, Node.js, backend validation, testing, build tooling, desktop bridges and device I/O. Contextual recipes remain available in groups labelled Recipes — ....

JC Lib 0.7.48 — TypeScript advanced ecosystem audit

JC Lib 0.7.48 upgrades the TypeScript pack to 1.2.0. The second pass adds advanced type transformations, RxJS, Angular modern APIs, NestJS, Prisma, typed environment configuration, pnpm workspaces and library publishing helpers while preserving contextual recipes separately.

JC Lib 0.7.49 — Database structured quality audit

JC Lib 0.7.49 upgrades data/database_pack.json to 1.1.0. The Database pack now separates parameterized direct SQL, NoSQL and CLI cards from contextual recipes. Structured cards cover relational schema and DML statements, SQLite PRAGMAs and CLI operations, PostgreSQL, MySQL/MariaDB, SQL Server sqlcmd, DuckDB file analytics, MongoDB CRUD and change streams, and Redis cache, queue, stream and ACL commands.

JC Lib 0.7.50 — Database clients, ORM and operations audit

JC Lib 0.7.50 upgrades data/database_pack.json to 1.2.0. The Database pack now includes direct SQLite3 C, PostgreSQL libpq, MySQL client C API, ODBC, SQLAlchemy/Alembic, hiredis and operational backup/replication helpers alongside the SQL and NoSQL layers.

JC Lib 0.7.51 — Kotlin structured quality audit

JC Lib 0.7.51 upgrades data/kotlin_language_pack.json to 1.1.0. The Kotlin pack now exposes direct parameterized cards for the language, standard library, collections, coroutines, Flow, filesystem, serialization, JDBC, Ktor, Compose, JVM tooling, Gradle and device integration. Contextual snippets remain available in explicit Recipes — groups.

JC Lib 0.7.52 — Kotlin advanced ecosystem audit

JC Lib 0.7.52 upgrades data/kotlin_language_pack.json to 1.2.0. The Kotlin pack now includes structured cards for KMP Gradle DSL, Kotlin/Native, Kotlin/Wasm, Android BLE, Room, SQLDelight, Spring Boot and Compose Multiplatform.

JC Lib 0.7.53 — PHP structured quality audit

JC Lib 0.7.53 upgrades data/php_language_pack.json to 1.1.0. The PHP pack now exposes direct parameterized cards for PHP 8.5 language features, arrays, functions, OOP, filesystem, streams, JSON, PDO, HTTP, security, sessions, CLI, Composer, testing, Laravel, Symfony, workers and WordPress. Contextual examples remain available in explicit Recipes — groups. File and folder parameters use native path browsers where a concrete filesystem target is expected.

JC Lib 0.7.54 — PHP advanced ecosystem audit

JC Lib 0.7.54 upgrades data/php_language_pack.json to 1.2.0. The second PHP pass adds structured direct cards for Doctrine ORM and DBAL, Doctrine migrations, Symfony dependency injection, Symfony Forms and Validator, Laravel API resources and Sanctum, WordPress administration and Settings API, WordPress AJAX, PHP-FPM pools, Nginx FastCGI, official PHP Docker images and Docker Compose operations. Elementary recipes replaced by direct cards are removed while architectural workflows remain available under explicit Recipes — groups.

C# 14 / .NET 10 structured pack

JC Lib 0.7.56 refactors the bundled C# pack into direct parameterized cards. The pack targets C# 14 and .NET 10, preserves contextual multi-step examples under Recipes —, exposes documented pickers for flags and policy values, and adds native file or folder browsers where a path is expected.

C# advanced ecosystem pass

JC Lib 0.7.58 expands the C# pack to version 1.2.0 with direct parameterized cards for EF Core advanced operations, Blazor, gRPC, SignalR, ASP.NET Core security, OpenTelemetry, integration testing, .NET MAUI, MVVM, WPF and WinUI.

Java 25 LTS structured refactor

JC Lib 0.7.58 restructures the Java pack into direct parameterized cards, documented selectors, native file and folder browsers, and contextual Recipes — groups. The production baseline is Java 25 LTS; a reference card distinguishes JDK 26 as the latest feature release.

Java advanced ecosystem pack 1.2.0

JC Lib 0.7.59 adds a second Java 25 LTS pass for Spring, RPC, messaging, observability, JVM diagnostics, desktop and Android Java workflows.

0.7.60 — Transversal pack audit and consistency fixes

• Audited all 20 distributed JSON packs with a cross-pack structural validator.
• Repaired stale environment/library/category metadata in Embedded, Qt and Web packs.
• Eliminated Vue template collisions with JC Lib {{parameter}} placeholders by using v-text.
• Removed exact duplicate C++ range/partition cards and the duplicated QML timer.restart card.
• Disambiguated the Jansson and json-c json_object_get cards.
• Made Python frame_signal parameters effective in the generated insertion text.
• Added an SDL3 migration reference while intentionally retaining the SDL2 pack target.
• Re-synchronized modified C, C++, Qt and SDL libraries into default_pack.json.

LabWindows/CVI structured API pack

JC Lib now distributes data/cvi_pack.json, replacing the historical CVI Helpers starter snippets with a structured catalog completed from the supplied CVI headers.

HTML optional-attributes picker

Every HTML attributes field keeps free-form editing and provides a structured multi-select popup for documented global attributes, custom data-* fragments, common ARIA metadata and inline event handlers. Element-specific attributes remain on the corresponding HTML cards.

ASP.NET Core Razor / CSHTML library

The C# pack is split into C# Language and ASP.NET Core Razor / CSHTML. The CSHTML library combines Razor syntax, layouts, reusable views, Tag Helpers and a complete configurable HTML element reference suitable for MVC views and Razor Pages.

CSS structured catalogue — 0.7.84

The CSS library is organized into selectors and cascade, box model, flexbox/grid, typography and visual styling, responsive interaction and modern features, plus reusable recipes and CSSWG references.

C and C++ DLL helper modernization — 0.7.85

The C and C++ DLL helper libraries now provide structured Windows loader APIs, secure DLL-search configuration, GetProcAddress name and ordinal lookup cards, POSIX dlopen equivalents, typed runtime-loading recipes and a configurable DllMain lifecycle-case picker.

DLL helper deduplication and DllMain preview fix — 0.7.86

The C, C++ and Win32 loader references now expose one configurable GetProcAddress card. Choose name or ordinal lookup from a guided selector; only the relevant parameter remains active. Configurable DllMain switch-case blocks now use a multiline editor and retain canonical lifecycle order. Direct Win32 and POSIX loader APIs are centralized in C DLL Helpers rather than duplicated inside the C language library.

CMake static runtime and shared-library configuration

The Build pack now separates BUILD_SHARED_LIBS, static archives, shared-library targets and compiler-runtime flags such as -static-libgcc. Project-defined -D switches remain editable and are labelled as project-specific examples.

Native Explorer split layout — 0.7.92

Clicking the JC Lib Activity Bar icon now opens VS Code's built-in Explorer and reveals the JC Lib Libraries view beneath the native workspace file explorer. The vertical separator is managed by VS Code and remains resizable. The launcher also clears any stale JC Lib tree filter before focusing the top-level environment.

LabWindows/CVI User Interface attribute menus — 0.7.93

The User interface library now exposes contextual menus for all 24 Set*Attribute helper cards. After selecting an ATTR_* constant, the value argument receives a second contextual picker: CVI boolean attributes use 1 / 0 with True / False labels, RGB attributes expose common CVI color constants, documented enumerations expose their VAL_* constants, and free numeric or textual expressions remain editable.

The catalog is derived from the distributed userint.h declarations and excludes entries explicitly marked not settable. NI's proprietary function-panel validity matrices are not present in the public header archives, so the generated lists are context-scoped helpers rather than a byte-for-byte extraction of the native CVI panel database. The concrete CVI control type still determines whether a given attribute is accepted at runtime.

CVI Basics callbacks and UI events — 0.7.94

The CVI pack includes a dedicated CVI Basics library beside User interface. It centralizes the base callback pointer prototypes declared by userint.h, configurable callback skeletons, the complete standard EVENT_* catalog from the CVI 2020 reference header, the related eventData1 specifiers and callback-installation recipes.

The panel, control and main callback skeletons expose multi-select event menus. Applying the selection generates editable switch (event) branches in canonical source order. The catalog retains compatibility notes for the three events present in the CVI 2020 header but absent from the supplied CVI 2012 archive: EVENT_RING_BEGIN_MENU, EVENT_TAB_PAGE_CLOSE and EVENT_MOUSE_WHEEL_CLICK.

CVI Basics structured selectors and CVIRTE lifecycle — 0.7.95

CVI Basics now uses compact parameterized cards instead of flat macro lists. The Events category contains one card per functional family. Each picker displays both the symbolic EVENT_* macro and its numeric value while inserting the symbolic name into source code. Callback pointer typedef cards expose editable formal parameter names directly in the details form. The library also exposes InitCVIRTE, InitCVIRTEEx, CVIRTEHasBeenDetached and CloseCVIRTE from cvirte.h.

CVI Basics consolidation — 0.7.96

The former CVI Patterns & References library has been folded into CVI Basics. The calling-convention markers CVICALLBACK and CVIFUNC now live in CVI Basics → Keywords. The compact UI examples and workflow recipes now live in CVI Basics → Examples / Workflows. This reduces the number of top-level CVI libraries without removing any reference content.

Folder-based snippet insertion

JC Lib includes an independent snippet browser for inserting reusable code fragments at the active cursor position. Run JC Lib: Insert Snippet From Folder Tree... or press Ctrl+Alt+I (Cmd+Alt+I on macOS). The picker first selects a source tree, then follows its directory hierarchy. For example, a personal tree containing C/Random/monSnippet.txt is displayed as C -> Random -> monSnippet.

Three trees are available:

• built-in snippets distributed under data/snippets;
• personal snippets stored globally for the current VS Code profile;
• workspace snippets stored by default under .vscode/jc-lib/snippets in the active project.

Run JC Lib: Manage Snippet Folders... to open these directories in the operating-system file explorer or save the current editor selection as a reusable file. The storage model deliberately remains folder-based: adding, renaming, moving or removing a snippet can be done directly with ordinary files and directories.

Two UTF-8 text formats are supported:

• .txt and normal source-code extensions are inserted literally. This is the safest format for manually maintained fragments and shell code containing $variables;
• .snippet is also plain text, but it enables VS Code snippet syntax such as ${1:name}, ${2|first,second|} and $0 for interactive tab stops.

The personal and workspace folders can be redirected from the jcLib.snippets.* settings. ${userHome} and ${workspaceFolder} variables are accepted in configured paths.

0.8.8

• Improved documentation helpers: wrapped header change lines, separator line and special text block generation.

0.8.9 - SDL2 / SDL3 pack and multi-select picker fix

• Fixes advanced multi-select pickers applied to enum/select fields. Combined bitmask values are now inserted into the field and preview.
• Adds separate SDL2 and SDL3 bundled packs plus a combined SDL2 / SDL3 route in Add Library Pack.
• Adds SDL3 window, renderer, events, texture, properties, snippets and SDL2-to-SDL3 migration helpers.

Color picker 0.8.11

The context menu command JC LIB → Utilities → Insert color value now includes solid RGB preview, alpha checkerboard preview, a synchronized alpha slider, and a brightness/value slider.

0.8.16

• Fixed the Character table / converter live update path by rebuilding the converter panel with a single switchable Text → values / Values → text card.
• Added static ASCII fallback rows so the reference table is populated immediately, even before the webview script refreshes.
• Improved ASCII / Latin-1 filtering and row counts.

0.8.15 - Character / encoding tools

Adds contextual character conversion tools and an ASCII/Latin-1 table with Unicode code point, UTF-8 and UTF-16 representations.

Number / bit tools

JC Lib includes a contextual number / bit converter available from JC LIB > Utilities > Number / bit tools. It supports decimal, hexadecimal, binary and octal conversion, signed two's-complement display, MSB/LSB binary views, bitwise operations, shifts, rotations, masks and byte-array experiments with array order, per-byte bit order and aggregate endian selection.

Truth table / FSM designer

JC LIB > Utilities > Logic / state tools > Open truth table / FSM designer opens an interactive helper for boolean truth tables, expected outputs, DNF/CNF expressions, C lookup tables, and Mealy/Moore state-machine skeletons.

Recent changes

• 0.8.22: improves the digital filter designer Bode/phase rendering, field tooltips, unit-circle diagnostics, and adds a second-order Jury stability triangle.