@glassly/bluetooth-sdk 0.1.0-dev.26

package/plugin/build/withAndroid.js

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAndroidConfiguration = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const config_plugins_1 = require("expo/config-plugins");
+const META_ANALYTICS_DISABLED = "com.glassly.bluetoothsdk.analytics.disabled";
+const STALE_META_POSTHOG_API_KEY = "com.glassly.bluetoothsdk.analytics.posthog_api_key";
+const STALE_META_POSTHOG_HOST = "com.glassly.bluetoothsdk.analytics.posthog_host";
+const ANALYTICS_META_NAMES = [META_ANALYTICS_DISABLED, STALE_META_POSTHOG_API_KEY, STALE_META_POSTHOG_HOST];
+function getBluetoothSdkRoot() {
+    return path_1.default.dirname(require.resolve("../../package.json"));
+}
+function toGroovyString(value) {
+    return JSON.stringify(value);
+}
+/**
+ * Modify settings.gradle to include lc3Lib and silero modules
+ */
+function withSettingsGradleModifications(config) {
+    return (0, config_plugins_1.withSettingsGradle)(config, (config) => {
+        let settingsGradle = config.modResults.contents;
+        const bluetoothSdkRoot = getBluetoothSdkRoot();
+        const bluetoothSdkRootExpression = `System.getenv("GLASSLY_BLUETOOTH_SDK_PACKAGE_PATH") ?: ${toGroovyString(bluetoothSdkRoot)}`;
+        if (!settingsGradle.includes("project(':glassly-bluetooth-sdk').projectDir")) {
+            const bluetoothSdkProjectBlock = `
+  if (findProject(':glassly-bluetooth-sdk') != null) {
+    project(':glassly-bluetooth-sdk').projectDir = new File(${bluetoothSdkRootExpression}, 'android')
+  }
+`;
+            const lc3Include = "  include ':lc3Lib'";
+            settingsGradle = settingsGradle.includes(lc3Include)
+                ? settingsGradle.replace(lc3Include, `${bluetoothSdkProjectBlock}\n${lc3Include}`)
+                : `${settingsGradle}${bluetoothSdkProjectBlock}`;
+        }
+        if (!settingsGradle.includes("include ':lc3Lib'")) {
+            settingsGradle += `
+  include ':lc3Lib'
+  `;
+        }
+        if (!settingsGradle.includes("project(':lc3Lib').projectDir")) {
+            settingsGradle += `
+  project(':lc3Lib').projectDir = new File(${bluetoothSdkRootExpression}, 'android/lc3Lib')
+  `;
+        }
+        if (!settingsGradle.includes("include ':silero'")) {
+            settingsGradle += `
+  include ':silero'
+  `;
+        }
+        if (!settingsGradle.includes("project(':silero').projectDir")) {
+            settingsGradle += `
+  project(':silero').projectDir = new File(${bluetoothSdkRootExpression}, 'android/silero')
+  `;
+        }
+        config.modResults.contents = settingsGradle;
+        return config;
+    });
+}
+/**
+ * Modify gradle.properties to add node path for native builds launched outside a shell.
+ */
+function withGradlePropertiesModifications(config) {
+    return (0, config_plugins_1.withGradleProperties)(config, (config) => {
+        let props = config.modResults;
+        // Get node path and add to org.gradle.jvmargs
+        try {
+            const nodeExecutable = (0, child_process_1.execSync)("which node", { encoding: "utf-8" }).trim();
+            // Get parent directory of bin (e.g., /path/to/node/bin/node -> /path/to/node)
+            const nodePath = path_1.default.dirname(nodeExecutable);
+            // Find existing org.gradle.jvmargs property
+            const jvmArgsIndex = props.findIndex((p) => p.type === "property" && p.key === "org.gradle.jvmargs");
+            if (jvmArgsIndex !== -1) {
+                // Append nodePath to existing jvmargs if not already present
+                const jvmArgsProp = props[jvmArgsIndex];
+                if (jvmArgsProp?.type === "property" && "value" in jvmArgsProp) {
+                    const currentValue = jvmArgsProp.value;
+                    if (!currentValue.includes("-Dorg.gradle.project.nodePath=")) {
+                        jvmArgsProp.value = `${currentValue} -Dorg.gradle.project.nodePath=${nodePath}`;
+                    }
+                }
+            }
+            else {
+                // Create new jvmargs property with nodePath
+                props.push({
+                    type: "property",
+                    key: "org.gradle.jvmargs",
+                    value: `-Dorg.gradle.project.nodePath=${nodePath}`,
+                });
+            }
+        }
+        catch (error) {
+            console.warn("Failed to get node path:", error);
+        }
+        config.modResults = props;
+        return config;
+    });
+}
+/**
+ * Inject a local Maven repository into the root project's allprojects block so
+ * that `:app` (and any other module that transitively pulls our deps) can
+ * resolve `com.k2fsa.sherpa.onnx:sherpa-onnx`. The AAR is downloaded at
+ * configure-time by bluetooth-sdk's own build.gradle into
+ * `android/libs/maven/`; we just need that directory exposed as a maven repo
+ * to consumers as well. AGP rejects raw local-.aar deps from library modules,
+ * so the Maven layout is the supported workaround.
+ */
+function withSherpaOnnxLocalMavenRepo(config) {
+    return (0, config_plugins_1.withProjectBuildGradle)(config, (config) => {
+        if (config.modResults.language !== "groovy") {
+            return config;
+        }
+        let contents = config.modResults.contents;
+        const fallbackRoot = toGroovyString(getBluetoothSdkRoot());
+        const repoDirExpression = `new File(System.getenv("GLASSLY_BLUETOOTH_SDK_PACKAGE_PATH") ?: ${fallbackRoot}, "android/libs/maven")`;
+        const marker = "// bluetooth-sdk: sherpa-onnx local maven repo";
+        if (contents.includes(marker)) {
+            return config;
+        }
+        const repoBlock = `    maven {\n      ${marker}\n      url = uri(${repoDirExpression})\n    }`;
+        const allprojectsMatch = contents.match(/allprojects\s*\{[\s\S]*?repositories\s*\{/);
+        if (allprojectsMatch) {
+            const insertIdx = allprojectsMatch.index + allprojectsMatch[0].length;
+            contents = contents.slice(0, insertIdx) + "\n" + repoBlock + contents.slice(insertIdx);
+        }
+        else {
+            // Fallback: append an allprojects block. Older Expo templates that don't
+            // emit allprojects {} put repositories in settings.gradle instead — but
+            // this codebase's prebuild has historically emitted allprojects, so this
+            // branch is just a safety net.
+            contents += `\nallprojects {\n  repositories {\n${repoBlock}\n  }\n}\n`;
+        }
+        config.modResults.contents = contents;
+        return config;
+    });
+}
+function resolveAnalyticsProps(props) {
+    const analytics = props?.analytics;
+    let disabled;
+    if (analytics === false) {
+        disabled = true;
+    }
+    else if (analytics === true) {
+        disabled = false;
+    }
+    else if (typeof analytics === "object" && analytics.enabled !== undefined) {
+        disabled = !analytics.enabled;
+    }
+    return {
+        disabled,
+    };
+}
+function upsertMetaData(application, name, value) {
+    application["meta-data"] ??= [];
+    const existing = application["meta-data"].find((item) => item.$?.["android:name"] === name);
+    const entry = existing ?? { $: { "android:name": name } };
+    entry.$["android:value"] = value;
+    if (!existing) {
+        application["meta-data"].push(entry);
+    }
+}
+function removeMetaData(application, name) {
+    application["meta-data"] = (application["meta-data"] ?? []).filter((item) => item.$?.["android:name"] !== name);
+}
+function withAnalyticsManifestMetadata(config, props) {
+    return (0, config_plugins_1.withAndroidManifest)(config, (config) => {
+        const analytics = resolveAnalyticsProps(props);
+        const application = config_plugins_1.AndroidConfig.Manifest.getMainApplicationOrThrow(config.modResults);
+        for (const name of ANALYTICS_META_NAMES) {
+            removeMetaData(application, name);
+        }
+        if (analytics.disabled !== undefined) {
+            upsertMetaData(application, META_ANALYTICS_DISABLED, analytics.disabled ? "true" : "false");
+        }
+        return config;
+    });
+}
+const withAndroidConfiguration = (config, props) => {
+    config = withSettingsGradleModifications(config);
+    config = withSherpaOnnxLocalMavenRepo(config);
+    config = withAnalyticsManifestMetadata(config, props);
+    if (props?.node) {
+        config = withGradlePropertiesModifications(config);
+    }
+    return config;
+};
+exports.withAndroidConfiguration = withAndroidConfiguration;

package/plugin/build/withIos.d.ts

@@ -0,0 +1,5 @@
+import { IOSConfig, type ConfigPlugin } from "expo/config-plugins";
+import { type BluetoothSdkPluginProps } from "./index";
+export declare const INFO_SDK_VERSION = "BluetoothSdkVersion";
+export declare function applyBluetoothSdkInfoPlist(infoPlist: IOSConfig.InfoPlist, props: BluetoothSdkPluginProps | undefined): IOSConfig.InfoPlist;
+export declare const withIosConfiguration: ConfigPlugin<BluetoothSdkPluginProps>;

package/plugin/build/withIos.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withIosConfiguration = exports.INFO_SDK_VERSION = void 0;
+exports.applyBluetoothSdkInfoPlist = applyBluetoothSdkInfoPlist;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_plugins_1 = require("expo/config-plugins");
+const BLUETOOTH_SDK_EXPO_ADAPTER_ENV = "GLASSLY_BLUETOOTH_SDK_INCLUDE_EXPO_ADAPTER";
+const BLUETOOTH_SDK_EXPO_ADAPTER_LINE = `ENV['${BLUETOOTH_SDK_EXPO_ADAPTER_ENV}'] ||= '1'`;
+const INFO_ANALYTICS_DISABLED = "BluetoothSdkAnalyticsDisabled";
+exports.INFO_SDK_VERSION = "BluetoothSdkVersion";
+const STALE_INFO_POSTHOG_API_KEY = "BluetoothSdkPostHogApiKey";
+const STALE_INFO_POSTHOG_HOST = "BluetoothSdkPostHogHost";
+const ensureBluetoothSdkExpoAdapterPodEnv = (podfile) => {
+    if (podfile.includes(BLUETOOTH_SDK_EXPO_ADAPTER_ENV)) {
+        return podfile;
+    }
+    const insertion = [
+        "  # Expo apps need the SDK's Expo module adapter so autolinking can register BluetoothSdk.",
+        `  ${BLUETOOTH_SDK_EXPO_ADAPTER_LINE}`,
+        "",
+    ].join("\n");
+    return podfile.replace(/(target\s+['"][^'"]+['"]\s+do\n)/, `$1${insertion}`);
+};
+const withXcodeEnvLocal = (config) => {
+    return (0, config_plugins_1.withDangerousMod)(config, [
+        "ios",
+        async (config) => {
+            try {
+                // Get node executable path
+                const nodeExecutable = (0, child_process_1.execSync)("which node", { encoding: "utf-8" }).trim();
+                // Path to .xcode.env.local
+                const iosPath = path_1.default.join(config.modRequest.platformProjectRoot);
+                const xcodeEnvLocalPath = path_1.default.join(iosPath, ".xcode.env.local");
+                // Content to write
+                const content = `export NODE_BINARY=${nodeExecutable}\n`;
+                // Write or append to .xcode.env.local
+                if (fs_1.default.existsSync(xcodeEnvLocalPath)) {
+                    const existingContent = fs_1.default.readFileSync(xcodeEnvLocalPath, "utf-8");
+                    if (!existingContent.includes("NODE_BINARY")) {
+                        fs_1.default.appendFileSync(xcodeEnvLocalPath, content);
+                    }
+                }
+                else {
+                    fs_1.default.writeFileSync(xcodeEnvLocalPath, content);
+                }
+            }
+            catch (error) {
+                console.warn("Failed to create .xcode.env.local:", error);
+            }
+            return config;
+        },
+    ]);
+};
+function resolveAnalyticsProps(props) {
+    const analytics = props?.analytics;
+    let disabled;
+    if (analytics === false) {
+        disabled = true;
+    }
+    else if (analytics === true) {
+        disabled = false;
+    }
+    else if (typeof analytics === "object" && analytics.enabled !== undefined) {
+        disabled = !analytics.enabled;
+    }
+    return {
+        disabled,
+    };
+}
+function applyBluetoothSdkInfoPlist(infoPlist, props) {
+    const packageJson = require("../../package.json");
+    const sdkVersion = typeof packageJson.version === "string" ? packageJson.version.trim() : "";
+    if (!sdkVersion) {
+        throw new Error("@glassly/bluetooth-sdk package.json is missing a version");
+    }
+    const analytics = resolveAnalyticsProps(props);
+    delete infoPlist[INFO_ANALYTICS_DISABLED];
+    delete infoPlist[STALE_INFO_POSTHOG_API_KEY];
+    delete infoPlist[STALE_INFO_POSTHOG_HOST];
+    infoPlist[exports.INFO_SDK_VERSION] = sdkVersion;
+    if (analytics.disabled !== undefined) {
+        infoPlist[INFO_ANALYTICS_DISABLED] = analytics.disabled;
+    }
+    return infoPlist;
+}
+function withBluetoothSdkInfoPlist(config, props) {
+    return (0, config_plugins_1.withInfoPlist)(config, (config) => {
+        config.modResults = applyBluetoothSdkInfoPlist(config.modResults, props);
+        return config;
+    });
+}
+const withIosConfiguration = (config, props) => {
+    config = (0, config_plugins_1.withPodfile)(config, (config) => {
+        config.modResults.contents = ensureBluetoothSdkExpoAdapterPodEnv(config.modResults.contents);
+        return config;
+    });
+    config = withBluetoothSdkInfoPlist(config, props);
+    if (props?.node) {
+        config = withXcodeEnvLocal(config);
+    }
+    return config;
+};
+exports.withIosConfiguration = withIosConfiguration;

package/scripts/inject-ios-sdk-version.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+const packageJsonPath = path.join(packageRoot, "package.json")
+const sourcePath = path.join(packageRoot, "ios/Source/BluetoothSdkDefaults.swift")
+const backupPath = path.join(packageRoot, ".bluetooth-sdk-version-prepack-backup")
+const restore = process.argv.includes("--restore")
+
+const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"))
+const version = packageJson.version
+
+if (typeof version !== "string" || version.trim() === "") {
+  throw new Error("mobile/modules/bluetooth-sdk/package.json is missing a version")
+}
+
+const placeholder = 'private static let swiftPackageSdkVersion = "__GLASSLY_BLUETOOTH_SDK_VERSION__"'
+const injectedVersion = `private static let swiftPackageSdkVersion = "${version}"`
+
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+if (restore) {
+  if (!(await pathExists(backupPath))) {
+    console.log("No iOS SDK version prepack backup found; nothing to restore.")
+    process.exit(0)
+  }
+
+  await fs.writeFile(sourcePath, await fs.readFile(backupPath, "utf8"))
+  await fs.rm(backupPath)
+  console.log("Restored placeholder iOS SDK version after packing.")
+  process.exit(0)
+}
+
+if (await pathExists(backupPath)) {
+  throw new Error("Found an existing iOS SDK version prepack backup. Run `npm run postpack` before packing again.")
+}
+
+const originalSource = await fs.readFile(sourcePath, "utf8")
+let packedSource
+
+if (originalSource.includes(placeholder)) {
+  packedSource = originalSource.replace(placeholder, injectedVersion)
+} else if (originalSource.includes(injectedVersion)) {
+  packedSource = originalSource
+} else {
+  throw new Error("BluetoothSdkDefaults.swift does not contain the expected SDK version placeholder.")
+}
+
+await fs.writeFile(backupPath, originalSource)
+
+if (packedSource !== originalSource) {
+  await fs.writeFile(sourcePath, packedSource)
+}
+
+console.log(`Injected iOS SDK version ${version} for npm packaging.`)

package/scripts/public-ota-api.test.mjs

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict"
+import {readFileSync} from "node:fs"
+import path from "node:path"
+import test from "node:test"
+import {fileURLToPath} from "node:url"
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+
+test("publishes the supported OTA transport entrypoint", () => {
+  const manifest = JSON.parse(readFileSync(path.join(packageRoot, "package.json"), "utf8"))
+  assert.deepEqual(manifest.exports["./ota-transport"], {
+    "react-native": "./src/ota-transport/index.ts",
+    "types": "./build/ota-transport/index.d.ts",
+    "default": "./build/ota-transport/index.js",
+  })
+
+  const source = readFileSync(path.join(packageRoot, "src/ota-transport/index.ts"), "utf8")
+  assert.match(source, /export const otaLocalNetwork/)
+  assert.match(source, /export const otaServer/)
+  assert.doesNotMatch(source, /export \{default as Glassly(LocalNetwork|OtaServer)/)
+})
+
+test("keeps restart signals and correlated OTA status on the public root", () => {
+  const source = readFileSync(path.join(packageRoot, "src/index.ts"), "utf8")
+  for (const required of [
+    '"glasses_session_changed"',
+    '"mtk_update_complete"',
+    "queryOtaStatus",
+    "subscribeGlassesStatus",
+    "subscribeBluetoothStatus",
+    "setSystemTime",
+    "ping",
+  ]) {
+    assert.ok(source.includes(required), `missing public OTA primitive: ${required}`)
+  }
+  assert.match(source, /Unsupported BluetoothSdk event/)
+})

package/scripts/verify-release-package.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import {readFileSync} from "node:fs"
+import path from "node:path"
+
+function option(name, {required = true} = {}) {
+  const index = process.argv.indexOf(`--${name}`)
+  if (index < 0 || !process.argv[index + 1]) {
+    if (required) throw new Error(`Missing --${name}`)
+    return undefined
+  }
+  return process.argv[index + 1]
+}
+
+const packageRoot = path.resolve(option("package-root"))
+const releaseIdentity = option("release-identity")
+// Absent as a pair when the release carries no firmware pin.
+const otaManifestUrl = option("ota-manifest-url", {required: false})
+const otaManifestSha256 = option("ota-manifest-sha256", {required: false})
+const packageJson = JSON.parse(readFileSync(path.join(packageRoot, "package.json"), "utf8"))
+if (packageJson.version !== releaseIdentity) {
+  throw new Error(`Packed SDK version ${JSON.stringify(packageJson.version)} does not match ${releaseIdentity}`)
+}
+
+const files = [
+  "src/generated/releaseMetadata.ts",
+  "build/generated/releaseMetadata.js",
+  "android/src/main/java/com/glassly/bluetoothsdk/GeneratedReleaseMetadata.kt",
+  "ios/Source/GeneratedReleaseMetadata.swift",
+]
+// A release built without firmware records null OTA coordinates, so assert
+// those were written rather than a stale pin.
+const hasOta = Boolean(otaManifestUrl) || Boolean(otaManifestSha256)
+for (const relativePath of files) {
+  const contents = readFileSync(path.join(packageRoot, relativePath), "utf8")
+  if (hasOta) {
+    if (!contents.includes(otaManifestUrl)) throw new Error(`${relativePath} does not contain the OTA manifest URL`)
+    if (!contents.includes(otaManifestSha256))
+      throw new Error(`${relativePath} does not contain the OTA manifest SHA-256`)
+  } else if (!/OTA_MANIFEST_URL[^\n]*null|otaManifestUrl[^\n]*null/i.test(contents)) {
+    throw new Error(`${relativePath} does not record a null OTA manifest URL`)
+  }
+  if (!contents.includes(releaseIdentity)) throw new Error(`${relativePath} does not contain the release identity`)
+}
+
+console.log(`Verified packed Bluetooth SDK ${releaseIdentity} metadata across JavaScript, Android, and iOS`)

package/scripts/write-release-metadata.mjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import {mkdirSync, writeFileSync} from "node:fs"
+import path from "node:path"
+import {fileURLToPath} from "node:url"
+
+const STABLE_VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/
+const RELEASE_IDENTITY_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(?:dev|beta)\.[1-9]\d*)?$/
+const COMMIT_PATTERN = /^[0-9a-f]{40}$/
+const SHA256_PATTERN = /^[0-9a-f]{64}$/
+
+function validateHttpsUrl(value) {
+  let url
+  try {
+    url = new URL(value)
+  } catch {
+    throw new Error(`OTA manifest URL is invalid: ${JSON.stringify(value)}`)
+  }
+  if (url.protocol !== "https:" || url.username || url.password || url.hash) {
+    throw new Error("OTA manifest URL must be credential-free HTTPS without a fragment")
+  }
+  return url.toString()
+}
+
+export function validateReleaseMetadata(input) {
+  if (!STABLE_VERSION_PATTERN.test(input.familyBaseVersion)) {
+    throw new Error("familyBaseVersion must be a plain X.Y.Z version")
+  }
+  if (!RELEASE_IDENTITY_PATTERN.test(input.releaseIdentity)) {
+    throw new Error("releaseIdentity must be X.Y.Z, X.Y.Z-dev.N, or X.Y.Z-beta.N")
+  }
+  if (
+    input.releaseIdentity !== input.familyBaseVersion &&
+    !input.releaseIdentity.startsWith(`${input.familyBaseVersion}-`)
+  ) {
+    throw new Error("releaseIdentity does not belong to familyBaseVersion")
+  }
+  if (input.releaseSetId !== `glassly-${input.releaseIdentity}`) {
+    throw new Error("releaseSetId must be glassly-<releaseIdentity>")
+  }
+  if (!COMMIT_PATTERN.test(input.sourceCommit)) throw new Error("sourceCommit must be a full lowercase Git SHA")
+  // OTA coordinates are both-or-neither: a release without an OTA lane
+  // records null coordinates rather than fabricating a manifest.
+  const hasOta = input.otaManifestUrl != null || input.otaManifestSha256 != null
+  if (hasOta && !SHA256_PATTERN.test(input.otaManifestSha256)) {
+    throw new Error("otaManifestSha256 must be a lowercase SHA-256 digest")
+  }
+  return {
+    schemaVersion: 1,
+    familyBaseVersion: input.familyBaseVersion,
+    releaseIdentity: input.releaseIdentity,
+    releaseSetId: input.releaseSetId,
+    sourceCommit: input.sourceCommit,
+    otaManifestUrl: hasOta ? validateHttpsUrl(input.otaManifestUrl) : null,
+    otaManifestSha256: hasOta ? input.otaManifestSha256 : null,
+  }
+}
+
+function swiftString(value) {
+  return JSON.stringify(value)
+}
+
+export function renderReleaseMetadata(input) {
+  const metadata = validateReleaseMetadata(input)
+  const typescript = [
+    "/** Generated by release CI. Do not edit in a release checkout. */",
+    "export interface BluetoothSdkReleaseMetadata {",
+    "  schemaVersion: 1",
+    "  familyBaseVersion: string | null",
+    "  releaseIdentity: string | null",
+    "  releaseSetId: string | null",
+    "  sourceCommit: string | null",
+    "  otaManifestUrl: string | null",
+    "  otaManifestSha256: string | null",
+    "}",
+    "",
+    `export const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze(${JSON.stringify(
+      metadata,
+      null,
+      2,
+    )})`,
+    "",
+  ].join("\n")
+  const kotlin = [
+    "package com.glassly.bluetoothsdk",
+    "",
+    "/** Generated by release CI. Do not edit in a release checkout. */",
+    "internal object GeneratedReleaseMetadata {",
+    `    const val FAMILY_BASE_VERSION: String = ${JSON.stringify(metadata.familyBaseVersion)}`,
+    `    const val RELEASE_IDENTITY: String = ${JSON.stringify(metadata.releaseIdentity)}`,
+    `    const val RELEASE_SET_ID: String = ${JSON.stringify(metadata.releaseSetId)}`,
+    `    const val SOURCE_COMMIT: String = ${JSON.stringify(metadata.sourceCommit)}`,
+    `    const val OTA_MANIFEST_URL: String = ${JSON.stringify(metadata.otaManifestUrl)}`,
+    `    const val OTA_MANIFEST_SHA256: String = ${JSON.stringify(metadata.otaManifestSha256)}`,
+    "}",
+    "",
+  ].join("\n")
+  const swift = [
+    "import Foundation",
+    "",
+    "/// Generated by release CI. Do not edit in a release checkout.",
+    "enum GeneratedReleaseMetadata {",
+    `    static let familyBaseVersion = ${swiftString(metadata.familyBaseVersion)}`,
+    `    static let releaseIdentity = ${swiftString(metadata.releaseIdentity)}`,
+    `    static let releaseSetId = ${swiftString(metadata.releaseSetId)}`,
+    `    static let sourceCommit = ${swiftString(metadata.sourceCommit)}`,
+    `    static let otaManifestUrl = ${swiftString(metadata.otaManifestUrl)}`,
+    `    static let otaManifestSha256 = ${swiftString(metadata.otaManifestSha256)}`,
+    "}",
+    "",
+  ].join("\n")
+  return {metadata, typescript, kotlin, swift}
+}
+
+function parseArgs(args) {
+  const values = {}
+  for (let index = 0; index < args.length; index += 2) {
+    const option = args[index]
+    const value = args[index + 1]
+    if (!option?.startsWith("--") || value === undefined) throw new Error("Expected --name value pairs")
+    values[option.slice(2)] = value
+  }
+  return values
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2))
+  const required = ["family-base-version", "release-identity", "release-set-id", "source-commit"]
+  for (const field of required) if (!args[field]) throw new Error(`Missing --${field}`)
+  // --ota-manifest-url/--ota-manifest-sha256 are optional as a pair (absent
+  // when the OTA lane is disabled); validateReleaseMetadata enforces the rest.
+  const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
+  const rendered = renderReleaseMetadata({
+    familyBaseVersion: args["family-base-version"],
+    releaseIdentity: args["release-identity"],
+    releaseSetId: args["release-set-id"],
+    sourceCommit: args["source-commit"],
+    otaManifestUrl: args["ota-manifest-url"],
+    otaManifestSha256: args["ota-manifest-sha256"],
+  })
+  const outputs = {
+    typescript: path.join(packageRoot, "src/generated/releaseMetadata.ts"),
+    kotlin: path.join(packageRoot, "android/src/main/java/com/glassly/bluetoothsdk/GeneratedReleaseMetadata.kt"),
+    swift: path.join(packageRoot, "ios/Source/GeneratedReleaseMetadata.swift"),
+  }
+  for (const [target, file] of Object.entries(outputs)) {
+    mkdirSync(path.dirname(file), {recursive: true})
+    writeFileSync(file, rendered[target])
+  }
+  console.log(`Wrote Bluetooth SDK release metadata for ${rendered.metadata.releaseSetId}`)
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) main()

