create-octane-xplat 0.15.0 → 0.16.0

package/dist/scaffold.js

@@ -0,0 +1,439 @@
+import { ensureCompatibilityCatalog } from "./compatibility.js";
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseDocument } from "yaml";
+//#region scaffold.ts
+var moduleDir = dirname(fileURLToPath(import.meta.url));
+var pkgRoot = basename(moduleDir) === "dist" ? join(moduleDir, "..") : moduleDir;
+var TEMPLATE_DIR = join(pkgRoot, "template");
+var LIBRARY_TEMPLATE_DIR = join(pkgRoot, "library-template");
+/** Scaffoldable targets. `files` entries are template-relative paths —
+*  directories copy recursively. `deps`/`devDeps`/`scripts` name keys whose
+*  values come from template/package.json. `typecheck` contributes one clause
+*  to the generated typecheck script. */
+var targets = {
+	web: {
+		label: "Web (Vite)",
+		files: [
+			"index.html",
+			"vite.config.ts",
+			"src/main.web.tsrx",
+			"vitest.web.config.mts",
+			"src/app.web.test.tsx",
+			"src/test-setup.web.ts"
+		],
+		scripts: [
+			"dev",
+			"build",
+			"test",
+			"test:web"
+		],
+		devDeps: ["@octanejs/vite-plugin", "jsdom"]
+	},
+	ios: {
+		label: "iOS (NativeScript)",
+		requires: ["native-shared"],
+		files: ["App_Resources/iOS"],
+		scripts: [
+			"dev:ios",
+			"build:ios",
+			"test:ios"
+		],
+		devDeps: ["@nativescript/ios"],
+		note: "needs macOS + Xcode — `pnpm xplat doctor` checks the toolchain"
+	},
+	android: {
+		label: "Android (NativeScript)",
+		requires: ["native-shared"],
+		files: ["App_Resources/Android"],
+		scripts: [
+			"dev:android",
+			"build:android",
+			"test:android"
+		],
+		devDeps: ["@nativescript/android"],
+		note: "needs Android SDK + a compatible JDK — `pnpm xplat doctor` checks the toolchain"
+	},
+	"native-shared": {
+		hidden: true,
+		patches: [
+			"@nativescript/core",
+			"@nativescript/types",
+			"css",
+			"@nativescript/vite",
+			"@nativescript-community/octane",
+			"@nativescript-community/vite-octane"
+		],
+		files: [
+			"nativescript.config.ts",
+			"vite.config.native.mts",
+			"references.d.ts",
+			"src/main.ts",
+			"vitest.config.mts",
+			"src/test.ts",
+			"src/app.spec.tsrx",
+			"src/native-runtime.spec.ts",
+			"src/failure-reporting.spec.ts"
+		],
+		deps: [
+			"@nativescript-community/octane",
+			"@nativescript/core",
+			"@valor/nativescript-websockets"
+		],
+		devDeps: [
+			"@nativescript-community/vite-octane",
+			"@nativescript/types",
+			"@nativescript/unit-test-runner",
+			"@nativescript/vite",
+			"nativescript"
+		],
+		typecheck: "xplat typecheck"
+	}
+};
+var selectableTargets = Object.keys(targets).filter((id) => !targets[id].hidden);
+/** `pnpm create` without --targets and `xplat add`'s prompt default. */
+var defaultTargets = [
+	"web",
+	"ios",
+	"android"
+];
+var BASE_TYPECHECK = "xplat typecheck";
+var BASE_SCRIPTS = [
+	"xplat",
+	"lint",
+	"lint:fix",
+	"format"
+];
+/** Expand `requires` edges, dependencies first. Throws on unknown ids. */
+function resolveTargets(ids) {
+	const resolved = [];
+	const visit = (id) => {
+		const t = targets[id];
+		if (!t) throw new Error(`unknown target "${id}" — expected one of: ${selectableTargets.join(", ")}`);
+		for (const req of t.requires ?? []) visit(req);
+		if (!resolved.includes(id)) resolved.push(id);
+	};
+	for (const id of ids) visit(id);
+	return resolved;
+}
+var templateManifest = () => JSON.parse(readFileSync(join(TEMPLATE_DIR, "package.json"), "utf8"));
+/** Which target claims a template-relative path (entries may be dirs). */
+function ownerOf(path) {
+	for (const [id, t] of Object.entries(targets)) for (const entry of t.files) if (path === entry || path.startsWith(entry + "/")) return id;
+	return null;
+}
+function walk(dir, prefix = "") {
+	const out = [];
+	for (const name of readdirSync(dir)) {
+		if (name === "node_modules") continue;
+		const rel = prefix ? `${prefix}/${name}` : name;
+		if (statSync(join(dir, name)).isDirectory()) out.push(...walk(join(dir, name), rel));
+		else out.push(rel);
+	}
+	return out;
+}
+function pickKeys(source, names, label) {
+	const out = {};
+	for (const name of names) {
+		if (source[name] === void 0) throw new Error(`template/package.json has no ${label} entry "${name}"`);
+		out[name] = source[name];
+	}
+	return out;
+}
+/**
+* The package.json a given target set produces. With every target selected
+* this is identical to template/package.json.
+*/
+function composeManifest(ids) {
+	const resolved = resolveTargets(ids);
+	const tpl = templateManifest();
+	const manifest = { ...tpl };
+	for (const section of ["dependencies", "devDependencies"]) {
+		const key = section === "dependencies" ? "deps" : "devDeps";
+		const wanted = /* @__PURE__ */ new Set();
+		for (const id of resolved) for (const name of targets[id][key] ?? []) wanted.add(name);
+		const next = {};
+		for (const [name, spec] of Object.entries(tpl[section] ?? {})) if (!Object.keys(targets).some((id) => (targets[id][key] ?? []).includes(name)) || wanted.has(name)) next[name] = spec;
+		manifest[section] = next;
+	}
+	const wantedScripts = new Set(BASE_SCRIPTS);
+	for (const id of resolved) for (const name of targets[id].scripts ?? []) wantedScripts.add(name);
+	const scripts = pickKeys(tpl.scripts ?? {}, [...wantedScripts].sort(), "script");
+	const typecheck = [BASE_TYPECHECK];
+	for (const id of resolved) if (targets[id].typecheck) typecheck.push(targets[id].typecheck);
+	scripts.typecheck = [...new Set(typecheck)].join(" && ");
+	manifest.scripts = {};
+	for (const name of Object.keys(tpl.scripts ?? {})) if (name === "typecheck" || wantedScripts.has(name)) manifest.scripts[name] = scripts[name];
+	if (!resolved.includes("native-shared")) delete manifest.main;
+	return manifest;
+}
+var PATCH_ENTRY = /^\s+"?(@?[\w./-]+@[\w.-]+)"?:\s+\S+\s*$/;
+var patchPkg = (key) => key.replace(/@[^@]+$/, "");
+function parsePatchEntries(lines) {
+	const entries = [];
+	let inPatches = false;
+	let pending = [];
+	for (const line of lines) {
+		if (/^\S/.test(line)) {
+			inPatches = line.startsWith("patchedDependencies");
+			pending = [];
+			continue;
+		}
+		if (!inPatches) continue;
+		const m = line.match(PATCH_ENTRY);
+		if (m) {
+			entries.push({
+				name: patchPkg(m[1]),
+				comments: pending,
+				line
+			});
+			pending = [];
+		} else pending.push(line);
+	}
+	return entries;
+}
+/** The pnpm-workspace.yaml a given target set produces. */
+function composeWorkspaceYaml(ids) {
+	const resolved = new Set(resolveTargets(ids));
+	const drop = /* @__PURE__ */ new Set();
+	for (const [id, t] of Object.entries(targets)) if (!resolved.has(id)) for (const name of t.patches ?? []) drop.add(name);
+	const lines = readFileSync(join(TEMPLATE_DIR, "pnpm-workspace.yaml"), "utf8").split("\n");
+	const out = [];
+	let inPatches = false;
+	let pending = [];
+	for (const line of lines) {
+		if (/^\S/.test(line)) {
+			out.push(...pending, line);
+			pending = [];
+			inPatches = line.startsWith("patchedDependencies");
+			continue;
+		}
+		if (!inPatches) {
+			out.push(line);
+			continue;
+		}
+		const m = line.match(PATCH_ENTRY);
+		if (!m) {
+			pending.push(line);
+			continue;
+		}
+		if (drop.has(patchPkg(m[1]))) {
+			pending = [];
+			continue;
+		}
+		out.push(...pending, line);
+		pending = [];
+	}
+	out.push(...pending);
+	const doc = parseDocument(out.join("\n"));
+	const manifest = composeManifest(ids);
+	const used = /* @__PURE__ */ new Set([...Object.keys(manifest.dependencies), ...Object.keys(manifest.devDependencies)]);
+	for (const name of Object.keys(doc.toJS().catalogs?.xplat ?? {})) if (!used.has(name)) doc.deleteIn([
+		"catalogs",
+		"xplat",
+		name
+	]);
+	return String(doc);
+}
+/**
+* Add the patch entries that `enabledIds` owns to the app's
+* pnpm-workspace.yaml. Entries already present (by package name, any
+* version) are kept. Returns true if the file changed.
+*/
+function ensurePatchEntries(appRoot, enabledIds) {
+	const needed = /* @__PURE__ */ new Set();
+	for (const id of enabledIds) for (const name of targets[id].patches ?? []) needed.add(name);
+	if (!needed.size) return false;
+	const yamlPath = join(appRoot, "pnpm-workspace.yaml");
+	const appText = existsSync(yamlPath) ? readFileSync(yamlPath, "utf8") : "";
+	const present = new Set(parsePatchEntries(appText.split("\n")).map((e) => e.name));
+	const missing = [...needed].filter((name) => !present.has(name));
+	if (!missing.length) return false;
+	const blocks = parsePatchEntries(readFileSync(join(TEMPLATE_DIR, "pnpm-workspace.yaml"), "utf8").split("\n")).filter((e) => missing.includes(e.name)).map((e) => [...e.comments, e.line].join("\n"));
+	if (!appText.trim()) {
+		writeFileSync(yamlPath, composeWorkspaceYaml(enabledIds));
+		return true;
+	}
+	let next = appText;
+	const lines = next.split("\n");
+	const sectionStart = lines.findIndex((l) => l.startsWith("patchedDependencies"));
+	if (sectionStart === -1) next = `${appText.trimEnd()}\npatchedDependencies:\n${blocks.join("\n")}\n`;
+	else {
+		let insertAt = lines.length;
+		for (let i = sectionStart + 1; i < lines.length; i++) if (/^\S/.test(lines[i])) {
+			insertAt = i;
+			break;
+		}
+		lines.splice(insertAt, 0, ...blocks.join("\n").split("\n"));
+		next = lines.join("\n");
+	}
+	writeFileSync(yamlPath, next.endsWith("\n") ? next : next + "\n");
+	return true;
+}
+/**
+* The tsconfig.json a given target set produces. One program covers every
+* platform suffix (moduleSuffixes is the fixed precedence order); a web-only
+* scaffold just drops the native ambient root and entrypoint.
+*/
+function composeTsconfig(ids) {
+	const resolved = new Set(resolveTargets(ids));
+	const config = JSON.parse(readFileSync(join(TEMPLATE_DIR, "tsconfig.json"), "utf8"));
+	if (!resolved.has("native-shared")) {
+		delete config.files;
+		config.compilerOptions.types = (config.compilerOptions.types ?? []).filter((t) => t !== "@nativescript/types");
+		config.exclude = [.../* @__PURE__ */ new Set([...config.exclude ?? [], "src/main.ts"])];
+	}
+	return JSON.stringify(config, null, "	") + "\n";
+}
+/** Write a scaffold with tests for `ids` into `dir` (must not exist or be empty). */
+function composeTargets(ids, dir) {
+	const resolved = new Set(resolveTargets(ids));
+	mkdirSync(dir, { recursive: true });
+	for (const rel of walk(TEMPLATE_DIR)) {
+		if (rel === "package.json" || rel === "pnpm-workspace.yaml" || rel === "tsconfig.json") continue;
+		const owner = ownerOf(rel);
+		if (owner && !resolved.has(owner)) continue;
+		const dest = join(dir, rel === "gitignore" ? ".gitignore" : rel);
+		mkdirSync(dirname(dest), { recursive: true });
+		cpSync(join(TEMPLATE_DIR, rel), dest, { recursive: true });
+	}
+	writeFileSync(join(dir, "package.json"), JSON.stringify(composeManifest(ids), null, "	") + "\n");
+	writeFileSync(join(dir, "pnpm-workspace.yaml"), composeWorkspaceYaml(ids));
+	writeFileSync(join(dir, "tsconfig.json"), composeTsconfig(ids));
+	return [...resolved];
+}
+/** Write the cross-platform library starter into `dir`. */
+function composeLibrary(dir, packageName = basename(resolve(dir))) {
+	if (packageName.length > 214 || !/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/.test(packageName)) throw new Error(`invalid npm package name "${packageName}" — use lowercase letters, numbers, dots, underscores, or hyphens`);
+	mkdirSync(dir, { recursive: true });
+	for (const rel of walk(LIBRARY_TEMPLATE_DIR)) {
+		if (rel === "package.json") continue;
+		const dest = join(dir, rel === "gitignore" ? ".gitignore" : rel);
+		mkdirSync(dirname(dest), { recursive: true });
+		const source = join(LIBRARY_TEMPLATE_DIR, rel);
+		if (/\.(?:md|ts|tsx|mjs|json)$/.test(rel)) {
+			const content = readFileSync(source, "utf8").replaceAll("octane-xplat-library", packageName);
+			writeFileSync(dest, content);
+		} else cpSync(source, dest, { recursive: true });
+	}
+	const manifest = JSON.parse(readFileSync(join(LIBRARY_TEMPLATE_DIR, "package.json"), "utf8"));
+	manifest.name = packageName;
+	writeFileSync(join(dir, "package.json"), JSON.stringify(manifest, null, "	") + "\n");
+}
+var readJson = (file) => {
+	try {
+		return JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return null;
+	}
+};
+/** Sentinel-based enablement check, mirroring the CLI's targets.mjs. */
+function targetEnabled(appRoot, id) {
+	if (id === "web") return existsSync(join(appRoot, "vite.config.ts")) || existsSync(join(appRoot, "vite.config.mts"));
+	if (id === "native-shared") return existsSync(join(appRoot, "nativescript.config.ts"));
+	const manifest = readJson(join(appRoot, "package.json")) ?? {};
+	const declared = {
+		...manifest.dependencies,
+		...manifest.devDependencies
+	};
+	const runtime = {
+		ios: "@nativescript/ios",
+		android: "@nativescript/android"
+	}[id];
+	return runtime ? typeof declared[runtime] === "string" : false;
+}
+/** Copy a template file/dir into the app unless the destination exists. */
+function copyMissing(rel, appRoot, report) {
+	const src = join(TEMPLATE_DIR, rel);
+	const dest = join(appRoot, rel === "gitignore" ? ".gitignore" : rel);
+	if (existsSync(dest)) {
+		report.skipped.push(rel);
+		return;
+	}
+	mkdirSync(dirname(dest), { recursive: true });
+	cpSync(src, dest, { recursive: true });
+	report.copied.push(rel);
+}
+/**
+* Fold a native-capable app's sources into the one tsconfig program: the
+* manifest (tsconfig.envs.json) is gone — one program covers every platform
+* suffix — so enabling native means wiring the ambient declaration file and
+* the entrypoint into the app's own config.
+*/
+function enableNativeInTsconfig(appRoot) {
+	const path = join(appRoot, "tsconfig.json");
+	const text = existsSync(path) ? readFileSync(path, "utf8") : "";
+	const config = readJson(path);
+	if (!config || typeof config !== "object") return false;
+	const indent = text.match(/\n(\s+)"/)?.[1] ?? "	";
+	config.files = [.../* @__PURE__ */ new Set(["references.d.ts", ...config.files ?? []])];
+	config.exclude = (config.exclude ?? []).filter((e) => e !== "src/main.ts");
+	const types = config.compilerOptions?.types;
+	if (config.compilerOptions && Array.isArray(types) && !types.includes("@nativescript/types")) config.compilerOptions.types = [...types, "@nativescript/types"];
+	writeFileSync(path, JSON.stringify(config, null, indent) + "\n");
+	return true;
+}
+/**
+* Enable `id` (plus unmet `requires`) inside an existing app at `appRoot`.
+* Additive only: existing files, scripts, and dep entries are skipped, never
+* overwritten. Returns a report for the caller to render.
+*/
+function applyTarget(appRoot, id) {
+	const manifestPath = join(appRoot, "package.json");
+	const raw = readFileSync(manifestPath, "utf8");
+	const manifest = JSON.parse(raw);
+	const tpl = templateManifest();
+	const report = {
+		enabled: [],
+		already: [],
+		copied: [],
+		skipped: [],
+		scriptsAdded: [],
+		scriptsSkipped: [],
+		depsAdded: []
+	};
+	let touched = false;
+	for (const tid of resolveTargets([id])) {
+		if (targetEnabled(appRoot, tid)) {
+			report.already.push(tid);
+			continue;
+		}
+		report.enabled.push(tid);
+		const t = targets[tid];
+		for (const rel of t.files) copyMissing(rel, appRoot, report);
+		for (const [section, key] of [["dependencies", "deps"], ["devDependencies", "devDeps"]]) for (const name of t[key] ?? []) {
+			manifest[section] ??= {};
+			if (manifest[section][name] === void 0) {
+				manifest[section][name] = tpl[section][name];
+				report.depsAdded.push(name);
+			}
+		}
+		manifest.scripts ??= {};
+		for (const name of t.scripts ?? []) if (manifest.scripts[name] === void 0) {
+			manifest.scripts[name] = tpl.scripts[name];
+			report.scriptsAdded.push(name);
+		} else if (manifest.scripts[name] !== tpl.scripts[name]) report.scriptsSkipped.push(name);
+		if (t.typecheck) {
+			const current = manifest.scripts.typecheck ?? "";
+			if (!current.includes(t.typecheck)) {
+				manifest.scripts.typecheck = current ? `${current} && ${t.typecheck}` : t.typecheck;
+				report.scriptsAdded.push("typecheck");
+			}
+		}
+		if (tid === "native-shared") {
+			if (manifest.main === void 0) manifest.main = tpl.main;
+			report.tsconfigUpdated = enableNativeInTsconfig(appRoot);
+		}
+		touched = true;
+	}
+	if (ensurePatchEntries(appRoot, [...report.enabled, ...report.already])) report.patchesAdded = true;
+	ensureCompatibilityCatalog(appRoot, manifest);
+	if (touched) {
+		const indent = raw.match(/\n(\s+)"/)?.[1] ?? "	";
+		writeFileSync(manifestPath, JSON.stringify(manifest, null, indent) + "\n");
+	}
+	return report;
+}
+//#endregion
+export { LIBRARY_TEMPLATE_DIR, TEMPLATE_DIR, applyTarget, composeLibrary, composeManifest, composeTargets, composeTsconfig, composeWorkspaceYaml, defaultTargets, resolveTargets, selectableTargets, targetEnabled, targets };

package/{index.mjs → index.ts}

@@ -9,7 +9,7 @@ import {
 	resolveTargets,
 	selectableTargets,
 	targets,
-} from './scaffold.mjs'
+} from './scaffold.ts'
 
 const argv = process.argv.slice(2)
 const noInstall = argv.includes('--no-install')
@@ -111,7 +111,7 @@ const parseTargets = (value) => {
 	return resolveTargets(ids)
 }
 
-let ids = []
+let ids: string[] = []
 if (templateArg === 'library') {
 	const packageName = nameArg ?? basename(dir)
 	try {
@@ -131,8 +131,7 @@ if (templateArg === 'library') {
 			process.exit(1)
 		}
 	} else if (process.stdout.isTTY) {
-		// Lazy: the extracted tarball has no installed deps — only the interactive
-		// path needs @clack/prompts (verify-consumer runs the bin dep-free).
+		// Non-interactive creation does not need the prompt module.
 		const p = await import('@clack/prompts')
 		p.intro('create-octane-xplat')
 		const picked = await p.multiselect({

package/library-template/AGENTS.md

@@ -1,12 +1,14 @@
 # Library package notes
 
 - Use pnpm for package management.
+- Keep build dependencies in `catalog:xplat`. Use `pnpm dlx @octane-xplat/cli@latest upgrade --check` to preview a workspace-wide version/patch update and `pnpm dlx @octane-xplat/cli@latest upgrade` to apply it. Keep consumer peer ranges under the library's control; run `pnpm xplat doctor` and the package checks afterward.
 - Keep the public API in `src/index.ts` and `src/index.web.ts`; both barrels
   must export the same names and types.
 - Put shared prop contracts in `src/props.ts` and document public exports.
 - The unsuffixed `.tsx` file is the NativeScript implementation. Add a
   `.web.tsx` sibling when browser behavior or markup needs to differ. Native
-  files start with `/** @jsxImportSource @nativescript-community/octane */`.
+  files start with `/** @jsxImportSource @octane-xplat/jsx */`; browser files
+  start with `/** @jsxImportSource @octane-xplat/jsx/dom */`.
 - Keep DOM globals out of native files. Use the shared `@octane-xplat/ui`
   elements when behavior can be shared.
 - Declare every imported package. Runtime plugins belong in `dependencies`;

package/library-template/README.md

@@ -29,11 +29,21 @@ Run these commands from the package directory:
 ```sh
 pnpm typecheck
 pnpm lint
+pnpm lint:fix
 pnpm test
 pnpm typegen
 pnpm test:packed
 ```
 
+Linting uses the CLI's bundled framework defaults. Apply safe lint fixes with
+`lint:fix`; use `format` to format source and `fmt --check` to check formatting
+without changing files:
+
+```sh
+pnpm format
+pnpm exec xplat fmt --check
+```
+
 The package publishes authored source for the app's bundler to compile.
 `pnpm typegen` generates `.d.ts` files so consumers' type checkers use
 declarations. `pnpm test:packed` packs the package, places that artifact into
@@ -42,6 +52,16 @@ small web and native TypeScript consumers, and checks both export conditions.
 The package sets `nodeLinker: hoisted` in `pnpm-workspace.yaml` because the
 NativeScript bundler expects a flat dependency tree.
 
+Its `catalog:xplat` build dependencies and patches follow one framework
+compatibility set. Update that set together; consumer `peerDependencies`
+ranges are preserved for you to maintain:
+
+```sh
+pnpm dlx @octane-xplat/cli@latest upgrade --check
+pnpm dlx @octane-xplat/cli@latest upgrade
+pnpm xplat doctor
+```
+
 ## Platform files
 
 `src/Badge.tsx` is the shared iOS and Android implementation. The

package/library-template/package.json

@@ -46,8 +46,8 @@
 	"scripts": {
 		"typegen": "tsrx-typegen --project tsconfig.types.json",
 		"typecheck": "xplat typecheck",
-		"lint": "xplat-lint",
-		"lint:fix": "xplat-lint --fix",
+		"lint": "xplat lint",
+		"lint:fix": "xplat lint --fix",
 		"test": "vitest run",
 		"test:packed": "node tests/packed-consumer.mjs",
 		"prepack": "pnpm typegen && tsrx-typegen --pack-check",
@@ -55,26 +55,26 @@
 		"format": "xplat fmt"
 	},
 	"devDependencies": {
-		"@nativescript-community/octane": "catalog:",
-		"@nativescript/core": "catalog:",
-		"@nativescript/types": "catalog:",
-		"@octane-xplat/cli": "^0.15.0",
-		"@octane-xplat/lint": "^0.15.0",
-		"@octane-xplat/ui": "^0.15.0",
-		"@octanejs/vite-plugin": "catalog:",
-		"@tsrx/oxc": "0.20.0",
-		"@tsrx/typescript-plugin": "catalog:",
-		"octane": "catalog:",
-		"oxlint": "^1.74.0",
-		"tsrx-typegen": "^0.2.2",
-		"typescript": "catalog:",
-		"vite": "catalog:",
-		"vitest": "catalog:"
+		"@nativescript-community/octane": "catalog:xplat",
+		"@nativescript/core": "catalog:xplat",
+		"@nativescript/types": "catalog:xplat",
+		"@octane-xplat/cli": "catalog:xplat",
+		"@octane-xplat/jsx": "catalog:xplat",
+		"@octane-xplat/ui": "catalog:xplat",
+		"@octanejs/vite-plugin": "catalog:xplat",
+		"@tsrx/oxc": "catalog:xplat",
+		"@tsrx/typescript-plugin": "catalog:xplat",
+		"octane": "catalog:xplat",
+		"tsrx-typegen": "catalog:xplat",
+		"typescript": "catalog:xplat",
+		"vite": "catalog:xplat",
+		"vitest": "catalog:xplat"
 	},
 	"peerDependencies": {
 		"@nativescript-community/octane": ">=0.2.1 <1",
 		"@nativescript/core": ">=9.1.0 <10",
-		"@octane-xplat/ui": "^0.15.0",
+		"@octane-xplat/jsx": "^0.16.0",
+		"@octane-xplat/ui": "^0.16.0",
 		"octane": ">=0.6.3 <1"
 	},
 	"peerDependenciesMeta": {
@@ -85,5 +85,8 @@
 			"optional": true
 		}
 	},
-	"packageManager": "pnpm@11.24.0"
+	"packageManager": "pnpm@11.24.0",
+	"engines": {
+		"node": ">=22.18.0"
+	}
 }