@octane-xplat/workshop 0.0.0-nightly.g2e22171

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Alec Larson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/MOBILE.md

@@ -0,0 +1,143 @@
+# Try a component in the mobile workshop
+
+The mobile workshop opens your stories in a separate NativeScript development
+entry. Its iOS and Android adapters are implemented and compiled, but **neither
+host is qualified yet**. Actual touch, keyboard, screen-reader, IME, reload and
+cleanup checks are still required before claiming mobile support.
+
+## Prepare your existing app
+
+Use an app that already runs Octane Xplat on iOS or Android. Keep its existing
+framework versions, NativeScript resources, styles and plugins. Install the
+workshop as a development dependency, then create a local counter story:
+
+```sh
+pnpm add -D @octane-xplat/workshop
+pnpm exec xplat workshop init
+```
+
+Wrap the result of your existing native Vite configuration with
+`withWorkshopMobile`. This preserves your renderer settings and plugins and
+places the workshop's reload hook before Octane's hook. In a standard scaffold,
+edit `vite.config.native.mts` like this; retain your app-specific options:
+
+```ts
+import { defineConfig } from 'vite'
+import { xplatNative } from '@octane-xplat/cli/vite'
+import { withWorkshopMobile } from '@octane-xplat/workshop/vite-mobile'
+
+export default defineConfig(async ({ mode }) => withWorkshopMobile(await xplatNative(mode)))
+```
+
+Your ordinary app entry remains the production entry. The wrapper does nothing
+unless the workshop launcher supplies a mobile target. Keep stories outside
+production imports; check your production bundle rather than relying on their
+filename alone.
+
+```sh
+# Your existing production build remains unchanged.
+pnpm exec ns build android
+```
+
+## Select one real host
+
+Run Doctor inside the app. It reads package/configuration and SDK-directory
+prerequisites without booting a device. `unqualified-backend` means the launch
+setup is present, not that a host acceptance check passed. SDK-directory checks
+are preliminary; the NativeScript launch reports invalid SDK/toolchain setup.
+
+```sh
+pnpm exec xplat workshop doctor --json
+pnpm exec xplat workshop list --target ios
+pnpm exec xplat workshop list --target android
+```
+
+When you are authorized to use an actual host, supply its device ID explicitly.
+iOS requires a macOS/Xcode host; Android requires a configured Android SDK and
+compatible Java installation. The launcher uses the app's installed NativeScript
+CLI and development-session reload loop. Replace the sample IDs below with the
+IDs of your authorized devices; NativeScript may start the selected device.
+
+```sh
+pnpm exec xplat workshop dev --target ios --device YOUR_IOS_DEVICE_ID --story workshop/counter-basic
+pnpm exec xplat workshop dev --target android --device YOUR_ANDROID_DEVICE_ID --story workshop/counter-basic
+```
+
+Select **Workshop / Counter**, then press **Increment**. Open **Controls**, edit
+`step`, and press **Apply step**. Closing the panel returns to the same story.
+Back or hardware Escape closes an open panel, then exits stage-only view, and
+only then leaves the workshop to the host. **Reset** rebuilds its props, store
+and fixture from defaults. Save a story or component to request a fresh
+revision. A failed edit keeps the previous stage marked **STALE**; correcting
+the source requests another revision.
+
+```ts
+// Source edit in the story created by init:
+args: { step: 2 },
+```
+
+## Providers, styles and story collections
+
+The shared authoring contract is still version 1. Use the same story IDs,
+controls, fixture cancellation and cleanup as described in the
+[package guide](README.md). Global providers are configured in the consumer's
+workshop configuration and wrap story-specific providers in declaration order:
+
+```ts
+import { defineWorkshopConfig } from '@octane-xplat/workshop'
+export default defineWorkshopConfig({
+	providerModules: ['./src/demo-providers.tsrx'],
+	stories: { include: ['src/**/*.stories.tsrx'] },
+})
+```
+
+The workshop preserves the native build configuration, but does not execute your
+production entry's side effects. Import app styles and initialize required
+plugins in a development provider module. Provider and story components need
+the consumer's matching NativeScript compiler rules. Collections outside
+`src/**` or workspace `packages/**` need explicit renderer inclusion:
+
+```ts
+import { defineConfig } from 'vite'
+import { xplatNative } from '@octane-xplat/cli/vite'
+import { withWorkshopMobile } from '@octane-xplat/workshop/vite-mobile'
+export default defineConfig(async ({ mode }) =>
+	withWorkshopMobile(
+		await xplatNative(mode, {
+			rules: [
+				{ include: 'src/**/*.{ts,tsx,tsrx}', exclude: '**/*.web.*', renderer: 'nativescript' },
+				{ include: 'stories/**/*.{ts,tsx,tsrx}', exclude: '**/*.web.*', renderer: 'nativescript' },
+			],
+		}),
+	),
+)
+```
+
+## Qualification limits
+
+The shell keeps a single attached stage while switching phone, compact and wide
+layouts. Controls use explicit Apply actions to avoid applying unfinished text
+composition. NativeScript buttons, text fields and scroll views provide the shell
+surfaces; accessible names are implemented. Host Back and hardware Escape share
+one dismissal contract: an open stories/controls panel closes first (with a
+focus-return attempt to its opener), stage-only view exits next, and the key
+otherwise stays with the host or story. Android Back is the activity callback;
+hardware Escape uses the unhandled-key-event listener so a story view or IME
+composition that owns the key keeps it. iOS uses a page key command enabled
+only while a dismissal is available, routed to the accessibility escape hook —
+presented story modals keep priority — and requires the iOS 15 key-command API
+(older hosts keep the toolbar and accessibility-escape paths). Their actual
+accessibility, focus return, keyboard visibility, safe areas, IME and
+key-delivery behavior remain unverified on real hosts.
+
+The native adapter reuses the pinned portable Storybook composition subset and
+the shared session's preparation/disposal core, then mounts compiler-produced
+Octane components. The mobile Vite wrapper lowers Unicode-property regexes for
+the pinned native runtimes. Actual-host composition and compatibility
+qualification remain open. Browser manager/addon UI is excluded; the web
+adapter and private visual harness are unchanged.
+
+Native process crashes require a target restart. Module globals, permissions and
+external application resources are outside the story subtree; authors must
+register owned cleanup or use process-restart isolation. No runtime result,
+visual parity, or six-target completion is claimed by the source/packed checks.