package/scripts/write-release-metadata.test.mjs

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+
+import {renderReleaseMetadata, validateReleaseMetadata} from "./write-release-metadata.mjs"
+
+const input = {
+  familyBaseVersion: "3.1.0",
+  releaseIdentity: "3.1.0-beta.57",
+  releaseSetId: "glassly-3.1.0-beta.57",
+  sourceCommit: "a".repeat(40),
+  otaManifestUrl:
+    "https://github.com/tetramo-labs/glassly/releases/download/glassly-3.1.0-beta.57/mentra-live-ota-3.1.0-beta.57.json",
+  otaManifestSha256: "b".repeat(64),
+}
+
+test("renders identical immutable metadata for TypeScript, Kotlin, and Swift", () => {
+  const rendered = renderReleaseMetadata(input)
+  for (const contents of [rendered.typescript, rendered.kotlin, rendered.swift]) {
+    assert.match(contents, /3\.1\.0-beta\.57/)
+    assert.match(contents, /mentra-live-ota-3\.1\.0-beta\.57\.json/)
+    assert.match(contents, new RegExp("b".repeat(64)))
+  }
+})
+
+test("rejects mutable or cross-family release metadata", () => {
+  assert.throws(() => validateReleaseMetadata({...input, releaseIdentity: "3.2.0-beta.57"}), /does not belong/)
+  assert.throws(() => validateReleaseMetadata({...input, otaManifestUrl: "http://example.com/version.json"}), /HTTPS/)
+  assert.throws(() => validateReleaseMetadata({...input, otaManifestSha256: "short"}), /SHA-256/)
+})
+
+test("records null OTA coordinates when the OTA lane is absent", () => {
+  const metadata = validateReleaseMetadata({...input, otaManifestUrl: undefined, otaManifestSha256: undefined})
+  assert.equal(metadata.otaManifestUrl, null)
+  assert.equal(metadata.otaManifestSha256, null)
+  // Both-or-neither: half a coordinate pair is still rejected.
+  assert.throws(() => validateReleaseMetadata({...input, otaManifestSha256: undefined}), /SHA-256/)
+})