arcane-os 0.5.9 → 0.5.11

package/docs/reference/inventory/package-api.json

@@ -0,0 +1,3194 @@
+{
+  "schemaVersion": 1,
+  "sdkVersion": "0.5.11",
+  "environment": {
+    "runtime": "Node.js for Node entrypoints; browser for browser-only entrypoints",
+    "minimumVersion": "22.23.2 for Node entrypoints",
+    "moduleSystem": "ESM"
+  },
+  "memberCount": 204,
+  "members": [
+    {
+      "id": "root:APP_BUNDLE_DESCRIPTOR_NAME",
+      "name": "APP_BUNDLE_DESCRIPTOR_NAME",
+      "displayName": "APP_BUNDLE_DESCRIPTOR_NAME",
+      "kind": "constant",
+      "signature": "const APP_BUNDLE_DESCRIPTOR_NAME",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/release-bundle"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Canonical descriptor filename stored in an external application release bundle.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:APP_BUNDLE_EXTENSION",
+      "name": "APP_BUNDLE_EXTENSION",
+      "displayName": "APP_BUNDLE_EXTENSION",
+      "kind": "constant",
+      "signature": "const APP_BUNDLE_EXTENSION",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/release-bundle"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Required filename extension for deterministic external application release bundles.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:APP_BUNDLE_FORMAT",
+      "name": "APP_BUNDLE_FORMAT",
+      "displayName": "APP_BUNDLE_FORMAT",
+      "kind": "constant",
+      "signature": "const APP_BUNDLE_FORMAT",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/release-bundle"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Canonical archive encoding used by external application release bundles.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:APP_BUNDLE_KIND",
+      "name": "APP_BUNDLE_KIND",
+      "displayName": "APP_BUNDLE_KIND",
+      "kind": "constant",
+      "signature": "const APP_BUNDLE_KIND",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/release-bundle"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Stable manifest kind identifying an Arcane application release bundle.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:APP_BUNDLE_MANIFEST_NAME",
+      "name": "APP_BUNDLE_MANIFEST_NAME",
+      "displayName": "APP_BUNDLE_MANIFEST_NAME",
+      "kind": "constant",
+      "signature": "const APP_BUNDLE_MANIFEST_NAME",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/release-bundle"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Canonical bundle-envelope manifest filename.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:APP_BUNDLE_RELEASE_PATH",
+      "name": "APP_BUNDLE_RELEASE_PATH",
+      "displayName": "APP_BUNDLE_RELEASE_PATH",
+      "kind": "constant",
+      "signature": "const APP_BUNDLE_RELEASE_PATH",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/release-bundle"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Canonical path of the packaged release manifest inside a bundle payload.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:APP_BUNDLE_SCHEMA_VERSION",
+      "name": "APP_BUNDLE_SCHEMA_VERSION",
+      "displayName": "APP_BUNDLE_SCHEMA_VERSION",
+      "kind": "constant",
+      "signature": "const APP_BUNDLE_SCHEMA_VERSION",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/release-bundle"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Current immutable bundle-envelope schema version.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:APP_BUNDLE_SUPPORTED_SDK_VERSIONS",
+      "name": "APP_BUNDLE_SUPPORTED_SDK_VERSIONS",
+      "displayName": "APP_BUNDLE_SUPPORTED_SDK_VERSIONS",
+      "kind": "constant",
+      "signature": "const APP_BUNDLE_SUPPORTED_SDK_VERSIONS",
+      "entrypoints": [
+        "arcane-os/release-bundle"
+      ],
+      "primaryImport": "arcane-os/release-bundle",
+      "group": "Packaging and release bundles",
+      "summary": "Exact SDK generations accepted by this bundle verifier.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:APP_CONFIG_NAME",
+      "name": "APP_CONFIG_NAME",
+      "displayName": "APP_CONFIG_NAME",
+      "kind": "constant",
+      "signature": "const APP_CONFIG_NAME",
+      "entrypoints": [
+        "arcane-os/packager"
+      ],
+      "primaryImport": "arcane-os/packager",
+      "group": "Packaging and release bundles",
+      "summary": "Canonical schema-1 application package configuration filename used by the packager.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:APP_DESCRIPTOR_NAME",
+      "name": "APP_DESCRIPTOR_NAME",
+      "displayName": "APP_DESCRIPTOR_NAME",
+      "kind": "constant",
+      "signature": "const APP_DESCRIPTOR_NAME",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Canonical schema-2 application descriptor filename.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:APP_DESCRIPTOR_SCHEMA_VERSION",
+      "name": "APP_DESCRIPTOR_SCHEMA_VERSION",
+      "displayName": "APP_DESCRIPTOR_SCHEMA_VERSION",
+      "kind": "constant",
+      "signature": "const APP_DESCRIPTOR_SCHEMA_VERSION",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Current authored application descriptor schema version.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:ARCANE_INTEGRATED_PROVIDER_RELATIVE_PATH",
+      "name": "ARCANE_INTEGRATED_PROVIDER_RELATIVE_PATH",
+      "displayName": "ARCANE_INTEGRATED_PROVIDER_RELATIVE_PATH",
+      "kind": "constant",
+      "signature": "const ARCANE_INTEGRATED_PROVIDER_RELATIVE_PATH",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/integrated-provider"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Frozen repository-relative path of Arcane OS's integrated shared-development provider.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:ARCANE_MACHINE_BUNDLE_VERSION",
+      "name": "ARCANE_MACHINE_BUNDLE_VERSION",
+      "displayName": "ARCANE_MACHINE_BUNDLE_VERSION",
+      "kind": "constant",
+      "signature": "const ARCANE_MACHINE_BUNDLE_VERSION",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Identity and protocol constants",
+      "summary": "Exact Arcane machine-bundle generation paired with this SDK runtime.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:ARCANE_NATIVE_PROVIDER_PATHS",
+      "name": "ARCANE_NATIVE_PROVIDER_PATHS",
+      "displayName": "ARCANE_NATIVE_PROVIDER_PATHS",
+      "kind": "constant",
+      "signature": "const ARCANE_NATIVE_PROVIDER_PATHS",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/native-provider"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Frozen target-to-provider path registry for native development providers.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:ARCANE_PROTOCOL",
+      "name": "ARCANE_PROTOCOL",
+      "displayName": "ARCANE_PROTOCOL",
+      "kind": "constant",
+      "signature": "const ARCANE_PROTOCOL",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Identity and protocol constants",
+      "summary": "Application-facing Arcane bridge protocol required by this SDK.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:ARCANE_UPSTREAM_REPOSITORY",
+      "name": "ARCANE_UPSTREAM_REPOSITORY",
+      "displayName": "ARCANE_UPSTREAM_REPOSITORY",
+      "kind": "constant",
+      "signature": "const ARCANE_UPSTREAM_REPOSITORY",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Identity and protocol constants",
+      "summary": "Canonical upstream Arcane OS repository URL.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:ArcaneError",
+      "name": "ArcaneError",
+      "displayName": "ArcaneError",
+      "kind": "class",
+      "signature": "new ArcaneError(code, message, {details, cause, exitCode}={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Errors",
+      "summary": "Normalized SDK error class carrying a stable code, human message, optional resolution details, cause, and exit status.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "ArcaneError and JSON-safe error normalization"
+    },
+    {
+      "id": "root:assertIntegratedNativeToolchain",
+      "name": "assertIntegratedNativeToolchain",
+      "displayName": "assertIntegratedNativeToolchain()",
+      "kind": "function",
+      "signature": "assertIntegratedNativeToolchain({workspaceMode, workspaceRoot, toolchainRoot, target}={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Requires an integrated workspace and selected native toolchain root to resolve to the same canonical Arcane checkout.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:assessArcaneOllama",
+      "name": "assessArcaneOllama",
+      "displayName": "assessArcaneOllama()",
+      "kind": "function",
+      "signature": "async assessArcaneOllama({ signal, onEvent, platform=process.platform, run=runProcess, fileExists=exists }={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Performs a read-only Microsoft NT assessment of the managed ArcaneOllama service and reports unsupported hosts honestly.",
+      "availability": "Node; Microsoft NT managed-service assessment",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:buildApplication",
+      "name": "buildApplication",
+      "displayName": "buildApplication()",
+      "kind": "function",
+      "signature": "async buildApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Packages the selected app and builds one explicitly selected target; tests or checks run only when explicitly requested or required for the selected release output.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:buildTarget",
+      "name": "buildTarget",
+      "displayName": "buildTarget()",
+      "kind": "function",
+      "signature": "async buildTarget(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/targets"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Invokes one target adapter build with explicit app, target, and artifact inputs.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:bumpVersion",
+      "name": "bumpVersion",
+      "displayName": "bumpVersion()",
+      "kind": "function",
+      "signature": "async bumpVersion(options)",
+      "entrypoints": [
+        "arcane-os/packager"
+      ],
+      "primaryImport": "arcane-os/packager",
+      "group": "Packaging and release bundles",
+      "summary": "Updates one selected app version with a validated semantic-version bump through the packager boundary.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:bundleApplication",
+      "name": "bundleApplication",
+      "displayName": "bundleApplication()",
+      "kind": "function",
+      "signature": "async bundleApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Creates one deterministic external application bundle from one authenticated packaged release.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:checkApplication",
+      "name": "checkApplication",
+      "displayName": "checkApplication()",
+      "kind": "function",
+      "signature": "async checkApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Runs the selected application or integrated shared validation boundary.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:CLI_EVENT_PROTOCOL",
+      "name": "CLI_EVENT_PROTOCOL",
+      "displayName": "CLI_EVENT_PROTOCOL",
+      "kind": "constant",
+      "signature": "const CLI_EVENT_PROTOCOL",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Identity and protocol constants",
+      "summary": "Version identifier for normalized CLI JSON and NDJSON event envelopes.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:CLI_NAME",
+      "name": "CLI_NAME",
+      "displayName": "CLI_NAME",
+      "kind": "constant",
+      "signature": "const CLI_NAME",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Identity and protocol constants",
+      "summary": "Primary command name presented by the SDK.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:createApplication",
+      "name": "createApplication",
+      "displayName": "createApplication()",
+      "kind": "function",
+      "signature": "async createApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Creates one new external application workspace through the shared headless toolchain.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:createAppReleaseBundle",
+      "name": "createAppReleaseBundle",
+      "displayName": "createAppReleaseBundle()",
+      "kind": "function",
+      "signature": "async createAppReleaseBundle({ receipt, releaseRoot, outputPath, overwrite=false, signal, onEvent }={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/release-bundle"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Writes one deterministic USTAR+gzip external application bundle from the selected authored release state.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:createCanonicalUstarHeader",
+      "name": "createCanonicalUstarHeader",
+      "displayName": "createCanonicalUstarHeader()",
+      "kind": "function",
+      "signature": "createCanonicalUstarHeader(entryPath, size)",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/release-bundle"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Builds the exact 512-byte canonical USTAR header for one validated bundle entry.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:createNativeBuildPlan",
+      "name": "createNativeBuildPlan",
+      "displayName": "createNativeBuildPlan()",
+      "kind": "function",
+      "signature": "async createNativeBuildPlan({ nativeBuilder, toolchainRoot, toolchainReceipt, appReleaseRoot, appReleaseReceipt, appDescriptor, dependencyReleases=[], providerGeneration, minimumCoreVersion, protectedRoots=[], outputRoot, targetRequest, signal, onEvent }={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/native"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Creates one immutable, authenticated, single-attempt native plan binding app, dependencies, toolchain, request, and output roots.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:createNativeTargetAdapter",
+      "name": "createNativeTargetAdapter",
+      "displayName": "createNativeTargetAdapter()",
+      "kind": "function",
+      "signature": "createNativeTargetAdapter({targetId, nativeBuilder}={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/targets"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Adapts one validated native builder to the common target-adapter contract.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:createReporter",
+      "name": "createReporter",
+      "displayName": "createReporter()",
+      "kind": "function",
+      "signature": "createReporter({ command, output='human', stdout=process.stdout, stderr=process.stderr, operationId=randomUUID(), clock=()=>new Date() }={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/events"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Events, processes, and testing",
+      "summary": "Creates the ordered CLI reporter that normalizes accepted, progress, terminal, JSON, and NDJSON event delivery.",
+      "availability": "Node",
+      "protocol": "arcane-cli-events/1",
+      "normalization": "SDK event/error/report normalization"
+    },
+    {
+      "id": "root:createToolchain",
+      "name": "createToolchain",
+      "displayName": "createToolchain()",
+      "kind": "function",
+      "signature": "createToolchain(defaults={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Returns a frozen convenience object that applies shared defaults to every headless application operation.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:createWorkspace",
+      "name": "createWorkspace",
+      "displayName": "createWorkspace()",
+      "kind": "function",
+      "signature": "async createWorkspace({ targetPath, appId, displayName, target='browser', initializeGit=false, signal, onEvent })",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Scaffolds one new external repository-shaped workspace and one selected application.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:default",
+      "name": "default",
+      "displayName": "default()",
+      "kind": "function",
+      "signature": "default(name, optionsOrCallback, maybeCallback)",
+      "entrypoints": [
+        "arcane-os/testing"
+      ],
+      "primaryImport": "arcane-os/testing",
+      "group": "Events, processes, and testing",
+      "summary": "Default-export alias of the public `test` registration function.",
+      "availability": "Node",
+      "protocol": "Node ESM / owned process or test lifecycle",
+      "normalization": "SDK event/error/report normalization"
+    },
+    {
+      "id": "root:DEFAULT_TEST_TIMEOUT_MS",
+      "name": "DEFAULT_TEST_TIMEOUT_MS",
+      "displayName": "DEFAULT_TEST_TIMEOUT_MS",
+      "kind": "constant",
+      "signature": "const DEFAULT_TEST_TIMEOUT_MS",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/testing"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Events, processes, and testing",
+      "summary": "Default timeout applied by the public isolated test API.",
+      "availability": "Node",
+      "protocol": "Node ESM / owned process or test lifecycle",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:describeTargets",
+      "name": "describeTargets",
+      "displayName": "describeTargets()",
+      "kind": "function",
+      "signature": "async describeTargets(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Returns the normalized target catalog through the headless operation lifecycle.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:developApplication",
+      "name": "developApplication",
+      "displayName": "developApplication()",
+      "kind": "function",
+      "signature": "async developApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Starts one owned browser development server for the selected application.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:discoverPackagerApps",
+      "name": "discoverPackagerApps",
+      "displayName": "discoverPackagerApps()",
+      "kind": "function",
+      "signature": "async discoverPackagerApps({workspaceRoot:requestedWorkspaceRoot})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Root-entry alias for the packager-specific application discovery function.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:doctorApplication",
+      "name": "doctorApplication",
+      "displayName": "doctorApplication()",
+      "kind": "function",
+      "signature": "async doctorApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Runs the read-only SDK/runtime/workspace and optional local-AI diagnostic operation.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:doctorNativeTarget",
+      "name": "doctorNativeTarget",
+      "displayName": "doctorNativeTarget()",
+      "kind": "function",
+      "signature": "async doctorNativeTarget(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Loads and diagnoses one explicit native provider and target without building an application.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:ERROR_CODES",
+      "name": "ERROR_CODES",
+      "displayName": "ERROR_CODES",
+      "kind": "constant",
+      "signature": "const ERROR_CODES",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Errors",
+      "summary": "Frozen registry of stable SDK error-code strings.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:errorRecord",
+      "name": "errorRecord",
+      "displayName": "errorRecord()",
+      "kind": "function",
+      "signature": "errorRecord(error)",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Errors",
+      "summary": "Projects an error into the JSON-safe normalized public error record.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "ArcaneError and JSON-safe error normalization"
+    },
+    {
+      "id": "root:executeNativeBuildPlan",
+      "name": "executeNativeBuildPlan",
+      "displayName": "executeNativeBuildPlan()",
+      "kind": "function",
+      "signature": "async executeNativeBuildPlan(plan, { expectedNativeBuilder, expectedTarget, signal, onEvent }={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/native"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Consumes one authenticated single-attempt native plan through its bound builder and event/cancellation lifecycle.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:executeOperation",
+      "name": "executeOperation",
+      "displayName": "executeOperation()",
+      "kind": "function",
+      "signature": "async executeOperation(command, options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Dispatches one named headless SDK operation with normalized acceptance, events, cancellation, and failure.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:fail",
+      "name": "fail",
+      "displayName": "fail()",
+      "kind": "function",
+      "signature": "fail(code, message, options)",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Errors",
+      "summary": "Throws a normalized `ArcaneError` with the supplied code and context.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "ArcaneError and JSON-safe error normalization"
+    },
+    {
+      "id": "root:getSdkBrowserRuntimeRoot",
+      "name": "getSdkBrowserRuntimeRoot",
+      "displayName": "getSdkBrowserRuntimeRoot()",
+      "kind": "function",
+      "signature": "getSdkBrowserRuntimeRoot()",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Returns the absolute SDK browser-runtime root.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:getSdkRoot",
+      "name": "getSdkRoot",
+      "displayName": "getSdkRoot()",
+      "kind": "function",
+      "signature": "getSdkRoot()",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Returns the absolute installed SDK package root.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:getTargetAdapter",
+      "name": "getTargetAdapter",
+      "displayName": "getTargetAdapter()",
+      "kind": "function",
+      "signature": "getTargetAdapter(targetId)",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/targets"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Returns the registered adapter for one exact target id or fails for an unknown target.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:incrementSemver",
+      "name": "incrementSemver",
+      "displayName": "incrementSemver()",
+      "kind": "function",
+      "signature": "incrementSemver(value, bump, preid)",
+      "entrypoints": [
+        "arcane-os/packager"
+      ],
+      "primaryImport": "arcane-os/packager",
+      "group": "Packaging and release bundles",
+      "summary": "Returns a validated semantic version incremented by the requested bump and optional prerelease id.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:initializeApplication",
+      "name": "initializeApplication",
+      "displayName": "initializeApplication()",
+      "kind": "function",
+      "signature": "async initializeApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Initializes missing Arcane files for one app in an existing external or integrated workspace.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:initWorkspace",
+      "name": "initWorkspace",
+      "displayName": "initWorkspace()",
+      "kind": "function",
+      "signature": "async initWorkspace({ workspaceRoot=process.cwd(), appId, displayName, target='browser', signal, onEvent })",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Adds one application scaffold to an existing workspace without overwriting incompatible files.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:inspectApp",
+      "name": "inspectApp",
+      "displayName": "inspectApp()",
+      "kind": "function",
+      "signature": "async inspectApp({workspaceRoot, appId, signal}={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/packager"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Loads one validated packager app plan, including the shared descriptor-admitted browser document inventory.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:inspectWorkspaceProfile",
+      "name": "inspectWorkspaceProfile",
+      "displayName": "inspectWorkspaceProfile()",
+      "kind": "function",
+      "signature": "async inspectWorkspaceProfile(workspaceRoot=process.cwd())",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Classifies one canonical workspace as external or integrated and reports its fixed layout.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:INTEGRATED_TOOLCHAIN_PROTOCOL",
+      "name": "INTEGRATED_TOOLCHAIN_PROTOCOL",
+      "displayName": "INTEGRATED_TOOLCHAIN_PROTOCOL",
+      "kind": "constant",
+      "signature": "const INTEGRATED_TOOLCHAIN_PROTOCOL",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/integrated-provider"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Protocol required from the fixed integrated shared-development provider.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:listTargets",
+      "name": "listTargets",
+      "displayName": "listTargets()",
+      "kind": "function",
+      "signature": "listTargets()",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/targets"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Returns the frozen target descriptors without running an operation lifecycle.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:loadAppDescriptor",
+      "name": "loadAppDescriptor",
+      "displayName": "loadAppDescriptor()",
+      "kind": "function",
+      "signature": "async loadAppDescriptor({workspaceRoot, appRoot, appId, packageManifest})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Loads an authored schema-2 descriptor or a complete package/registry projection with its source label.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:loadArcaneIntegratedProvider",
+      "name": "loadArcaneIntegratedProvider",
+      "displayName": "loadArcaneIntegratedProvider()",
+      "kind": "function",
+      "signature": "loadArcaneIntegratedProvider({ arcaneRoot, signal, onEvent, run=runProcess }={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/integrated-provider"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Loads and authenticates the fixed Arcane-owned integrated development provider generation.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:loadArcaneNativeProvider",
+      "name": "loadArcaneNativeProvider",
+      "displayName": "loadArcaneNativeProvider()",
+      "kind": "function",
+      "signature": "loadArcaneNativeProvider({ arcaneRoot, target, inspect=lstat, canonicalize=realpath, readModule=readFile, importModule=specifier=>import(specifier), generationCache=providerGenerationCache, signal, onEvent }={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/native-provider"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Loads the fixed provider for one target from an explicitly selected Arcane OS checkout and authenticates that provider generation for the current SDK process.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:listRuntimeFiles",
+      "name": "listRuntimeFiles",
+      "displayName": "listRuntimeFiles()",
+      "kind": "function",
+      "signature": "async listRuntimeFiles({runtimeRoot=path.join(sdkRoot, 'runtime'),signal}={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Lists the complete ordered relative-file inventory beneath one selected SDK runtime root.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:listSdkBrowserRuntimeFiles",
+      "name": "listSdkBrowserRuntimeFiles",
+      "displayName": "listSdkBrowserRuntimeFiles()",
+      "kind": "function",
+      "signature": "async listSdkBrowserRuntimeFiles({browserRuntimeRoot=defaultRoot,signal}={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Lists the complete ordered relative-file inventory beneath one selected SDK browser-runtime root.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:loadRuntimeRelease",
+      "name": "loadRuntimeRelease",
+      "displayName": "loadRuntimeRelease()",
+      "kind": "function",
+      "signature": "async loadRuntimeRelease({runtimeRoot=path.join(sdkRoot, 'runtime'),signal}={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Returns the selected runtime root, SDK version, and complete current file inventory derived from that directory.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:loadSdkBrowserRuntimeRelease",
+      "name": "loadSdkBrowserRuntimeRelease",
+      "displayName": "loadSdkBrowserRuntimeRelease()",
+      "kind": "function",
+      "signature": "async loadSdkBrowserRuntimeRelease({browserRuntimeRoot=defaultRoot,signal}={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Returns the selected browser-runtime root, SDK version, and complete current file inventory derived from that directory.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:materializeInstalledSdkRuntime",
+      "name": "materializeInstalledSdkRuntime",
+      "displayName": "materializeInstalledSdkRuntime()",
+      "kind": "function",
+      "signature": "async materializeInstalledSdkRuntime({workspaceRoot,sdkPackageSource,workspaceOperationLease,signal,onEvent}={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Materializes the complete installed SDK runtime and browser runtime, then replaces semantic arcane.lock.json metadata from the actual installed dependency and package.",
+      "availability": "Node",
+      "protocol": "Installed SDK runtime materialization",
+      "normalization": "Complete installed runtime content and a mutable materialization result"
+    },
+    {
+      "id": "root:materializeWorkspaceRuntimeContent",
+      "name": "materializeWorkspaceRuntimeContent",
+      "displayName": "materializeWorkspaceRuntimeContent()",
+      "kind": "function",
+      "signature": "async materializeWorkspaceRuntimeContent({workspaceRoot,runtimeRoot=path.join(getSdkRoot(), 'runtime'),browserRuntimeRoot=getSdkBrowserRuntimeRoot(),signal,onEvent}={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Replaces one workspace's complete projected runtime and browser-runtime content from selected source roots.",
+      "availability": "Node",
+      "protocol": "Workspace runtime materialization",
+      "normalization": "Complete workspace runtime content and a mutable materialization result"
+    },
+    {
+      "id": "root:NATIVE_BUILD_PLAN_PROTOCOL",
+      "name": "NATIVE_BUILD_PLAN_PROTOCOL",
+      "displayName": "NATIVE_BUILD_PLAN_PROTOCOL",
+      "kind": "constant",
+      "signature": "const NATIVE_BUILD_PLAN_PROTOCOL",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/native"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Protocol identifier for immutable authenticated native build plans.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:NATIVE_BUILDER_PROTOCOL",
+      "name": "NATIVE_BUILDER_PROTOCOL",
+      "displayName": "NATIVE_BUILDER_PROTOCOL",
+      "kind": "constant",
+      "signature": "const NATIVE_BUILDER_PROTOCOL",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/native"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Protocol identifier required from injected native builders.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:normalizeError",
+      "name": "normalizeError",
+      "displayName": "normalizeError()",
+      "kind": "function",
+      "signature": "normalizeError(error, fallbackCode=ERROR_CODES.operationFailed)",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Errors",
+      "summary": "Converts an unknown thrown value into an `ArcaneError` while preserving an existing normalized error.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "ArcaneError and JSON-safe error normalization"
+    },
+    {
+      "id": "root:normalizeRelativePath",
+      "name": "normalizeRelativePath",
+      "displayName": "normalizeRelativePath()",
+      "kind": "function",
+      "signature": "normalizeRelativePath(value, label='path')",
+      "entrypoints": [
+        "arcane-os/packager"
+      ],
+      "primaryImport": "arcane-os/packager",
+      "group": "Packaging and release bundles",
+      "summary": "Normalizes one portable repository-relative path and rejects traversal, aliases, links, and unsafe names.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:OUTPUT_MODES",
+      "name": "OUTPUT_MODES",
+      "displayName": "OUTPUT_MODES",
+      "kind": "constant",
+      "signature": "const OUTPUT_MODES",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Identity and protocol constants",
+      "summary": "Frozen supported CLI output modes: human, JSON, and NDJSON.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:packageApp",
+      "name": "packageApp",
+      "displayName": "packageApp()",
+      "kind": "function",
+      "signature": "async packageApp(options)",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/packager"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Builds one selected browser application release through the low-level packager API; it never runs tests or checks automatically.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:packageApplication",
+      "name": "packageApplication",
+      "displayName": "packageApplication()",
+      "kind": "function",
+      "signature": "async packageApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Runs the high-level package operation for one selected application.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:PACKAGER_VERSION",
+      "name": "PACKAGER_VERSION",
+      "displayName": "PACKAGER_VERSION",
+      "kind": "constant",
+      "signature": "const PACKAGER_VERSION",
+      "entrypoints": [
+        "arcane-os/packager"
+      ],
+      "primaryImport": "arcane-os/packager",
+      "group": "Packaging and release bundles",
+      "summary": "Builder identity written into schema-1 application release manifests.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "packager:discoverApps",
+      "name": "discoverApps",
+      "displayName": "packager.discoverApps()",
+      "kind": "function",
+      "signature": "async discoverApps({workspaceRoot:requestedWorkspaceRoot})",
+      "entrypoints": [
+        "arcane-os/packager"
+      ],
+      "primaryImport": "arcane-os/packager",
+      "group": "Packaging and release bundles",
+      "summary": "Discovers packager application configurations and release boundaries beneath one workspace root.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:parseSemver",
+      "name": "parseSemver",
+      "displayName": "parseSemver()",
+      "kind": "function",
+      "signature": "parseSemver(value)",
+      "entrypoints": [
+        "arcane-os/packager"
+      ],
+      "primaryImport": "arcane-os/packager",
+      "group": "Packaging and release bundles",
+      "summary": "Parses one strict three-part semantic version with optional prerelease metadata.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:planApplication",
+      "name": "planApplication",
+      "displayName": "planApplication()",
+      "kind": "function",
+      "signature": "async planApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Creates one authenticated native build plan without executing the provider build.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:prepareNativeTarget",
+      "name": "prepareNativeTarget",
+      "displayName": "prepareNativeTarget()",
+      "kind": "function",
+      "signature": "async prepareNativeTarget(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Runs one provider toolchain preparation and returns its process-owned result.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:projectNativeDescriptor",
+      "name": "projectNativeDescriptor",
+      "displayName": "projectNativeDescriptor()",
+      "kind": "function",
+      "signature": "projectNativeDescriptor(descriptor, {source}={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Projects the canonical app descriptor into the native registry shape consumed by paired builders.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:projectPackageManifest",
+      "name": "projectPackageManifest",
+      "displayName": "projectPackageManifest()",
+      "kind": "function",
+      "signature": "projectPackageManifest(descriptor)",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Projects a schema-2 descriptor into the compatible schema-1 application package contract.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "preference-store:default",
+      "name": "default",
+      "displayName": "PreferenceStore default export",
+      "kind": "class",
+      "signature": "default class PreferenceStore extends EventTarget",
+      "entrypoints": ["arcane-os/preference-store"],
+      "primaryImport": "arcane-os/preference-store",
+      "group": "Portable runtime modules",
+      "summary": "Default binding for the canonical PreferenceStore runtime class in Node and managed browsers.",
+      "availability": "Node with injected adapters, or browser/native WebView storage",
+      "protocol": "Node ESM / authenticated managed browser import map",
+      "normalization": "Binding identity and namespace come directly from the canonical runtime module"
+    },
+    {
+      "id": "preference-store:PREFERENCE_STORE_ERROR_CODES",
+      "name": "PREFERENCE_STORE_ERROR_CODES",
+      "displayName": "PREFERENCE_STORE_ERROR_CODES",
+      "kind": "constant",
+      "signature": "const PREFERENCE_STORE_ERROR_CODES",
+      "entrypoints": ["arcane-os/preference-store"],
+      "primaryImport": "arcane-os/preference-store",
+      "group": "Portable runtime modules",
+      "summary": "Frozen stable error-code vocabulary emitted by PreferenceStore.",
+      "availability": "Node and browser",
+      "protocol": "PreferenceStore runtime contract",
+      "normalization": "Exact immutable code names from the canonical runtime module"
+    },
+    {
+      "id": "preference-store:PREFERENCE_STORE_EVENT_TYPES",
+      "name": "PREFERENCE_STORE_EVENT_TYPES",
+      "displayName": "PREFERENCE_STORE_EVENT_TYPES",
+      "kind": "constant",
+      "signature": "const PREFERENCE_STORE_EVENT_TYPES",
+      "entrypoints": ["arcane-os/preference-store"],
+      "primaryImport": "arcane-os/preference-store",
+      "group": "Portable runtime modules",
+      "summary": "Frozen semantic event names published by PreferenceStore.",
+      "availability": "Node and browser",
+      "protocol": "PreferenceStore runtime contract",
+      "normalization": "Exact load, change, and reset event names"
+    },
+    {
+      "id": "preference-store:Preference",
+      "name": "Preference",
+      "displayName": "Preference",
+      "kind": "class",
+      "signature": "new Preference(data={})",
+      "entrypoints": ["arcane-os/preference-store"],
+      "primaryImport": "arcane-os/preference-store",
+      "group": "Portable runtime modules",
+      "summary": "Canonical Preference entity re-exported with the store namespace.",
+      "availability": "Node and browser",
+      "protocol": "Preference entity schema",
+      "normalization": "Canonical entity validation and serialization"
+    },
+    {
+      "id": "preference-store:preferenceSchema",
+      "name": "preferenceSchema",
+      "displayName": "preferenceSchema()",
+      "kind": "function",
+      "signature": "preferenceSchema(definitions=[])",
+      "entrypoints": ["arcane-os/preference-store"],
+      "primaryImport": "arcane-os/preference-store",
+      "group": "Portable runtime modules",
+      "summary": "Builds the canonical Preference strong-type schema for an admitted definition set.",
+      "availability": "Node and browser",
+      "protocol": "Preference entity schema",
+      "normalization": "Returns the canonical runtime schema for the supplied definitions"
+    },
+    {
+      "id": "speech-playback:default",
+      "name": "default",
+      "displayName": "SpeechPlayback default export",
+      "kind": "class",
+      "signature": "default class SpeechPlayback",
+      "entrypoints": ["arcane-os/speech-playback"],
+      "primaryImport": "arcane-os/speech-playback",
+      "group": "Portable runtime modules",
+      "summary": "Default binding for the canonical SpeechPlayback runtime class in Node and managed browsers.",
+      "availability": "Node with injected media adapters, or browser/native WebView media",
+      "protocol": "SpeechPlayback runtime contract",
+      "normalization": "Binding identity and namespace come directly from the canonical runtime module"
+    },
+    {
+      "id": "speech-playback:SPEECH_PLAYBACK_STATE_EVENT",
+      "name": "SPEECH_PLAYBACK_STATE_EVENT",
+      "displayName": "SPEECH_PLAYBACK_STATE_EVENT",
+      "kind": "constant",
+      "signature": "const SPEECH_PLAYBACK_STATE_EVENT",
+      "entrypoints": ["arcane-os/speech-playback"],
+      "primaryImport": "arcane-os/speech-playback",
+      "group": "Portable runtime modules",
+      "summary": "Canonical semantic event name for SpeechPlayback state transitions.",
+      "availability": "Node and browser",
+      "protocol": "SpeechPlayback runtime contract",
+      "normalization": "Exact immutable speech-playback-state event name"
+    },
+    {
+      "id": "speech-playback:SpeechPlayback",
+      "name": "SpeechPlayback",
+      "displayName": "SpeechPlayback",
+      "kind": "class",
+      "signature": "new SpeechPlayback(options={})",
+      "entrypoints": ["arcane-os/speech-playback"],
+      "primaryImport": "arcane-os/speech-playback",
+      "group": "Portable runtime modules",
+      "summary": "Named binding for the same canonical class exposed as the subpath default.",
+      "availability": "Node with injected media adapters, or browser/native WebView media",
+      "protocol": "SpeechPlayback runtime contract",
+      "normalization": "Binding identity equals the default export; prepare preserves each nonblank part input exactly without trimming, splitting, or freezing it; provider and media availability remain host-owned"
+    },
+    {
+      "id": "speech-playback:splitSpeechText",
+      "name": "splitSpeechText",
+      "displayName": "splitSpeechText()",
+      "kind": "function",
+      "signature": "splitSpeechText(value='')",
+      "entrypoints": ["arcane-os/speech-playback"],
+      "primaryImport": "arcane-os/speech-playback",
+      "group": "Portable runtime modules",
+      "summary": "Returns the caller's exact nonblank speech text as one segment.",
+      "availability": "Node and browser",
+      "protocol": "SpeechPlayback runtime contract",
+      "normalization": "Uses trimming only to detect blank input; nonblank text is returned unchanged in one mutable array without trimming, splitting, or freezing"
+    },
+    {
+      "id": "root:readRuntimeFile",
+      "name": "readRuntimeFile",
+      "displayName": "readRuntimeFile()",
+      "kind": "function",
+      "signature": "async readRuntimeFile({runtimeRoot=path.join(sdkRoot, 'runtime'),relativePath,signal}={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Reads one complete contained file from a selected SDK runtime root.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:readSdkBrowserRuntimeFile",
+      "name": "readSdkBrowserRuntimeFile",
+      "displayName": "readSdkBrowserRuntimeFile()",
+      "kind": "function",
+      "signature": "async readSdkBrowserRuntimeFile({browserRuntimeRoot=defaultRoot,relativePath,signal}={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Reads one complete contained file from a selected SDK browser-runtime root.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:registeredTestCount",
+      "name": "registeredTestCount",
+      "displayName": "registeredTestCount()",
+      "kind": "function",
+      "signature": "registeredTestCount()",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/testing"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Events, processes, and testing",
+      "summary": "Returns the number of tests registered in the current isolated test realm.",
+      "availability": "Node",
+      "protocol": "Node ESM / owned process or test lifecycle",
+      "normalization": "SDK event/error/report normalization"
+    },
+    {
+      "id": "root:RELEASE_MANIFEST_NAME",
+      "name": "RELEASE_MANIFEST_NAME",
+      "displayName": "RELEASE_MANIFEST_NAME",
+      "kind": "constant",
+      "signature": "const RELEASE_MANIFEST_NAME",
+      "entrypoints": [
+        "arcane-os/packager"
+      ],
+      "primaryImport": "arcane-os/packager",
+      "group": "Packaging and release bundles",
+      "summary": "Canonical packaged application release manifest filename.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:repositoryApplication",
+      "name": "repositoryApplication",
+      "displayName": "repositoryApplication()",
+      "kind": "function",
+      "signature": "async repositoryApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Dispatches one selected repository status, pull, or push operation through the headless lifecycle.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:repositoryPull",
+      "name": "repositoryPull",
+      "displayName": "repositoryPull()",
+      "kind": "function",
+      "signature": "async repositoryPull({ workspaceRoot=process.cwd(), signal, onEvent, run=runProcess }={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Runs one fast-forward-only pull after proving the selected repository worktree is clean.",
+      "availability": "Node; network-assisted Git",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:repositoryPush",
+      "name": "repositoryPush",
+      "displayName": "repositoryPush()",
+      "kind": "function",
+      "signature": "async repositoryPush({ workspaceRoot=process.cwd(), signal, onEvent, run=runProcess }={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Pushes the selected attached branch through the repository's configured remote and credentials.",
+      "availability": "Node; network-assisted Git",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:repositoryStatus",
+      "name": "repositoryStatus",
+      "displayName": "repositoryStatus()",
+      "kind": "function",
+      "signature": "async repositoryStatus({ workspaceRoot=process.cwd(), signal, onEvent, run=runProcess }={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Reads one repository's branch and short worktree status through an owned child process.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:resolveNativeBuildOutputRoot",
+      "name": "resolveNativeBuildOutputRoot",
+      "displayName": "resolveNativeBuildOutputRoot()",
+      "kind": "function",
+      "signature": "resolveNativeBuildOutputRoot({target, workspaceMode, workspaceRoot, outputRoot}={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Resolves and validates one native output root, including integrated-checkout non-overlap.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:resolveWorkspace",
+      "name": "resolveWorkspace",
+      "displayName": "resolveWorkspace()",
+      "kind": "function",
+      "signature": "async resolveWorkspace({workspaceRoot=process.cwd(), appId}={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Resolves one workspace profile and selected app into canonical SDK paths.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:ROOT_CONFIG_NAME",
+      "name": "ROOT_CONFIG_NAME",
+      "displayName": "ROOT_CONFIG_NAME",
+      "kind": "constant",
+      "signature": "const ROOT_CONFIG_NAME",
+      "entrypoints": [
+        "arcane-os/packager"
+      ],
+      "primaryImport": "arcane-os/packager",
+      "group": "Packaging and release bundles",
+      "summary": "Canonical root packager configuration filename.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:discoverApps",
+      "name": "discoverApps",
+      "displayName": "discoverApps()",
+      "kind": "function",
+      "signature": "async discoverApps(workspaceRoot=process.cwd())",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Discovers application ids in one external or integrated workspace without selecting one.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:runApplication",
+      "name": "runApplication",
+      "displayName": "runApplication()",
+      "kind": "function",
+      "signature": "async runApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Runs a browser app or performs the retained native build/verify/launch lifecycle for one target.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:runDoctor",
+      "name": "runDoctor",
+      "displayName": "runDoctor()",
+      "kind": "function",
+      "signature": "async runDoctor({ workspaceRoot, appId, arcaneRoot, requireLocalAI=false, signal, onEvent, platform=process.platform, run=runProcess }={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Runs the underlying read-only doctor checks and returns their normalized report.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:runProcess",
+      "name": "runProcess",
+      "displayName": "runProcess()",
+      "kind": "function",
+      "signature": "async runProcess(command, args=[], { cwd, env, signal, onEvent, heartbeatMs=5000, terminationGraceMs=DEFAULT_TERMINATION_GRACE_MS, allowNonzero=false, input }={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Events, processes, and testing",
+      "summary": "Runs one shell-free child command with complete stdout and stderr, ordered stream events, heartbeats, and process-tree cancellation.",
+      "availability": "Node",
+      "protocol": "Node ESM / owned process or test lifecycle",
+      "normalization": "SDK event/error/report normalization"
+    },
+    {
+      "id": "root:runRegisteredTests",
+      "name": "runRegisteredTests",
+      "displayName": "runRegisteredTests()",
+      "kind": "function",
+      "signature": "async runRegisteredTests({signal, requireTests=true, onPhase}={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/testing"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Events, processes, and testing",
+      "summary": "Executes the current isolated realm's registered tests once and returns the normalized Vanilla Test report.",
+      "availability": "Node",
+      "protocol": "Node ESM / owned process or test lifecycle",
+      "normalization": "SDK event/error/report normalization"
+    },
+    {
+      "id": "root:runRepositoryAction",
+      "name": "runRepositoryAction",
+      "displayName": "runRepositoryAction()",
+      "kind": "function",
+      "signature": "async runRepositoryAction(action, options={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Selects and runs one repository action by name.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:runTarget",
+      "name": "runTarget",
+      "displayName": "runTarget()",
+      "kind": "function",
+      "signature": "async runTarget(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/targets"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Invokes one target adapter run method and fails honestly when the artifact kind is not runnable.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:RUNTIME_ROOT",
+      "name": "RUNTIME_ROOT",
+      "displayName": "RUNTIME_ROOT",
+      "kind": "constant",
+      "signature": "const RUNTIME_ROOT",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Identity and protocol constants",
+      "summary": "Absolute installed SDK runtime directory for the current process.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:SDK_NAME",
+      "name": "SDK_NAME",
+      "displayName": "SDK_NAME",
+      "kind": "constant",
+      "signature": "const SDK_NAME",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Identity and protocol constants",
+      "summary": "Published npm package name.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:SDK_ROOT",
+      "name": "SDK_ROOT",
+      "displayName": "SDK_ROOT",
+      "kind": "constant",
+      "signature": "const SDK_ROOT",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Identity and protocol constants",
+      "summary": "Absolute installed package root for the current process.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:SDK_VERSION",
+      "name": "SDK_VERSION",
+      "displayName": "SDK_VERSION",
+      "kind": "constant",
+      "signature": "const SDK_VERSION",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Identity and protocol constants",
+      "summary": "Exact SDK package version.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:selectApp",
+      "name": "selectApp",
+      "displayName": "selectApp()",
+      "kind": "function",
+      "signature": "async selectApp(workspaceRoot=process.cwd(), appId)",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Selects one exact app id, or requires an unambiguous single discovered application.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:startDevServer",
+      "name": "startDevServer",
+      "displayName": "startDevServer()",
+      "kind": "function",
+      "signature": "async startDevServer(options={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Starts one owned browser development server with exact runtime/app route mappings and an unguessable session capability.",
+      "availability": "Node control plane; browser data plane",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:startSourceExampleServer",
+      "name": "startSourceExampleServer",
+      "displayName": "startSourceExampleServer()",
+      "kind": "function",
+      "signature": "async startSourceExampleServer(options={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Starts a generic source-example server over explicit directory mounts with complete streaming and HTTP range transport.",
+      "availability": "Node control plane; browser data plane",
+      "protocol": "Node ESM and HTTP/1.1 static source transport",
+      "normalization": "Explicit URL mounts, optional file inclusion lists, lazy missing directories, and a closeable server result"
+    },
+    {
+      "id": "root:TARGET_ADAPTER_PROTOCOL",
+      "name": "TARGET_ADAPTER_PROTOCOL",
+      "displayName": "TARGET_ADAPTER_PROTOCOL",
+      "kind": "constant",
+      "signature": "const TARGET_ADAPTER_PROTOCOL",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Protocol required from target adapter descriptors and implementations.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:TARGET_IDS",
+      "name": "TARGET_IDS",
+      "displayName": "TARGET_IDS",
+      "kind": "constant",
+      "signature": "const TARGET_IDS",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Frozen list of currently exposed target identifiers.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Exact immutable SDK value"
+    },
+    {
+      "id": "root:test",
+      "name": "test",
+      "displayName": "test()",
+      "kind": "function",
+      "signature": "test(name, optionsOrCallback, maybeCallback)",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/testing"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Events, processes, and testing",
+      "summary": "Registers one public test, optional timeout, callback, nested cases, and FIFO cleanup in the isolated runner.",
+      "availability": "Node",
+      "protocol": "Node ESM / owned process or test lifecycle",
+      "normalization": "SDK event/error/report normalization"
+    },
+    {
+      "id": "root:testApplication",
+      "name": "testApplication",
+      "displayName": "testApplication()",
+      "kind": "function",
+      "signature": "async testApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Runs the selected application's exact test boundary or one integrated shared test.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:throwIfAborted",
+      "name": "throwIfAborted",
+      "displayName": "throwIfAborted()",
+      "kind": "function",
+      "signature": "throwIfAborted(signal)",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Errors",
+      "summary": "Throws the signal reason or a normalized cancellation error when an AbortSignal is already aborted.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "ArcaneError and JSON-safe error normalization"
+    },
+    {
+      "id": "root:validateAppBundlePath",
+      "name": "validateAppBundlePath",
+      "displayName": "validateAppBundlePath()",
+      "kind": "function",
+      "signature": "validateAppBundlePath(value, label='bundle path')",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/release-bundle"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Validates and normalizes one portable path admitted inside an external app bundle.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:validateAppConfig",
+      "name": "validateAppConfig",
+      "displayName": "validateAppConfig()",
+      "kind": "function",
+      "signature": "validateAppConfig(value, appId, rootConfig, configPath=`apps/${appId}/${APP_CONFIG_NAME}`)",
+      "entrypoints": [
+        "arcane-os/packager"
+      ],
+      "primaryImport": "arcane-os/packager",
+      "group": "Packaging and release bundles",
+      "summary": "Validates one schema-1 packager app configuration and its relationship to the root config.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:validateAppDescriptor",
+      "name": "validateAppDescriptor",
+      "displayName": "validateAppDescriptor()",
+      "kind": "function",
+      "signature": "validateAppDescriptor(value, {appId}={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Runtime and app descriptors",
+      "summary": "Strictly validates and freezes one schema-2 app descriptor, including runtime-only cross-field rules.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:validateNativeBuilder",
+      "name": "validateNativeBuilder",
+      "displayName": "validateNativeBuilder()",
+      "kind": "function",
+      "signature": "validateNativeBuilder(provider)",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/native"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Validates a native builder's protocol and required describe/doctor/prepare/build/verify/run methods.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:validateRootConfig",
+      "name": "validateRootConfig",
+      "displayName": "validateRootConfig()",
+      "kind": "function",
+      "signature": "validateRootConfig(value, configPath=ROOT_CONFIG_NAME)",
+      "entrypoints": [
+        "arcane-os/packager"
+      ],
+      "primaryImport": "arcane-os/packager",
+      "group": "Packaging and release bundles",
+      "summary": "Validates one root packager mapping and its fixed shared-route boundaries.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:validateWorkspace",
+      "name": "validateWorkspace",
+      "displayName": "validateWorkspace()",
+      "kind": "function",
+      "signature": "async validateWorkspace({workspaceRoot=process.cwd(), appId, allowMissingManagedImportMap=false, signal, onEvent}={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Workspace, doctor, repository, and server",
+      "summary": "Runs canonical workspace, runtime, descriptor, selected-app, and exact installed-SDK validation with progress events.",
+      "availability": "Node",
+      "protocol": "Node ESM",
+      "normalization": "Returns a frozen workspace record and, for external workspaces, the exact canonical or npm-alias-bound SDK installation authority"
+    },
+    {
+      "id": "root:upgradeApplication",
+      "name": "upgradeApplication",
+      "displayName": "upgradeApplication()",
+      "kind": "function",
+      "signature": "async upgradeApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Runs an external application's ordinary npm upgrade command without a separate SDK lock, runtime, import-map, authentication, or reconciliation workflow.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "Returns a mutable application-upgrade record with the selected workspace fields and normal npm process result"
+    },
+    {
+      "id": "root:verifyApp",
+      "name": "verifyApp",
+      "displayName": "verifyApp()",
+      "kind": "function",
+      "signature": "async verifyApp({workspaceRoot, appId, signal, onEvent})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/packager"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Authenticates one existing browser app release through the low-level packager API.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:verifyApplication",
+      "name": "verifyApplication",
+      "displayName": "verifyApplication()",
+      "kind": "function",
+      "signature": "async verifyApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Runs the high-level verification operation for one selected browser release.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:verifyAppReleaseBundle",
+      "name": "verifyAppReleaseBundle",
+      "displayName": "verifyAppReleaseBundle()",
+      "kind": "function",
+      "signature": "async verifyAppReleaseBundle({bundlePath, signal, onEvent}={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/release-bundle"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Packaging and release bundles",
+      "summary": "Parses and authenticates one deterministic app bundle without extraction.",
+      "availability": "Node",
+      "protocol": "SDK packager and deterministic bundle contract",
+      "normalization": "Normalized SDK validation with complete canonical archive and release content"
+    },
+    {
+      "id": "root:verifyBundleApplication",
+      "name": "verifyBundleApplication",
+      "displayName": "verifyBundleApplication()",
+      "kind": "function",
+      "signature": "async verifyBundleApplication(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Headless toolchain operations",
+      "summary": "Runs the high-level external bundle verification operation.",
+      "availability": "Node; selected operation may produce browser or native output",
+      "protocol": "Shared headless operation API + arcane-cli-events/1",
+      "normalization": "SDK-normalized inputs, errors, events, and documented result"
+    },
+    {
+      "id": "root:verifyNativeArtifact",
+      "name": "verifyNativeArtifact",
+      "displayName": "verifyNativeArtifact()",
+      "kind": "function",
+      "signature": "async verifyNativeArtifact(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Explicitly verifies one selected target artifact through the prepared provider and toolchain state.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:verifyTarget",
+      "name": "verifyTarget",
+      "displayName": "verifyTarget()",
+      "kind": "function",
+      "signature": "async verifyTarget(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/targets"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Targets, native plans, and providers",
+      "summary": "Invokes one target adapter's artifact verification boundary.",
+      "availability": "Node; selected browser/native target or provider as documented",
+      "protocol": "arcane-target-adapter/1, arcane-native-build-plan/1, or provider protocol",
+      "normalization": "Normalized complete plan and result; target-specific artifact detail preserved"
+    },
+    {
+      "id": "root:ARCANE_EVENT_AUTHORITY_BRAND",
+      "name": "ARCANE_EVENT_AUTHORITY_BRAND",
+      "displayName": "ARCANE_EVENT_AUTHORITY_BRAND",
+      "kind": "constant",
+      "signature": "const ARCANE_EVENT_AUTHORITY_BRAND",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Global registry symbol used as a protocol marker on a created per-realm Arcane event authority.",
+      "availability": "Node and browser/bundler",
+      "protocol": "Symbol.for('arcane-os.arcane-events-authority') with arcane-event-authority/1",
+      "normalization": "Exact global symbol key; a created authority receives an enumerable, writable, configurable marker property"
+    },
+    {
+      "id": "root:ARCANE_EVENT_AUTHORITY_KIND",
+      "name": "ARCANE_EVENT_AUTHORITY_KIND",
+      "displayName": "ARCANE_EVENT_AUTHORITY_KIND",
+      "kind": "constant",
+      "signature": "const ARCANE_EVENT_AUTHORITY_KIND",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Identifies the canonical authority descriptor kind.",
+      "availability": "Node and browser/bundler",
+      "protocol": "arcane-event-authority",
+      "normalization": "Exact descriptor-kind discriminator"
+    },
+    {
+      "id": "root:ARCANE_EVENT_AUTHORITY_PROTOCOL",
+      "name": "ARCANE_EVENT_AUTHORITY_PROTOCOL",
+      "displayName": "ARCANE_EVENT_AUTHORITY_PROTOCOL",
+      "kind": "constant",
+      "signature": "const ARCANE_EVENT_AUTHORITY_PROTOCOL",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Identifies the current Arcane event-authority protocol.",
+      "availability": "Node and browser/bundler",
+      "protocol": "arcane-event-authority/1",
+      "normalization": "Exact authority protocol discriminator; a global with this protocol and the required callable API is reused, otherwise the module installs a new authority when possible"
+    },
+    {
+      "id": "root:ARCANE_EVENT_ERROR_CODES",
+      "name": "ARCANE_EVENT_ERROR_CODES",
+      "displayName": "ARCANE_EVENT_ERROR_CODES",
+      "kind": "constant",
+      "signature": "const ARCANE_EVENT_ERROR_CODES",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Mutable map of event-authority error-code names to their identical string values.",
+      "availability": "Node and browser/bundler",
+      "protocol": "arcane-event-authority/1 failures",
+      "normalization": "Exact mutable string-to-itself code map"
+    },
+    {
+      "id": "root:ARCANE_EVENT_LISTENER_ERROR_EVENT",
+      "name": "ARCANE_EVENT_LISTENER_ERROR_EVENT",
+      "displayName": "ARCANE_EVENT_LISTENER_ERROR_EVENT",
+      "kind": "constant",
+      "signature": "const ARCANE_EVENT_LISTENER_ERROR_EVENT",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Canonical observational event emitted for a listener failure.",
+      "availability": "Node and browser/bundler",
+      "protocol": "arcane.event.listener.error over arcane-event-authority/1",
+      "normalization": "Mutable public detail includes the code, source identifiers, and complete normalized error snapshot; the raw error also reaches the owner-local callback"
+    },
+    {
+      "id": "root:ARCANE_EVENT_OCCURRENCE_PROTOCOL",
+      "name": "ARCANE_EVENT_OCCURRENCE_PROTOCOL",
+      "displayName": "ARCANE_EVENT_OCCURRENCE_PROTOCOL",
+      "kind": "constant",
+      "signature": "const ARCANE_EVENT_OCCURRENCE_PROTOCOL",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Identifies canonical event occurrences.",
+      "availability": "Node and browser/bundler",
+      "protocol": "arcane-event-occurrence/1",
+      "normalization": "Exact occurrence protocol discriminator; occurrences and their complete normalized detail are mutable"
+    },
+    {
+      "id": "root:ARCANE_EVENT_SOURCE_DISPOSED_EVENT",
+      "name": "ARCANE_EVENT_SOURCE_DISPOSED_EVENT",
+      "displayName": "ARCANE_EVENT_SOURCE_DISPOSED_EVENT",
+      "kind": "constant",
+      "signature": "const ARCANE_EVENT_SOURCE_DISPOSED_EVENT",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Final noncancelable canonical occurrence published when a source is disposed.",
+      "availability": "Node and browser/bundler",
+      "protocol": "arcane.event.source.disposed over arcane-event-authority/1",
+      "normalization": "Mutable normalized detail contains source, instanceId, and the exact source-disposed reason before source listener cleanup"
+    },
+    {
+      "id": "root:ARCANE_EVENT_SOURCE_KIND",
+      "name": "ARCANE_EVENT_SOURCE_KIND",
+      "displayName": "ARCANE_EVENT_SOURCE_KIND",
+      "kind": "constant",
+      "signature": "const ARCANE_EVENT_SOURCE_KIND",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Identifies the canonical source descriptor kind.",
+      "availability": "Node and browser/bundler",
+      "protocol": "arcane-event-source",
+      "normalization": "Exact descriptor-kind discriminator"
+    },
+    {
+      "id": "root:ARCANE_EVENT_SOURCE_PROTOCOL",
+      "name": "ARCANE_EVENT_SOURCE_PROTOCOL",
+      "displayName": "ARCANE_EVENT_SOURCE_PROTOCOL",
+      "kind": "constant",
+      "signature": "const ARCANE_EVENT_SOURCE_PROTOCOL",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Identifies canonical event source handles and descriptors.",
+      "availability": "Node and browser/bundler",
+      "protocol": "arcane-event-source/1",
+      "normalization": "Exact source protocol discriminator with declared event types and one realm-local instance id"
+    },
+    {
+      "id": "root:ARCANE_EVENT_STACK_PROTOCOL",
+      "name": "ARCANE_EVENT_STACK_PROTOCOL",
+      "displayName": "ARCANE_EVENT_STACK_PROTOCOL",
+      "kind": "constant",
+      "signature": "const ARCANE_EVENT_STACK_PROTOCOL",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Identifies strict serialized event-stack documents and records as arcane-event-stack/1.",
+      "availability": "Node and browser/bundler",
+      "protocol": "arcane-event-stack/1",
+      "normalization": "Exact protocol discriminator; no transport or host authority"
+    },
+    {
+      "id": "root:DEFAULT_DOM_EVENT_TYPES",
+      "name": "DEFAULT_DOM_EVENT_TYPES",
+      "displayName": "DEFAULT_DOM_EVENT_TYPES",
+      "kind": "constant",
+      "signature": "const DEFAULT_DOM_EVENT_TYPES",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Mutable default set of 44 capture-phase DOM interaction event names.",
+      "availability": "Node and browser/bundler; meaningful to browser DOM instrumentation",
+      "protocol": "Synchronous DOM observation projected into arcane-event-stack/1 records",
+      "normalization": "Exact mutable event-name list; host event objects are not retained"
+    },
+    {
+      "id": "root:DOM_INTERACTION_EVENT",
+      "name": "DOM_INTERACTION_EVENT",
+      "displayName": "DOM_INTERACTION_EVENT",
+      "kind": "constant",
+      "signature": "const DOM_INTERACTION_EVENT",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Event type emitted for a complete DOM interaction diagnostic.",
+      "availability": "Browser DOM or a DOM-compatible test host; constant imports in Node",
+      "protocol": "In-process event-pubsub; optional arcane-event-stack/1 recording",
+      "normalization": "Complete readable event fields, target values, selectors, URLs, markup or text content, and object details are retained"
+    },
+    {
+      "id": "root:DOM_MUTATION_EVENT",
+      "name": "DOM_MUTATION_EVENT",
+      "displayName": "DOM_MUTATION_EVENT",
+      "kind": "constant",
+      "signature": "const DOM_MUTATION_EVENT",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Event type emitted for a complete DOM mutation diagnostic.",
+      "availability": "Browser DOM or a DOM-compatible test host; constant imports in Node",
+      "protocol": "MutationObserver projected through in-process events and optional arcane-event-stack/1 recording",
+      "normalization": "Complete markup, text, selectors, URLs, character data, and attribute values are retained"
+    },
+    {
+      "id": "root:DOM_OBSERVATION_STARTED_EVENT",
+      "name": "DOM_OBSERVATION_STARTED_EVENT",
+      "displayName": "DOM_OBSERVATION_STARTED_EVENT",
+      "kind": "constant",
+      "signature": "const DOM_OBSERVATION_STARTED_EVENT",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Lifecycle event emitted after DOM instrumentation starts successfully.",
+      "availability": "Browser DOM or a DOM-compatible test host; constant imports in Node",
+      "protocol": "In-process event-pubsub; optional arcane-event-stack/1 recording",
+      "normalization": "Normalized root and capture-option diagnostic"
+    },
+    {
+      "id": "root:DOM_OBSERVATION_STOPPED_EVENT",
+      "name": "DOM_OBSERVATION_STOPPED_EVENT",
+      "displayName": "DOM_OBSERVATION_STOPPED_EVENT",
+      "kind": "constant",
+      "signature": "const DOM_OBSERVATION_STOPPED_EVENT",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Lifecycle event emitted when active DOM instrumentation stops normally.",
+      "availability": "Browser DOM or a DOM-compatible test host; constant imports in Node",
+      "protocol": "In-process event-pubsub; optional arcane-event-stack/1 recording",
+      "normalization": "Normalized root diagnostic; stopping an already inactive controller is idempotent and emits nothing"
+    },
+    {
+      "id": "root:EventManager",
+      "name": "EventManager",
+      "displayName": "EventManager",
+      "kind": "class",
+      "signature": "new EventManager(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Runs synchronous pub/sub with optional complete, mutable time-travel history and DOM instrumentation.",
+      "availability": "Node and browser/bundler; DOM capture requires a browser DOM or compatible host",
+      "protocol": "Synchronous event-pubsub plus optional arcane-event-stack/1 export/import",
+      "normalization": "Live listener arguments retain identity; recording preserves complete normalized values, URLs, public details, and captured stack text in mutable snapshots without a configured retention cap"
+    },
+    {
+      "id": "root:PLAYBACK_CANCELLED_EVENT",
+      "name": "PLAYBACK_CANCELLED_EVENT",
+      "displayName": "PLAYBACK_CANCELLED_EVENT",
+      "kind": "constant",
+      "signature": "const PLAYBACK_CANCELLED_EVENT",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Lifecycle event emitted when an AbortSignal cancels event-stack playback.",
+      "availability": "Node and browser/bundler",
+      "protocol": "In-process playback lifecycle over an arcane-event-stack/1 source",
+      "normalization": "Mutable summary with session, delivered count, cursor, completion flag, and a complete normalized error snapshot"
+    },
+    {
+      "id": "root:PLAYBACK_COMPLETED_EVENT",
+      "name": "PLAYBACK_COMPLETED_EVENT",
+      "displayName": "PLAYBACK_COMPLETED_EVENT",
+      "kind": "constant",
+      "signature": "const PLAYBACK_COMPLETED_EVENT",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Lifecycle event emitted after selected event-stack records finish playback.",
+      "availability": "Node and browser/bundler",
+      "protocol": "In-process playback lifecycle over an arcane-event-stack/1 source",
+      "normalization": "Mutable summary with session, delivered count, cursor, and completed=true"
+    },
+    {
+      "id": "root:PLAYBACK_FAILED_EVENT",
+      "name": "PLAYBACK_FAILED_EVENT",
+      "displayName": "PLAYBACK_FAILED_EVENT",
+      "kind": "constant",
+      "signature": "const PLAYBACK_FAILED_EVENT",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Lifecycle event emitted when event-stack playback fails for a reason other than signal cancellation.",
+      "availability": "Node and browser/bundler",
+      "protocol": "In-process playback lifecycle over an arcane-event-stack/1 source",
+      "normalization": "Mutable summary with session, delivered count, cursor, completion flag, and a complete normalized error snapshot"
+    },
+    {
+      "id": "root:PLAYBACK_RECORD_EVENT",
+      "name": "PLAYBACK_RECORD_EVENT",
+      "displayName": "PLAYBACK_RECORD_EVENT",
+      "kind": "constant",
+      "signature": "const PLAYBACK_RECORD_EVENT",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Review-mode event that presents one validated mutable record without re-emitting its original type.",
+      "availability": "Node and browser/bundler",
+      "protocol": "In-process review projection of arcane-event-stack/1",
+      "normalization": "Validated mutable event-stack record"
+    },
+    {
+      "id": "root:PLAYBACK_STARTED_EVENT",
+      "name": "PLAYBACK_STARTED_EVENT",
+      "displayName": "PLAYBACK_STARTED_EVENT",
+      "kind": "constant",
+      "signature": "const PLAYBACK_STARTED_EVENT",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Lifecycle event emitted before the selected playback range is delivered.",
+      "availability": "Node and browser/bundler",
+      "protocol": "In-process playback lifecycle over an arcane-event-stack/1 source",
+      "normalization": "Normalized session, range, count, speed, and mode summary"
+    },
+    {
+      "id": "root:TIME_TRAVEL_SEEK_EVENT",
+      "name": "TIME_TRAVEL_SEEK_EVENT",
+      "displayName": "TIME_TRAVEL_SEEK_EVENT",
+      "kind": "constant",
+      "signature": "const TIME_TRAVEL_SEEK_EVENT",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Event emitted when the review cursor seeks to sequence zero or a retained sequence.",
+      "availability": "Node and browser/bundler",
+      "protocol": "In-process review cursor event; the retained stack remains unchanged",
+      "normalization": "Normalized sessionId, requested sequence, and mutable matching record or null"
+    },
+    {
+      "id": "root:arcaneEvents",
+      "name": "arcaneEvents",
+      "displayName": "arcaneEvents",
+      "kind": "singleton",
+      "signature": "const arcaneEvents",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Package-scoped EventManager singleton for applications that want one shared event bus.",
+      "availability": "Node and browser/bundler; DOM capture requires a compatible DOM",
+      "protocol": "Synchronous event-pubsub plus opt-in arcane-event-stack/1 recording",
+      "normalization": "Same module singleton through root and focused subpath; time travel starts disabled; complete mutable recording is available when enabled"
+    },
+    {
+      "id": "root:createArcaneEventSource",
+      "name": "createArcaneEventSource",
+      "displayName": "createArcaneEventSource()",
+      "kind": "function",
+      "signature": "createArcaneEventSource(owner, options)",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Registers one declared semantic event source for a non-null object or function owner.",
+      "availability": "Node and browser/bundler",
+      "protocol": "arcane-event-source/1 over the per-realm arcane-event-authority/1 singleton",
+      "normalization": "Returns one mutable source handle with declared event types, a realm-local instance id, synchronous publication, and deterministic disposal"
+    },
+    {
+      "id": "root:createDOMInstrumentation",
+      "name": "createDOMInstrumentation",
+      "displayName": "createDOMInstrumentation()",
+      "kind": "function",
+      "signature": "createDOMInstrumentation(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Creates a start/stop controller that projects DOM interactions and mutations into an EventManager.",
+      "availability": "Browser DOM or a DOM-compatible test host",
+      "protocol": "Capture-phase DOM events and MutationObserver projected to in-process EventManager events",
+      "normalization": "Accepts eventManager, root, eventTypes, MutationObserver, captureMutations, and observeOpenShadowRoots; preserves complete readable event, value, markup, text, selector, URL, and mutation detail"
+    },
+    {
+      "id": "root:createEventManager",
+      "name": "createEventManager",
+      "displayName": "createEventManager()",
+      "kind": "function",
+      "signature": "createEventManager(options)",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Constructs and returns an independent EventManager instance.",
+      "availability": "Node and browser/bundler; DOM capture requires a compatible DOM",
+      "protocol": "Synchronous event-pubsub plus optional arcane-event-stack/1",
+      "normalization": "Equivalent constructor behavior without sharing the arcaneEvents singleton; accepts the current timeTravel, dom, clock, now, and sessionId options"
+    },
+    {
+      "id": "root:describeDOMTarget",
+      "name": "describeDOMTarget",
+      "displayName": "describeDOMTarget()",
+      "kind": "function",
+      "signature": "describeDOMTarget(target, root)",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Returns a mutable diagnostic descriptor for a DOM target, including complete text or markup content when present.",
+      "availability": "Browser DOM or DOM-compatible objects; importable in Node",
+      "protocol": "Local DOM diagnostic helper",
+      "normalization": "Normalizes document, shadow root, text, element, global, and generic event targets without retaining nodes"
+    },
+    {
+      "id": "root:domSelector",
+      "name": "domSelector",
+      "displayName": "domSelector()",
+      "kind": "function",
+      "signature": "domSelector(target, root)",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Builds a diagnostic selector across light DOM and open shadow-root boundaries.",
+      "availability": "Browser DOM or DOM-compatible objects; importable in Node",
+      "protocol": "Local DOM diagnostic helper",
+      "normalization": "Returns a best-effort selector or null; triple-chevron separates open shadow boundaries"
+    },
+    {
+      "id": "root:isArcaneEventOccurrence",
+      "name": "isArcaneEventOccurrence",
+      "displayName": "isArcaneEventOccurrence()",
+      "kind": "function",
+      "signature": "isArcaneEventOccurrence(value)",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Recognizes canonical occurrences and source event views created by the current realm authority.",
+      "availability": "Node and browser/bundler",
+      "protocol": "arcane-event-occurrence/1 realm-local recognition",
+      "normalization": "Returns a boolean from authority-owned identity records; protocol-shaped foreign objects are not admitted"
+    },
+    {
+      "id": "root:parseEventStack",
+      "name": "parseEventStack",
+      "displayName": "parseEventStack()",
+      "kind": "function",
+      "signature": "parseEventStack(source)",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Strictly parses and validates an event-stack object or JSON string into a mutable normalized document.",
+      "availability": "Node and browser/bundler",
+      "protocol": "arcane-event-stack/1",
+      "normalization": "Rejects extra keys, malformed nesting, unsafe values, invalid timing or session structure, and non-increasing sequences; returns a mutable null-prototype normalized document"
+    },
+    {
+      "id": "root:projectArcaneDOMEvent",
+      "name": "projectArcaneDOMEvent",
+      "displayName": "projectArcaneDOMEvent()",
+      "kind": "function",
+      "signature": "projectArcaneDOMEvent(target, occurrence, options)",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/event-manager"
+      ],
+      "primaryImport": "arcane-os/event-manager",
+      "group": "Central events, time travel, and DOM instrumentation",
+      "summary": "Projects one canonical occurrence to one CustomEvent without republishing it into the authority.",
+      "availability": "Browser DOM or a DOM-compatible test host",
+      "protocol": "One-way arcane-event-occurrence/1 to CustomEvent projection",
+      "normalization": "Adds mutable occurrence, source, instance, and operation identifiers; DOM cancellation propagates only to a cancelable occurrence"
+    },
+    {
+      "id": "root:SDK_UPDATE_REGISTRY",
+      "name": "SDK_UPDATE_REGISTRY",
+      "displayName": "SDK_UPDATE_REGISTRY",
+      "kind": "constant",
+      "signature": "const SDK_UPDATE_REGISTRY",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Explicit SDK update checks",
+      "summary": "Approved default npm registry origin for the on-demand SDK update check.",
+      "availability": "Node; on-demand CLI or maintainer check only",
+      "protocol": "Ordinary HTTP or HTTPS GET to the selected npm registry dist-tag endpoint",
+      "normalization": "Exact default HTTPS registry string"
+    },
+    {
+      "id": "root:SDK_UPDATE_TIMEOUT_MS",
+      "name": "SDK_UPDATE_TIMEOUT_MS",
+      "displayName": "SDK_UPDATE_TIMEOUT_MS",
+      "kind": "constant",
+      "signature": "const SDK_UPDATE_TIMEOUT_MS",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Explicit SDK update checks",
+      "summary": "Default per-request timeout for one explicit SDK registry check.",
+      "availability": "Node; on-demand CLI or maintainer check only",
+      "protocol": "Ordinary HTTP or HTTPS GET to the selected npm registry dist-tag endpoint",
+      "normalization": "Exact default millisecond integer"
+    },
+    {
+      "id": "root:checkForSdkUpdate",
+      "name": "checkForSdkUpdate",
+      "displayName": "checkForSdkUpdate()",
+      "kind": "function",
+      "signature": "async checkForSdkUpdate({ packageName=SDK_NAME, currentVersion=SDK_VERSION, registry=SDK_UPDATE_REGISTRY, timeoutMs=SDK_UPDATE_TIMEOUT_MS, fetchImpl=globalThis.fetch, signal, onEvent, clock=()=>new Date() }={})",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Explicit SDK update checks",
+      "summary": "Performs one ordinary registry read and reports whether the selected npm dist-tag is newer than the installed SDK.",
+      "availability": "Node; on-demand CLI or maintainer check only",
+      "protocol": "Ordinary HTTP or HTTPS GET to the selected npm registry dist-tag endpoint",
+      "normalization": "Mutable current, ahead, or update-available result with complete registry data and normalized update-check failures"
+    },
+    {
+      "id": "root:checkSdkUpdate",
+      "name": "checkSdkUpdate",
+      "displayName": "checkSdkUpdate()",
+      "kind": "function",
+      "signature": "async checkSdkUpdate(options={})",
+      "entrypoints": [
+        "arcane-os",
+        "arcane-os/toolchain"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Explicit SDK update checks",
+      "summary": "Toolchain and CLI wrapper for exactly one checkForSdkUpdate invocation.",
+      "availability": "Node; on-demand CLI or maintainer check only",
+      "protocol": "Ordinary HTTP or HTTPS GET to the selected npm registry dist-tag endpoint",
+      "normalization": "Preserves the direct check result, events, cancellation, and errors without scheduling another check"
+    },
+    {
+      "id": "root:compareSdkVersions",
+      "name": "compareSdkVersions",
+      "displayName": "compareSdkVersions()",
+      "kind": "function",
+      "signature": "compareSdkVersions(leftValue, rightValue)",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Explicit SDK update checks",
+      "summary": "Compares two strict semantic SDK versions without performing a registry request.",
+      "availability": "Node; on-demand CLI or maintainer check only",
+      "protocol": "In-process semantic-version comparison",
+      "normalization": "Returns -1, 0, or 1; build metadata does not affect precedence"
+    },
+    {
+      "id": "root:updateTagForVersion",
+      "name": "updateTagForVersion",
+      "displayName": "updateTagForVersion()",
+      "kind": "function",
+      "signature": "updateTagForVersion(value)",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Explicit SDK update checks",
+      "summary": "Selects npm dev for a prerelease SDK version and latest for a stable version.",
+      "availability": "Node; on-demand CLI or maintainer check only",
+      "protocol": "In-process npm dist-tag selection",
+      "normalization": "Exact dev or latest tag selected from strict semantic-version prerelease state"
+    },
+    {
+      "id": "root:validateUpdateRegistry",
+      "name": "validateUpdateRegistry",
+      "displayName": "validateUpdateRegistry()",
+      "kind": "function",
+      "signature": "validateUpdateRegistry(value)",
+      "entrypoints": [
+        "arcane-os"
+      ],
+      "primaryImport": "arcane-os",
+      "group": "Explicit SDK update checks",
+      "summary": "Validates one ordinary HTTP or HTTPS registry URL.",
+      "availability": "Node; on-demand CLI or maintainer check only",
+      "protocol": "Ordinary HTTP or HTTPS registry URL",
+      "normalization": "Returns the normalized URL object without a host, credential, port, path, query, fragment, or redirect policy"
+    },
+    {
+      "id": "browser-wasm:BROWSER_WASM_RUNTIME_AUTHORITY",
+      "name": "BROWSER_WASM_RUNTIME_AUTHORITY",
+      "displayName": "BROWSER_WASM_RUNTIME_AUTHORITY",
+      "kind": "constant",
+      "signature": "const BROWSER_WASM_RUNTIME_AUTHORITY",
+      "entrypoints": [
+        "arcane-os/ai/browser-wasm"
+      ],
+      "primaryImport": "arcane-os/ai/browser-wasm",
+      "group": "Browser-WASM local AI",
+      "summary": "Mutable metadata for the packaged Wllama and llama.cpp runtime, upstream JS and WASM assets, licensing, and disabled compatibility-network policy.",
+      "availability": "Browser metadata; import and inspection require neither DBOPFS nor a loaded model",
+      "protocol": "arcane-ai-browser-wasm/2 over the provider-neutral arcane-ai-adapter/1 boundary",
+      "normalization": "Complete mutable runtime/component metadata; it contains no model weights or model catalog"
+    },
+    {
+      "id": "browser-wasm:adaptV1LlmProvider",
+      "name": "adaptV1LlmProvider",
+      "displayName": "adaptV1LlmProvider()",
+      "kind": "function",
+      "signature": "adaptV1LlmProvider(provider)",
+      "entrypoints": [
+        "arcane-os/ai/browser-wasm"
+      ],
+      "primaryImport": "arcane-os/ai/browser-wasm",
+      "group": "Browser-WASM local AI",
+      "summary": "Adapts one compatible browser LLM provider to the provider-neutral LLM role contract.",
+      "availability": "Browser; the wrapped provider retains its own WebGPU, storage, model, and lifecycle requirements",
+      "protocol": "arcane-ai-provider/2 adapted from the browser LLM adapter surface",
+      "normalization": "Projects catalog, inspection, status, lifecycle, declaration/history-validated chat and stream, private automatic stream draining, complete all-choice content/reasoning FIFO projections, result-first buffering, terminal-only structural-call acceptance, exact per-choice observed/terminal complete-envelope correlation, prompt observed early-return cancellation, and disposal without adding a provider or fallback"
+    },
+    {
+      "id": "browser-wasm:completeValueText",
+      "name": "completeValueText",
+      "displayName": "completeValueText()",
+      "kind": "function",
+      "signature": "completeValueText(value)",
+      "entrypoints": [
+        "arcane-os/ai/browser-wasm"
+      ],
+      "primaryImport": "arcane-os/ai/browser-wasm",
+      "group": "Browser-WASM local AI",
+      "summary": "Returns complete caller content as text, preserving strings and serializing supported non-string values without clipping.",
+      "availability": "Compatible JavaScript module host; no provider, model, cache, storage, WebAssembly, or browser capability is required",
+      "protocol": "Complete caller-value text normalization",
+      "normalization": "Preserves complete string content and converts supported structured values to complete readable JSON text"
+    },
+    {
+      "id": "browser-wasm:createArcaneAI",
+      "name": "createArcaneAI",
+      "displayName": "createArcaneAI()",
+      "kind": "function",
+      "signature": "createArcaneAI({ llm=null, provider=null, loadPolicy='on-demand', security }={})",
+      "entrypoints": [
+        "arcane-os/ai/browser-wasm"
+      ],
+      "primaryImport": "arcane-os/ai/browser-wasm",
+      "group": "Browser-WASM local AI",
+      "summary": "Creates the provider-neutral browser AI API module and LLM lifecycle controller around one compatible provider or controller.",
+      "availability": "Browser; the selected provider observes its own WebAssembly, storage, and model readiness",
+      "protocol": "arcane-ai-adapter/1",
+      "normalization": "Normalizes lazy or manual load, mutable complete lifecycle status, cancellation, complete all-choice nonstructural stream projection, complete provider data callbacks, single-choice text or multi-choice terminal output, required structural arguments.message, and atomic exact matching nonblank all-ID tool-result sequencing without executing tools; an existing ModelController retains its preconfigured load policy and rejects a new security option"
+    },
+    {
+      "id": "browser-wasm:createBrowserModelSource",
+      "name": "createBrowserModelSource",
+      "displayName": "createBrowserModelSource()",
+      "kind": "function",
+      "signature": "createBrowserModelSource(descriptor, { fetchImpl=null }={})",
+      "entrypoints": [
+        "arcane-os/ai/browser-wasm"
+      ],
+      "primaryImport": "arcane-os/ai/browser-wasm",
+      "group": "Browser-WASM local AI",
+      "summary": "Validates a caller-supplied ordered multi-file model descriptor with optional progress metadata and creates cancellable no-credentials HTTPS member downloads.",
+      "availability": "Browser with Fetch and a readable response body; each direct member open performs its configured HTTPS fetch",
+      "protocol": "Caller-supplied version-pinned HTTPS model-file URLs",
+      "normalization": "Canonical mutable ordered descriptor with optional observational bytes plus a complete per-member download handle with nullable observed content length"
+    },
+    {
+      "id": "browser-wasm:createBrowserWasmLlmProvider",
+      "name": "createBrowserWasmLlmProvider",
+      "displayName": "createBrowserWasmLlmProvider()",
+      "kind": "function",
+      "signature": "createBrowserWasmLlmProvider({ sources, store, loadDefaults={}, security, logger=console }={})",
+      "entrypoints": [
+        "arcane-os/ai/browser-wasm"
+      ],
+      "primaryImport": "arcane-os/ai/browser-wasm",
+      "group": "Browser-WASM local AI",
+      "summary": "Creates the packaged Wllama browser provider with complete serialized inference, streaming, abort, unload, and probe operations.",
+      "availability": "Browser context with WebAssembly, OPFS/DBOPFS, and WebGPU; no CPU fallback",
+      "protocol": "arcane-ai-adapter/1 with OpenAI-like chat completion and streaming envelopes",
+      "normalization": "Mutable complete lifecycle/status records, declaration/history validation, atomic nonblank all-ID tool-result sequencing, complete all-choice nonstructural ordinary iterator projections, all-choice terminal validation, terminal-only structural-call acceptance, and exact structured tool-call data with required user-facing message and retained extension fields; the SDK never invokes application tools"
+    },
+    {
+      "id": "browser-wasm:createDbopfsModelStore",
+      "name": "createDbopfsModelStore",
+      "displayName": "createDbopfsModelStore()",
+      "kind": "function",
+      "signature": "createDbopfsModelStore({ dbopfs, tableName='arcane_ai_browser_models', estimateStorage=null, downloadConcurrency=4 }={})",
+      "entrypoints": [
+        "arcane-os/ai/browser-wasm"
+      ],
+      "primaryImport": "arcane-os/ai/browser-wasm",
+      "group": "Browser-WASM local AI",
+      "summary": "Adapts an existing DBOPFS instance into a resumable model cache with bounded parallel shard or monolithic Range-part transfer and live aggregate byte progress.",
+      "availability": "Browser with a ready DBOPFS instance and OPFS support",
+      "protocol": "Resumable ordered model members and deterministic per-member Range parts over existing DBOPFS method semantics",
+      "normalization": "Uses one bounded transfer axis, preserves ordered completed shards and deterministic current Range parts within any member across interruption, emits coalesced additive loaded/total/remaining/rate/ETA/active-worker telemetry, rolls discarded partial writes back out of progress, cleans superseded current Range parts after a complete replacement exists, and settles failed or cancelled peers while retaining completed work for retry"
+    },
+    {
+      "id": "browser-speech:BROWSER_SPEECH_ARTIFACT_GRAPH_PROTOCOL",
+      "name": "BROWSER_SPEECH_ARTIFACT_GRAPH_PROTOCOL",
+      "displayName": "BROWSER_SPEECH_ARTIFACT_GRAPH_PROTOCOL",
+      "kind": "constant",
+      "signature": "const BROWSER_SPEECH_ARTIFACT_GRAPH_PROTOCOL",
+      "entrypoints": [
+        "arcane-os/ai/browser-speech"
+      ],
+      "primaryImport": "arcane-os/ai/browser-speech",
+      "group": "Browser speech providers",
+      "summary": "Stable protocol identifier for a complete caller-owned browser speech materialization graph.",
+      "availability": "Browser metadata; graph construction is side-effect free and provider use requires the selected browser storage and Worker capabilities",
+      "protocol": "arcane-ai-browser-speech-artifact-graph/1",
+      "normalization": "Exact protocol string; the graph file inventory routes known materialized files and does not select artifacts or enforce edge policy"
+    },
+    {
+      "id": "browser-speech:BROWSER_SPEECH_ARTIFACT_PROTOCOL",
+      "name": "BROWSER_SPEECH_ARTIFACT_PROTOCOL",
+      "displayName": "BROWSER_SPEECH_ARTIFACT_PROTOCOL",
+      "kind": "constant",
+      "signature": "const BROWSER_SPEECH_ARTIFACT_PROTOCOL",
+      "entrypoints": [
+        "arcane-os/ai/browser-speech"
+      ],
+      "primaryImport": "arcane-os/ai/browser-speech",
+      "group": "Browser speech providers",
+      "summary": "Stable protocol identifier for browser speech artifact stores.",
+      "availability": "Browser metadata; model/runtime use requires DBOPFS, Web Locks, Workers, and caller-selected artifacts",
+      "protocol": "arcane-ai-browser-speech-artifacts/1 over arcane-ai-provider/2",
+      "normalization": "Exact protocol string; it grants no model authority and names no model download"
+    },
+    {
+      "id": "browser-speech:createBrowserKokoroProvider",
+      "name": "createBrowserKokoroProvider",
+      "displayName": "createBrowserKokoroProvider()",
+      "kind": "function",
+      "signature": "createBrowserKokoroProvider(options={})",
+      "entrypoints": [
+        "arcane-os/ai/browser-speech"
+      ],
+      "primaryImport": "arcane-os/ai/browser-speech",
+      "group": "Browser speech providers",
+      "summary": "Creates a local-only Kokoro text-to-speech provider for the provider-neutral AI runtime.",
+      "availability": "Browser with DBOPFS, Web Locks, Workers, object URLs, and caller-selected kokoro-js runtime/model content",
+      "protocol": "arcane-ai-provider/2 tts/synthesize",
+      "normalization": "Independent load, status, request, unload, cancellation, and disposal; provider-native requests return 24000 Hz Float32Array PCM, while shared AI.js requests use wav and return complete Uint8Array audio/wav data; never selects a cloud fallback"
+    },
+    {
+      "id": "browser-speech:createBrowserSpeechArtifactGraph",
+      "name": "createBrowserSpeechArtifactGraph",
+      "displayName": "createBrowserSpeechArtifactGraph()",
+      "kind": "function",
+      "signature": "createBrowserSpeechArtifactGraph({ kind='browser-speech-authenticated-artifact-graph', security, providerId=null, role, model, runtime, files }={})",
+      "entrypoints": [
+        "arcane-os/ai/browser-speech"
+      ],
+      "primaryImport": "arcane-os/ai/browser-speech",
+      "group": "Browser speech providers",
+      "summary": "Normalizes one complete caller-owned browser speech materialization graph.",
+      "availability": "Browser metadata; construction starts no fetch, cache, Worker, provider, or event operation",
+      "protocol": "arcane-ai-browser-speech-artifact-graph/1",
+      "normalization": "Returns one mutable graph with normalized file, model, runtime, and routing facts"
+    },
+    {
+      "id": "browser-speech:createBrowserSpeechAuthority",
+      "name": "createBrowserSpeechAuthority",
+      "displayName": "createBrowserSpeechAuthority()",
+      "kind": "function",
+      "signature": "createBrowserSpeechAuthority({ providerId, role, model, runtime, security }={})",
+      "entrypoints": [
+        "arcane-os/ai/browser-speech"
+      ],
+      "primaryImport": "arcane-os/ai/browser-speech",
+      "group": "Browser speech providers",
+      "summary": "Validates and preserves one mutable caller-owned Whisper or Kokoro model/runtime authority.",
+      "availability": "Browser descriptor construction; using the authority requires the selected storage and provider Web APIs",
+      "protocol": "arcane-ai-model-authority/1",
+      "normalization": "Requires an exact adapter role, unique paths and URLs, and a caller-supplied revision; returns one mutable normalized authority record"
+    },
+    {
+      "id": "browser-speech:createBrowserWhisperProvider",
+      "name": "createBrowserWhisperProvider",
+      "displayName": "createBrowserWhisperProvider()",
+      "kind": "function",
+      "signature": "createBrowserWhisperProvider(options={})",
+      "entrypoints": [
+        "arcane-os/ai/browser-speech"
+      ],
+      "primaryImport": "arcane-os/ai/browser-speech",
+      "group": "Browser speech providers",
+      "summary": "Creates a local-only Whisper speech-to-text provider for the provider-neutral AI runtime.",
+      "availability": "Browser with DBOPFS, Web Locks, Workers, object URLs, and caller-selected transformers-whisper runtime/model content",
+      "protocol": "arcane-ai-provider/2 stt/transcribe",
+      "normalization": "Independent load, status, request, unload, cancellation, and disposal; accepts provider-native Float32Array audio at exactly 16000 Hz or decodes the shared AI.js Blob/File payload to authoritative 16000 Hz mono PCM; never selects a cloud fallback"
+    },
+    {
+      "id": "browser-speech:createDbopfsSpeechArtifactStore",
+      "name": "createDbopfsSpeechArtifactStore",
+      "displayName": "createDbopfsSpeechArtifactStore()",
+      "kind": "function",
+      "signature": "createDbopfsSpeechArtifactStore({ dbopfs, tableName='arcane_ai_browser_speech', fetchImpl=null, objectUrlFactory=null }={})",
+      "entrypoints": [
+        "arcane-os/ai/browser-speech"
+      ],
+      "primaryImport": "arcane-os/ai/browser-speech",
+      "group": "Browser speech providers",
+      "summary": "Adapts an existing DBOPFS instance into a caller-scoped speech runtime/model artifact store and ordinary module router.",
+      "availability": "Browser with a ready DBOPFS instance, Web Locks, Fetch or an explicit fetch implementation, File/Blob, and object URLs",
+      "protocol": "arcane-ai-browser-speech-artifacts/1 ordinary DBOPFS storage and module routing",
+      "normalization": "Serializes complete caller-selected content, invalidates stale cache selections without byte identities, routes known materialized imports/fetches/Workers/cache reads, falls back to native browser behavior for unmapped operations, and keeps secure intent dormant"
+    },
+    {
+      "id": "mail:MAIL_OUTBOX_IDEMPOTENCY_WINDOW_MS",
+      "name": "MAIL_OUTBOX_IDEMPOTENCY_WINDOW_MS",
+      "displayName": "MAIL_OUTBOX_IDEMPOTENCY_WINDOW_MS",
+      "kind": "constant",
+      "signature": "const MAIL_OUTBOX_IDEMPOTENCY_WINDOW_MS",
+      "entrypoints": ["arcane-os/mail"],
+      "primaryImport": "arcane-os/mail",
+      "group": "Portable Mail",
+      "summary": "Duration for same-key retry before an ambiguous delivery requires reconciliation.",
+      "availability": "Node and browser metadata",
+      "protocol": "arcane-mail-outbox/1",
+      "normalization": "Exact immutable value of 86400000 milliseconds"
+    },
+    {
+      "id": "mail:MAIL_OUTBOX_PROTOCOL",
+      "name": "MAIL_OUTBOX_PROTOCOL",
+      "displayName": "MAIL_OUTBOX_PROTOCOL",
+      "kind": "constant",
+      "signature": "const MAIL_OUTBOX_PROTOCOL",
+      "entrypoints": ["arcane-os/mail"],
+      "primaryImport": "arcane-os/mail",
+      "group": "Portable Mail",
+      "summary": "Stable protocol identifier written to durable Mail outbox records.",
+      "availability": "Node and browser metadata",
+      "protocol": "arcane-mail-outbox/1",
+      "normalization": "Exact immutable protocol value"
+    },
+    {
+      "id": "mail:MAIL_OUTBOX_STATES",
+      "name": "MAIL_OUTBOX_STATES",
+      "displayName": "MAIL_OUTBOX_STATES",
+      "kind": "constant",
+      "signature": "const MAIL_OUTBOX_STATES",
+      "entrypoints": ["arcane-os/mail"],
+      "primaryImport": "arcane-os/mail",
+      "group": "Portable Mail",
+      "summary": "Mutable ordered vocabulary for durable Mail outbox lifecycle states.",
+      "availability": "Node and browser metadata",
+      "protocol": "arcane-mail-outbox/1",
+      "normalization": "Exact queued, sending, retry_wait, accepted, failed, and reconciliation_required state list"
+    },
+    {
+      "id": "mail:MAIL_OUTBOX_TABLE",
+      "name": "MAIL_OUTBOX_TABLE",
+      "displayName": "MAIL_OUTBOX_TABLE",
+      "kind": "constant",
+      "signature": "const MAIL_OUTBOX_TABLE",
+      "entrypoints": ["arcane-os/mail"],
+      "primaryImport": "arcane-os/mail",
+      "group": "Portable Mail",
+      "summary": "Default DBOPFS-compatible table name for durable Mail outbox records.",
+      "availability": "Node and browser metadata",
+      "protocol": "arcane-mail-outbox/1",
+      "normalization": "Exact immutable value mail_outbox"
+    },
+    {
+      "id": "mail:Mail",
+      "name": "Mail",
+      "displayName": "Mail",
+      "kind": "class",
+      "signature": "new Mail(config=globalThis.arcane?.config?.mail||{}, options={})",
+      "entrypoints": ["arcane-os/mail"],
+      "primaryImport": "arcane-os/mail",
+      "group": "Portable Mail",
+      "summary": "Owns the application Mail singleton, durable lifecycle, report normalization, and explicit transport selection.",
+      "availability": "Node with injected host adapters, or browser/native WebView with durable storage and Web Locks",
+      "protocol": "arcane-mail-outbox/1 with native Arcane.mail or complete HTTP delivery",
+      "normalization": "Validates complete reports, persists before delivery, and returns complete mutable provider-neutral send results"
+    },
+    {
+      "id": "mail:MailOutbox",
+      "name": "MailOutbox",
+      "displayName": "MailOutbox",
+      "kind": "class",
+      "signature": "new MailOutbox(options={})",
+      "entrypoints": ["arcane-os/mail"],
+      "primaryImport": "arcane-os/mail",
+      "group": "Portable Mail",
+      "summary": "Persists complete reports before delivery and owns FIFO draining, retry classification, and explicit invalid-record maintenance.",
+      "availability": "Node or browser with injected DBOPFS-compatible storage and a Web Locks-compatible lock manager",
+      "protocol": "arcane-mail-outbox/1",
+      "normalization": "Returns complete mutable records and summaries; accepted results require requestId, optional providerId and acceptanceAuthority remain transport metadata, and ambiguous attempts remain same-key retries or require reconciliation"
+    },
+    {
+      "id": "mail:MailTransportError",
+      "name": "MailTransportError",
+      "displayName": "MailTransportError",
+      "kind": "class",
+      "signature": "new MailTransportError(message, options={})",
+      "entrypoints": ["arcane-os/mail"],
+      "primaryImport": "arcane-os/mail",
+      "group": "Portable Mail",
+      "summary": "Normalized Mail transport failure with stable retry, uncertainty, status, and delay metadata.",
+      "availability": "Node and browser",
+      "protocol": "Arcane Mail HTTP transport",
+      "normalization": "Exposes code, retryable, retryAfterMs, statusCode, uncertain, and complete remote detail"
+    },
+    {
+      "id": "mail:createMailOutbox",
+      "name": "createMailOutbox",
+      "displayName": "createMailOutbox()",
+      "kind": "function",
+      "signature": "createMailOutbox(options)",
+      "entrypoints": ["arcane-os/mail"],
+      "primaryImport": "arcane-os/mail",
+      "group": "Portable Mail",
+      "summary": "Creates a MailOutbox from caller-owned storage, locking, delivery, and lifecycle adapters.",
+      "availability": "Node or browser with the required injected outbox adapters",
+      "protocol": "arcane-mail-outbox/1",
+      "normalization": "Returns the same validated MailOutbox contract as direct construction"
+    },
+    {
+      "id": "mail:default",
+      "name": "default",
+      "displayName": "Mail default export",
+      "kind": "class",
+      "signature": "default as Mail",
+      "entrypoints": ["arcane-os/mail"],
+      "primaryImport": "arcane-os/mail",
+      "group": "Portable Mail",
+      "summary": "Default package binding for the same Mail class exposed by the named export.",
+      "availability": "Node with injected host adapters, or browser/native WebView with durable storage and Web Locks",
+      "protocol": "arcane-mail-outbox/1 with native Arcane.mail or complete HTTP delivery",
+      "normalization": "Binding identity is exactly equal to the named Mail export"
+    },
+    {
+      "id": "mail:normalizeMailEndpoint",
+      "name": "normalizeMailEndpoint",
+      "displayName": "normalizeMailEndpoint()",
+      "kind": "function",
+      "signature": "normalizeMailEndpoint(endpoint, base=globalThis.location?.href)",
+      "entrypoints": ["arcane-os/mail"],
+      "primaryImport": "arcane-os/mail",
+      "group": "Portable Mail",
+      "summary": "Resolves and validates one credential-free HTTPS or loopback-HTTP Mail endpoint.",
+      "availability": "Node and browser with URL support; relative endpoints require an explicit or global base URL",
+      "protocol": "Arcane Mail HTTP transport",
+      "normalization": "Returns an absolute URL and rejects credentials, query strings, fragments, and insecure non-loopback transport"
+    },
+    {
+      "id": "mail:resolveMailConfig",
+      "name": "resolveMailConfig",
+      "displayName": "resolveMailConfig()",
+      "kind": "function",
+      "signature": "resolveMailConfig(config=globalThis.arcane?.config?.mail||{}, options={})",
+      "entrypoints": ["arcane-os/mail"],
+      "primaryImport": "arcane-os/mail",
+      "group": "Portable Mail",
+      "summary": "Resolves application identity, key, endpoint, and timeout from explicit or host Mail configuration.",
+      "availability": "Node with explicit configuration, or browser/native WebView with optional document and location defaults",
+      "protocol": "Arcane Mail configuration",
+      "normalization": "Returns a mutable appName, appKey, endpoint, and requestTimeout record without initiating delivery"
+    },
+    {
+      "id": "mail:sendMailReport",
+      "name": "sendMailReport",
+      "displayName": "sendMailReport()",
+      "kind": "function",
+      "signature": "sendMailReport({ appKey, appName, endpoint, fetchImpl=globalThis.fetch, report, reportKey, requestTimeout=null, serializedReport, signal })",
+      "entrypoints": ["arcane-os/mail"],
+      "primaryImport": "arcane-os/mail",
+      "group": "Portable Mail",
+      "summary": "Sends one complete Mail report with an idempotency key through HTTP.",
+      "availability": "Node and browser with Fetch and AbortController, or an explicit fetch implementation",
+      "protocol": "Arcane Mail HTTP transport",
+      "normalization": "Validates request identity and complete body equality, preserves the complete response subject only to HTTP framing, and returns normalized acceptance or throws MailTransportError"
+    },
+    {
+      "id": "mail:serializeMailReport",
+      "name": "serializeMailReport",
+      "displayName": "serializeMailReport()",
+      "kind": "function",
+      "signature": "serializeMailReport(report)",
+      "entrypoints": ["arcane-os/mail"],
+      "primaryImport": "arcane-os/mail",
+      "group": "Portable Mail",
+      "summary": "Serializes one JSON-object Mail report for exact request-body comparison and delivery.",
+      "availability": "Node and browser",
+      "protocol": "Arcane Mail HTTP transport",
+      "normalization": "Returns compact JSON and rejects non-object or non-serializable reports"
+    }
+  ]
+}