package/README.md

@@ -0,0 +1,307 @@
+# @octane-xplat/workshop
+
+Render an app-owned component on its own development page, edit its inputs,
+and Reset to a fresh example. The current release provides real launch paths
+for three hosts: the **web** browser target, **macOS** through the real AppKit
+renderer on the JavaScriptCore NativeScript host, and **Linux** through the
+real GTK4/WebKitGTK webview host on a Linux machine. Authoring contract
+version: **1**.
+
+[iOS/Android launch setup](MOBILE.md) and native adapters are implemented,
+but iOS, Android and Windows remain unqualified backends — `xplat workshop
+doctor` reports them honestly. Keyboard and browser accessibility semantics
+have regression coverage; actual screen-reader announcements and OS IME input
+still require qualification on every host. On macOS, scripted interaction
+dispatches through each view's real recognizer or control action — it is not
+OS-synthesized input or hit-testing. On Linux, the GJS window, GTK input/focus
+and WebKitGTK reload semantics remain actual-Linux-host gates.
+
+For Windows prerequisite reporting and the blocked native launch, see
+[Windows workshop setup status](WINDOWS.md). Windows mounting and interaction
+remain incomplete; setup checks do not qualify that host.
+
+## Try it
+
+Inside an existing Octane Xplat app, install the development tooling. Keep the
+app's existing matching Octane/compiler versions; the app template already
+provides Octane's compiler peers, including `@tsrx/oxc`.
+
+```sh
+pnpm add -D @octane-xplat/workshop @octane-xplat/cli @octanejs/vite-plugin vite
+pnpm exec xplat workshop init
+pnpm exec xplat workshop dev --target web
+```
+
+Open the printed URL and choose **Workshop / Counter**. Press **Increment**:
+the count increases. Change **step**, leave the field, and press again. **Reset**
+restores the initial count and step.
+
+Initialization creates `workshop.config.ts`, a local example story, and an
+optional package script. Existing files and app entries remain intact. Run it
+again to check that the configuration is already present.
+
+```sh
+pnpm exec xplat workshop init
+pnpm exec xplat workshop doctor
+pnpm exec xplat workshop list
+```
+
+## Declaring stories
+
+A story is a named example of your component. Save this in
+`src/counter.stories.tsrx`; `args` supplies its initial inputs, and the controls
+form edits only the declared portable prop values.
+
+```tsx
+import { Pressable, Text } from '@octane-xplat/ui'
+import { useStore, type Store } from '@octane-xplat/ui/data'
+import { defineStory } from '@octane-xplat/workshop'
+
+type Props = { step: number; label?: string }
+type State = { count: number }
+type Fixture = { account: string }
+
+function Counter(p: Props & { state: Store<State>; fixture: Fixture }) {
+	const { count } = useStore(p.state)
+	return (
+		<Pressable
+			accessibilityLabel="Increment"
+			onPress={() => p.state.set((s) => ({ count: s.count + p.step }))}
+		>
+			<Text>
+				{p.label ?? p.fixture.account}: {count}
+			</Text>
+		</Pressable>
+	)
+}
+
+export const Basic = defineStory<Props, State, Fixture>({
+	id: 'counter/basic',
+	title: 'Examples / Counter',
+	targets: 'all',
+	component: Counter,
+	args: { step: 1 },
+	controls: {
+		step: { type: 'number', min: 1, max: 10 },
+		label: { type: 'string', allowUnset: true },
+	},
+	state: () => ({ count: 0 }),
+	fixture: () => ({ account: 'Demo' }),
+})
+```
+
+IDs address stories across reloads. Metadata must be literal: discovery reads
+it without evaluating the story or importing an incompatible platform leaf.
+Computed metadata and duplicate IDs produce catalog diagnostics. Use literal
+strings without escape sequences and literal arrays without expression suffixes.
+
+```ts
+// Inside the Basic declaration above:
+id: 'counter/basic',
+title: 'Examples / Counter',
+targets: ['web', 'ios'],
+```
+
+`state` and `fixture` are reserved prop names. The runner supplies a fresh store
+and resolved fixture for each generation; return new nested data from factories.
+The native readers of a store must subscribe with `useStore`, as Counter does.
+
+```ts
+// Inside the Basic declaration:
+state: () => ({ count: 0 }),
+fixture: () => ({ account: 'Demo' }),
+```
+
+## State-preserving controls vs. full reset
+
+Control edits keep the current fixture, providers, store and component-local
+state. **Unset** removes an optional value; required props cannot be unset.
+Empty, non-finite or out-of-range numbers show a field error and keep the last
+valid stage value. **Reset** creates a fresh complete generation.
+
+```ts
+// Inside the Basic declaration:
+controls: {
+	step: { type: 'number', min: 1, max: 10 },
+	label: { type: 'string', allowUnset: true },
+},
+```
+
+## Owned fixture resources
+
+Register cleanup as soon as a fixture acquires a resource. Preparation has a
+10-second default budget. Rejection offers Retry/Reset; cancellation prevents
+stale content mounting. Cleanup starts in reverse registration order, attempts
+all entries, and awaits the combined result before another generation. A hung
+or rejected cleanup requires target restart, including failures in late cleanup.
+
+```ts
+// Replace Basic's fixture factory with this local timer example:
+fixture: ({ signal, onCleanup }) => {
+	const timer = setInterval(() => {
+		if (!signal.aborted) console.log('Demo fixture is active')
+	}, 1000)
+	onCleanup(() => clearInterval(timer))
+	return { account: 'Demo' }
+},
+```
+
+Providers wrap the compiled component; global presets wrap story-specific
+providers. Each owned secondary root needs the same explicit provider data and
+its own registered cleanup. The maintained
+[isolation example](../../apps/workshop-demo/src/stories/isolation.stories.web.tsrx)
+shows an actual secondary Octane root, shared provider store, and disposal.
+
+```tsx
+function DemoProvider(p: { fixture: Fixture; children?: unknown }) {
+	return p.children
+}
+// Inside the Basic declaration:
+providers: [DemoProvider],
+```
+
+Stories do not sandbox imported module globals, external stores or OS resources.
+If those cannot recover cleanly, stop and restart the development target.
+
+```sh
+# Stop the running development command with Ctrl+C, then:
+pnpm exec xplat workshop dev --target web --story counter/basic
+```
+
+## Linux host
+
+On a Linux machine the workshop opens inside the real GTK4/WebKitGTK webview,
+not a browser tab. The command starts the same development server, then launches
+the GJS host shipped in `@octane-xplat/cli` at its URL. Closing the window stops
+the server; stopping the command closes the window.
+
+```sh
+pnpm exec xplat workshop dev --target linux
+pnpm exec xplat workshop dev --target linux --story counter/basic
+```
+
+The launch needs `gjs` plus the GTK4, WebKitGTK 6.0 and Adwaita typelibs (on
+Debian/Ubuntu: `gjs libgtk-4-1 libadwaita-1-0 libwebkitgtk-6.0-4
+gir1.2-webkit-6.0 gir1.2-adw-1`). `xplat workshop doctor` probes them without
+opening a window. On any other OS the row reads `remote-host-required` — run
+the same commands in the Linux host's own checkout rather than bridging
+remotely. Linux resolves `.linux` leaves ahead of `.web` and shared modules,
+matching the consumer app's Linux build; a story listing `linux` under
+`targets` mounts, while foreign leaves stay out of the bundle.
+
+## Platform-leaf filtering
+
+A platform-suffixed declaration has no loader on an incompatible target.
+It stays visible with its reason. Required capabilities are currently
+unknown/unqualified in this preview and cannot silently become supported.
+
+```ts
+// A story saved in counter.stories.ios.tsrx:
+id: 'counter/ios-only',
+title: 'Examples / iOS counter',
+targets: ['ios'],
+```
+
+## Shell
+
+Search by title or ID. Wide windows show catalog, stage and controls; narrower
+windows open Stories or Controls separately. Escape closes a workshop panel and
+restores its opener. Composition Enter does not apply a draft. Stage-only mode
+keeps an accessible return/Reset action. Environment background and bounds are
+preview settings, separate from component props; changing them keeps the session.
+The target menu lists all six real host statuses without simulating a host.
+
+```sh
+pnpm exec xplat workshop dev --target web --story counter/basic
+```
+
+## Save and reload
+
+Saving component or story source remounts the selected story with its default
+inputs. Search and shell settings remain. A failed edit leaves the last good
+stage visibly stale; correcting it restores a fresh successful revision.
+
+```sh
+# Keep this command running while saving src/counter.stories.tsrx:
+pnpm exec xplat workshop dev --target web --story counter/basic
+```
+
+The DOM-host adapter uses the pinned Storybook 10.6.1 `composeStory` subset
+already used by the private visual harness. Octane owns rendering; workshop
+owns cancellation, fixture/provider lifetime and reset. Arbitrary CSF addons
+are outside this supported subset. Web and Linux share the same DOM shell and
+save/remount wiring; WebKitGTK input, focus and reload semantics still need
+actual-Linux-host qualification. Other native composition imports need their
+own host qualification.
+
+## macOS target
+
+The `macos` target runs the same catalog and session in a small AppKit shell on
+the real JavaScriptCore/NativeScript host — the same runtime `xplat dev` uses
+for packaged macOS apps. It needs a macOS arm64 machine and the app's matching
+macOS dependencies (`@octane-xplat/macos-renderer` and
+`@nativescript/macos-node-api`). Story windows and sheets opened through `openWindow` or
+`mountSheet` are workshop-owned and close when the story generation retires.
+
+```sh
+pnpm exec xplat workshop dev --target macos
+```
+
+Set `OCTANE_WORKSHOP_OFFSCREEN=1` to run the window without desktop focus, and
+`OCTANE_MACOS_AUTOMATION=1` to enable the stdin qualification protocol
+(`catalog`, `select`, `control`, `unset`, `press`, `reset`, `query`, `panel`,
+`stage-only`, `status`, `close`).
+
+## Commands
+
+Run these from the consuming package, rather than the monorepo root.
+
+```sh
+pnpm exec xplat workshop init
+pnpm exec xplat workshop doctor
+pnpm exec xplat workshop list
+pnpm exec xplat workshop dev --target web --story counter/basic
+```
+
+Configure includes/excludes, global provider modules and static assets explicitly.
+Relative provider and asset paths resolve from the consuming app.
+
+```ts
+import { defineWorkshopConfig } from '@octane-xplat/workshop'
+
+export default defineWorkshopConfig({
+	stories: { include: ['src/**/*.stories.tsrx', 'src/**/*.stories.web.tsrx'] },
+	assets: { examples: './public' },
+})
+```
+
+## Production exclusion
+
+Keep stories out of the production app's imports. The workshop creates a separate
+development page and does not replace the app's production entry. Build the
+ordinary app to ship it; installing workshop as a development dependency alone
+does not exclude a story explicitly imported by production code.
+
+```sh
+pnpm run build
+```
+
+For repository maintainers, the packed regression compiles source in an external consumer,
+runs the same browser acceptance catalog, measures warm HMR, and checks a normal
+production bundle for story/fixture/workshop markers. Generate dependency declarations first.
+
+```sh
+pnpm --filter @octane-xplat/lib typegen
+pnpm --filter @octane-xplat/ui typegen
+pnpm --filter @octane-xplat/workshop typegen
+pnpm --filter @octane-xplat/workshop test
+pnpm --filter @octane-xplat/workshop test:packed
+pnpm --filter @octane-xplat/workshop test:packed:linux
+```
+
+The packed checks compile the published source with the consumer's toolchain.
+They use headless Chromium and capture no images.
+The Linux packed check verifies packed export resolution, catalog applicability,
+the production linux server wiring and production-build exclusion in a plain
+DOM — the GJS window, GTK input/focus and WebKitGTK reload remain actual-host
+gates that no DOM check substitutes for.

package/dist/node/index.js

@@ -0,0 +1,50 @@
+//#region src/contract.ts
+var WORKSHOP_TARGETS = [
+	"web",
+	"ios",
+	"android",
+	"macos",
+	"windows",
+	"linux"
+];
+/** Version of the authoring contract — bumped on breaking changes. */
+var WORKSHOP_CONTRACT_VERSION = 1;
+/** Declare a story. Validates cheap authoring rules eagerly. */
+function defineStory(definition) {
+	assertLiteralAuthoring(definition);
+	return definition;
+}
+function assertLiteralAuthoring(definition) {
+	const fail = (message) => {
+		throw new Error(`defineStory: ${message}`);
+	};
+	if (typeof definition?.id !== "string" || !definition.id) fail("a story requires a non-empty string id");
+	if (typeof definition.title !== "string" || !definition.title) fail(`story "${definition.id}" requires a non-empty string title`);
+	const targets = definition.targets;
+	if (!(targets === "all" || Array.isArray(targets) && targets.length > 0 && targets.every((t) => WORKSHOP_TARGETS.includes(t)))) fail(`story "${definition.id}" — targets must be 'all' or a subset of: ${WORKSHOP_TARGETS.join(", ")}`);
+	if (typeof definition.component !== "function") fail(`story "${definition.id}" — component must be an Octane component`);
+	if (definition.args == null || typeof definition.args !== "object") fail(`story "${definition.id}" — args must be an object`);
+	if ("state" in definition && typeof definition.state !== "function") fail(`story "${definition.id}" — state must be a factory function`);
+	if ("fixture" in definition && typeof definition.fixture !== "function") fail(`story "${definition.id}" — fixture must be a factory function`);
+	if (definition.args && typeof definition.args === "object") {
+		for (const key of ["state", "fixture"]) if (key in definition.args) fail(`story "${definition.id}" — args may not declare reserved injected prop "${key}"`);
+	}
+	if (definition.controls) for (const [key, control] of Object.entries(definition.controls)) {
+		if (!control || typeof control !== "object") fail(`story "${definition.id}" — control "${key}" must be an object`);
+		const type = control.type;
+		if (![
+			"boolean",
+			"string",
+			"number",
+			"enum"
+		].includes(type ?? "")) fail(`story "${definition.id}" — control "${key}" has unknown type "${type}" (expected boolean, string, number or enum)`);
+		if (type === "enum" && !Array.isArray(control.options)) fail(`story "${definition.id}" — enum control "${key}" requires an options array`);
+		if (type === "number" && typeof control.min === "number" && typeof control.max === "number" && control.min > control.max) fail(`story "${definition.id}" — number control "${key}" has min > max`);
+	}
+	if (definition.providers !== void 0 && !Array.isArray(definition.providers)) fail(`story "${definition.id}" — providers must be an array`);
+}
+function defineWorkshopConfig(config) {
+	return config;
+}
+//#endregion
+export { WORKSHOP_CONTRACT_VERSION, WORKSHOP_TARGETS, defineStory, defineWorkshopConfig };

package/package.json

@@ -0,0 +1,127 @@
+{
+  "name": "@octane-xplat/workshop",
+  "version": "0.0.0-nightly.g2e22171",
+  "description": "Development-only component workshop for Octane Xplat — typed stories, metadata discovery, adaptive shell, lifecycle and warm reload",
+  "keywords": [
+    "components",
+    "cross-platform",
+    "dev-tools",
+    "octane",
+    "stories",
+    "storybook",
+    "workshop",
+    "xplat"
+  ],
+  "homepage": "https://github.com/octane-xplat/octane-xplat/tree/main/packages/workshop",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/octane-xplat/octane-xplat",
+    "directory": "packages/workshop"
+  },
+  "files": [
+    "types",
+    "dist/node",
+    "src",
+    "MOBILE.md",
+    "!src/**/*.test.*",
+    "!src/**/*.spec.*"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./types/generated/index.d.ts",
+      "node": "./dist/node/index.js",
+      "default": "./src/index.ts"
+    },
+    "./web": {
+      "types": "./types/generated/web/index.web.d.ts",
+      "default": "./src/web/index.web.ts"
+    },
+    "./vite": {
+      "types": "./src/vite.d.ts",
+      "default": "./src/vite.mjs"
+    },
+    "./node": {
+      "types": "./src/node.d.ts",
+      "default": "./src/node.mjs"
+    },
+    "./package.json": "./package.json",
+    "./mobile": {
+      "types": "./types/generated/mobile/index.mobile.d.ts",
+      "default": "./src/mobile/index.mobile.ts"
+    },
+    "./vite-mobile": {
+      "types": "./src/vite-mobile.d.ts",
+      "default": "./src/vite-mobile.mjs"
+    },
+    "./macos": {
+      "types": "./types/generated/macos/index.macos.d.ts",
+      "default": "./src/macos/index.macos.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@babel/core": "7.29.7",
+    "@babel/plugin-transform-unicode-property-regex": "7.29.7",
+    "@octane-xplat/cli": "0.0.0-nightly.g2e22171",
+    "@octane-xplat/platform": "0.0.0-nightly.g2e22171",
+    "@octane-xplat/ui": "0.0.0-nightly.g2e22171",
+    "storybook": "10.6.1",
+    "tinyglobby": "0.2.17"
+  },
+  "devDependencies": {
+    "@nativescript-community/octane": "0.2.5",
+    "@nativescript/core": "9.1.3",
+    "@nativescript/macos-node-api": "0.4.4-next.2026-08-09-31292056208",
+    "@nativescript/types": "9.1.4",
+    "@octane-xplat/macos-renderer": "0.0.0-nightly.g2e22171",
+    "@octanejs/vite-plugin": "0.1.61",
+    "octane": "0.11.0",
+    "tsrx-typegen": "0.3.0",
+    "typescript": "5.9.3",
+    "vite": "8.3.0"
+  },
+  "peerDependencies": {
+    "@nativescript-community/octane": ">=0.2.4 <1",
+    "@nativescript/core": ">=9.1.3 <10",
+    "@nativescript/macos-node-api": "0.4.4-next.2026-08-09-31292056208",
+    "@octane-xplat/macos-renderer": ">=0.14.0 <1",
+    "@octanejs/vite-plugin": ">=0.1.61",
+    "octane": ">=0.6.3 <1",
+    "vite": ">=8"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    },
+    "@nativescript/core": {
+      "optional": true
+    },
+    "@nativescript-community/octane": {
+      "optional": true
+    },
+    "@octane-xplat/macos-renderer": {
+      "optional": true
+    },
+    "@nativescript/macos-node-api": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "typegen": "tsrx-typegen --target workshop",
+    "typecheck": "node ../../scripts/typecheck.mjs",
+    "test": "vitest run && tsrx-tsc --noEmit -p tsconfig.test.json",
+    "test:e2e": "pnpm --filter @xplat/workshop-demo test:e2e",
+    "test:packed": "pnpm build && node tests/packed-consumer.web.mjs",
+    "test:packed:linux": "node tests/packed-consumer.linux.mjs",
+    "test:packed:macos": "node tests/packed-consumer.macos.mjs",
+    "test:packed:windows": "node tests/packed-windows-preflight.mjs",
+    "pack:check": "tsrx-typegen --pack-check",
+    "test:types": "tsrx-tsc --noEmit -p tsconfig.test.json",
+    "test:packed:mobile": "node tests/packed-consumer.mobile.mjs",
+    "build": "vite build"
+  }
+}