@vibesdotdev/host-cef 0.0.0-stage → 1.0.0-rc.4

package/dist/docs/plugin.js

@@ -0,0 +1,17 @@
+/**
+ * Docs-only plugin for the CEF runtime environment.
+ *
+ * Registers the owner `docs/topic` for runtime docs discovery. It does not
+ * select or register the environment: that happens before bootstrap through
+ * `@vibesdotdev/host-cef/plugin`.
+ */
+import { createRuntimePlugin } from '@vibesdotdev/kernel';
+import runtimeEnvironmentCefDocs from "./runtime-environment-cef.docs.descriptor.js";
+export const runtimeEnvironmentCefDocsPlugin = createRuntimePlugin({
+    id: '@vibesdotdev/host-cef/docs',
+    name: 'CEF Runtime Environment Docs',
+    description: 'Documentation for the CEF renderer runtime environment.',
+    descriptors: [runtimeEnvironmentCefDocs]
+});
+export default runtimeEnvironmentCefDocsPlugin;
+//# sourceMappingURL=plugin.js.map

package/dist/docs/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/docs/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,yBAAyB,MAAM,8CAA8C,CAAC;AAErF,MAAM,CAAC,MAAM,+BAA+B,GAAG,mBAAmB,CAAC;IAClE,EAAE,EAAE,4BAA4B;IAChC,IAAI,EAAE,8BAA8B;IACpC,WAAW,EAAE,yDAAyD;IACtE,WAAW,EAAE,CAAC,yBAAyB,CAAC;CACxC,CAAC,CAAC;AAEH,eAAe,+BAA+B,CAAC"}

package/dist/docs/runtime-environment-cef.docs.descriptor.d.ts

@@ -0,0 +1,20 @@
+/** Owner-authored `docs/topic` for the CEF renderer runtime environment. */
+declare const descriptor: {
+    kind: "docs/topic";
+    id: string;
+    parent: string;
+    order: number;
+    title: string;
+    summary: string;
+    tags: string[];
+    surfaces: readonly ["cli", "web", "in-app"];
+    hardware: readonly ["consumer"];
+    enabled: boolean;
+    body: {
+        type: "markdown";
+        sourceType: "raw";
+        source: string;
+    };
+};
+export default descriptor;
+//# sourceMappingURL=runtime-environment-cef.docs.descriptor.d.ts.map

package/dist/docs/runtime-environment-cef.docs.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-environment-cef.docs.descriptor.d.ts","sourceRoot":"","sources":["../../src/docs/runtime-environment-cef.docs.descriptor.ts"],"names":[],"mappings":"AAAA,4EAA4E;AA6J5E,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;CAgBf,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/runtime-environment-cef.docs.descriptor.js

@@ -0,0 +1,174 @@
+/** Owner-authored `docs/topic` for the CEF renderer runtime environment. */
+const source = `---
+title: CEF Runtime Environment
+summary: Credential-dark runtime environment for a native-attested CEF renderer
+tags: [runtime, environment, cef, browser, desktop]
+parent: runtime
+order: 6
+id: runtime.environment.cef
+surfaces: [cli, web, in-app]
+hardware: [consumer]
+---
+
+# CEF Runtime Environment
+
+\`@vibesdotdev/host-cef\` registers a CEF renderer as the local
+\`runtime/environment\`. The native host attests renderer facts; this package
+parses them strictly and turns them into runtime scope. It never exposes daemon
+endpoints, socket paths, credentials, undeclared environment values or filesystem paths.
+
+## Select it before bootstrap
+
+The environment must register before core bootstrap so its scope facts take
+part in discovery and candidate selection:
+
+\`\`\`ts
+import { ensureBrowserRuntime } from '@vibesdotdev/surface-sveltekit/surface-browser';
+import { createRuntimeEnvironmentCefPlugin } from '@vibesdotdev/host-cef/plugin';
+
+await ensureBrowserRuntime({
+  environment: async () => createRuntimeEnvironmentCefPlugin(),
+  plugins: [() => import('@vibesdotdev/kernel/client/plugin')]
+});
+\`\`\`
+
+Registering it as an ordinary feature plugin after bootstrap is a bug: its facts
+would not affect selection.
+
+## Host contract
+
+The plugin reads facts with one call, \`namespace.call('environment')\`, on the
+generic native namespace the host injects at \`globalThis.vibes.runtime\`. The
+host marks the page synchronously at document start
+(\`globalThis.__vibesNativeHost = 'cef'\`) and fires
+\`vibes:runtime-host-ready\` once the namespace is installed, so the plugin
+uses a namespace that is already there at once and otherwise waits for that
+event instead of polling. Pass \`namespace\` to supply it explicitly. Replies
+cross the host's JSON IPC.
+
+| Fact | Type |
+|---|---|
+| \`protocol\` | \`{ major: 1, minor }\` |
+| \`renderer\` | \`{ windowId, frameId, generation, origin }\` |
+| \`lifecycle\` | \`{ phase: 'loading' \\| 'ready' \\| 'closing', generation }\` |
+| \`trustedOrigin\` | non-empty string |
+| \`platform\` | \`'macos' \\| 'linux' \\| 'windows' \\| 'unknown'\` |
+| \`environmentTier\` | \`'local' \\| 'staging' \\| 'production'\` |
+| \`dev\` | boolean: the host runs a development build |
+| \`channelReady\` | boolean |
+| \`env\` | declared \`PUBLIC_*\` values the host captured once at launch; served by \`getEnv\`/\`getEnvSnapshot\` |
+| \`capabilities\` | up to 256 semantic runtime kind ids, never native method names |
+
+Every object, including the nested \`protocol\`, \`renderer\` and \`lifecycle\`,
+is strict. An unknown key such as \`renderer.token\` or \`protocol.endpoint\`
+fails the parse.
+
+## Host clock
+
+The environment supplies the host monotonic clock the kernel's lifecycle
+requires: live milliseconds from the renderer's browser performance clock
+(\`performance.now()\`, captured once at construction so readings cannot drift
+to another clock — never \`Date.now()\`). \`runtime.lifecycle.now()\` and
+disposal's finalization budget read it; the kernel validates the readings
+(finite, nonnegative, nondecreasing) and owns every lifecycle refusal. The
+page's own \`performance\` object is kept: \`performance.now\` is a browser
+interface operation that requires its original receiver, so the captured
+clock is never read off a copied object. A page whose \`performance\` global is missing,
+unreadable or has no callable \`now\` refuses
+\`UNAVAILABLE / host-unavailable\` at construction.
+
+## Runtime bindings
+
+The environment serves two values through the reader's owning schema:
+\`cef/runtime-namespace\` is the original native namespace with its receivers;
+\`cef/runtime-capabilities\` is the advertised semantic kind ids, available even
+without a namespace. An absent namespace or unknown binding key returns
+\`undefined\`. Reader-schema mismatches refuse
+\`INVALID_INPUT / binding-invalid\`. \`@vibesdotdev/kernel-rpc/cef\`
+consumes both bindings through the runtime, without reading page globals.
+
+## Resulting scope
+
+- \`surface: 'browser'\`, \`hardware: 'consumer'\`, \`purpose: 'direct'\`,
+  \`lifecycle: 'persistent'\`
+- \`hosting: { mode: 'local', owner: 'consumer', venue: 'user-device' }\`
+- no credential capability: the advertised ids stay host facts, and a renderer
+  has one actor (a single-principal invocation store), so
+  \`requestPrincipal()\` fails \`principal-source-undeclared\`
+- \`qualifiers\`: \`dev\`, \`cef: true\`, \`os\` (the platform),
+  \`environmentTier\`, \`trustedOrigin\`, \`rendererGeneration\`
+
+Config reads the \`environmentTier\` qualifier to pick the deployment
+environment. \`getEnv()\`/\`getEnvSnapshot()\` serve only the declared \`PUBLIC_*\` values the host captured at launch (every other key is \`undefined\`), and there is no secret accessor: credentials resolve through \`runtime.resolveCredential\`, which answers \`no-store\` here.
+
+## Native host client
+
+\`@vibesdotdev/host-cef/native-host/plugin\` registers \`cefNativeHostPlugin\`,
+the browser-scoped \`runtime/client\` \`host-cef\`; resolve it with
+\`getVibesClient(runtime, 'host-cef')\` and type it as the abstract
+\`CefNativeHostClient\`. It offers \`ready\`, \`call\`, \`emit\`, \`subscribe\` and
+\`subscribeLegacy\` over the own-property-only \`bridge\` and \`vibes\` globals.
+\`subscribeLegacy\` forwards \`bridge.onMessage\` and restores the original
+descriptor when the last listener leaves. Subscriptions and pending calls are
+released when the runtime is disposed.
+
+\`awaitCefRuntimeNamespace({ signal, lifecycle })\` also accepts an abort signal
+and a runtime lifecycle, and resolves on either \`vibes:runtime-host-ready\` or
+the legacy \`bridgeReady\` event.
+
+| Condition | Result |
+|---|---|
+| native member absent or inherited | \`UNAVAILABLE / cef-native-unavailable\` |
+| malformed native address, payload or member | \`INVALID_INPUT / cef-native-invalid\` |
+| wait or call aborted | \`CANCELLED / wait-aborted\`, \`details.cause\` \`caller-aborted\` (caller \`signal\`) or \`runtime-disposed\` (runtime or caller \`lifecycle\`) |
+
+\`call()\` rejects with the native function's own rejection unchanged; only
+boundary or member failures become \`cef-native-*\` refusals. Caught boundary
+failures appear only as \`details.failure.name\`, narrowed to a fixed
+class-name category.
+
+## Failures
+
+| Condition | Result | Remedy |
+|---|---|---|
+| the page carries no native host marker | \`CapabilityError\` \`UNAVAILABLE\` \`host-unavailable\`, at once | Load the renderer inside the Vibes CEF host, or pass \`namespace\` |
+| the ready event fires without an installed namespace | \`UNAVAILABLE\` \`host-unavailable\` | Fix the native host's injection order |
+| invalid or unreadable facts | \`INVALID_INPUT / cef-host-facts-invalid\` | Repair the strict host payload |
+| failed native environment call | \`UNAVAILABLE / cef-host-facts-unavailable\` | Restore the native channel |
+| unreadable globals or failed event registration | \`UNAVAILABLE / host-unavailable\` | Repair native injection |
+| unreadable renderer performance clock | \`UNAVAILABLE\` \`host-unavailable\`, at construction | Repair the page so its \`performance\` global is readable |
+| invalid constructor or plugin options | \`INVALID_INPUT / cef-environment-options-invalid\` | Supply a callable namespace and workspace root of 1–4096 characters |
+
+Host and options failures are typed, value-free refusals: fixed messages, bounded
+issue counts or fixed failure categories, without input values or raw causes.
+Compose \`@vibesdotdev/docs/plugin\` with this package's \`./docs/plugin\`
+to contribute this topic without selecting or registering a CEF environment.
+
+There is no timer, poll or optional mode: a build that selects this
+environment requires the CEF host.
+
+## Path mechanics
+
+This environment deliberately does not implement \`paths/runtime-path\`. A
+renderer has no host filesystem authority, and that contract exposes
+\`homedir()\` and \`tmpdir()\`.
+`;
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'runtime.environment.cef',
+    parent: 'runtime',
+    order: 6,
+    title: 'CEF Runtime Environment',
+    summary: 'Credential-dark runtime environment for a native-attested CEF renderer',
+    tags: ['runtime', 'environment', 'cef', 'browser', 'desktop'],
+    surfaces: ['cli', 'web', 'in-app'],
+    hardware: ['consumer'],
+    enabled: true,
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source
+    }
+};
+export default descriptor;
+//# sourceMappingURL=runtime-environment-cef.docs.descriptor.js.map

package/dist/docs/runtime-environment-cef.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-environment-cef.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/runtime-environment-cef.docs.descriptor.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAE5E,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyJd,CAAC;AAEF,MAAM,UAAU,GAAG;IAClB,IAAI,EAAE,YAAqB;IAC3B,EAAE,EAAE,yBAAyB;IAC7B,MAAM,EAAE,SAAS;IACjB,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,yBAAyB;IAChC,OAAO,EAAE,wEAAwE;IACjF,IAAI,EAAE,CAAC,SAAS,EAAE,aAAa,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,CAAC;IAC7D,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAU;IAC3C,QAAQ,EAAE,CAAC,UAAU,CAAU;IAC/B,OAAO,EAAE,IAAI;IACb,IAAI,EAAE;QACL,IAAI,EAAE,UAAmB;QACzB,UAAU,EAAE,KAAc;QAC1B,MAAM;KACN;CACD,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/environment.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Direct construction of the concrete CEF environment implementation.
+ *
+ * Normal composition goes through `./plugin` or `runtime/environment`
+ * resolution; this explicit entrypoint exists for hosts and tests that
+ * construct `CefEnvironment` themselves (with or without a namespace).
+ * The root barrel deliberately does not export the implementation class.
+ */
+export { CefEnvironment } from './cef-environment.impl.ts';
+export type { CefEnvironmentDeclaration } from './schemas/options.ts';
+//# sourceMappingURL=environment.d.ts.map

package/dist/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../src/environment.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,YAAY,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/environment.js

@@ -0,0 +1,10 @@
+/**
+ * Direct construction of the concrete CEF environment implementation.
+ *
+ * Normal composition goes through `./plugin` or `runtime/environment`
+ * resolution; this explicit entrypoint exists for hosts and tests that
+ * construct `CefEnvironment` themselves (with or without a namespace).
+ * The root barrel deliberately does not export the implementation class.
+ */
+export { CefEnvironment } from "./cef-environment.impl.js";
+//# sourceMappingURL=environment.js.map

package/dist/environment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.js","sourceRoot":"","sources":["../src/environment.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { CEF_ENVIRONMENT_OPTIONS_INVALID, CEF_RUNTIME_CAPABILITIES_BINDING, CEF_RUNTIME_NAMESPACE_BINDING, CefHostFactsSchema, CefHostLifecycleSchema, getGlobalCefRuntimeNamespace, readCefHostFacts, awaitCefRuntimeNamespace, NATIVE_HOST_MARKER, NATIVE_HOST_READY_EVENT, type CefHostFacts, type CefHostLifecycle, type CefRuntimeNamespace } from './contracts.ts';
+export type { CefEnvironmentDeclaration } from './schemas/options.ts';
+export { createRuntimeEnvironmentCefPlugin, runtimeEnvironmentCefPlugin, type RuntimeEnvironmentCefPluginOptions } from './runtime-environment-cef.plugin.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,+BAA+B,EAC/B,gCAAgC,EAChC,6BAA6B,EAC7B,kBAAkB,EAClB,sBAAsB,EACtB,4BAA4B,EAC5B,gBAAgB,EAChB,wBAAwB,EACxB,kBAAkB,EAClB,uBAAuB,EACvB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACtE,OAAO,EACN,iCAAiC,EACjC,2BAA2B,EAC3B,KAAK,kCAAkC,EACvC,MAAM,qCAAqC,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { CEF_ENVIRONMENT_OPTIONS_INVALID, CEF_RUNTIME_CAPABILITIES_BINDING, CEF_RUNTIME_NAMESPACE_BINDING, CefHostFactsSchema, CefHostLifecycleSchema, getGlobalCefRuntimeNamespace, readCefHostFacts, awaitCefRuntimeNamespace, NATIVE_HOST_MARKER, NATIVE_HOST_READY_EVENT } from "./contracts.js";
+export { createRuntimeEnvironmentCefPlugin, runtimeEnvironmentCefPlugin } from "./runtime-environment-cef.plugin.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,+BAA+B,EAC/B,gCAAgC,EAChC,6BAA6B,EAC7B,kBAAkB,EAClB,sBAAsB,EACtB,4BAA4B,EAC5B,gBAAgB,EAChB,wBAAwB,EACxB,kBAAkB,EAClB,uBAAuB,EAIvB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACN,iCAAiC,EACjC,2BAA2B,EAE3B,MAAM,qCAAqC,CAAC"}

package/dist/native-host.client.d.ts

@@ -0,0 +1,15 @@
+import { BaseRuntimeClient } from '@vibesdotdev/kernel/client';
+import type { VibesRuntime } from '@vibesdotdev/kernel';
+import type { JsonValue } from '@vibesdotdev/kernel/schemas/json';
+import type { CefNativeCall, CefNativeEvent, CefNativeListener, CefLegacyListener } from './schemas/native-host.ts';
+import type { CefRuntimeNamespace } from './schemas/namespace.ts';
+import type { CefReadinessOptions } from './schemas/readiness.ts';
+/** Semantic native mechanism; resolve 'host-cef' through kernel/client. Domain replies belong to their owners. */
+export declare abstract class CefNativeHostClient extends BaseRuntimeClient<VibesRuntime> {
+    abstract ready(options?: CefReadinessOptions): Promise<CefRuntimeNamespace>;
+    abstract call(input: CefNativeCall, options?: CefReadinessOptions): Promise<JsonValue>;
+    abstract emit(input: CefNativeCall): void;
+    abstract subscribe(input: CefNativeEvent, listener: CefNativeListener): () => void;
+    abstract subscribeLegacy(listener: CefLegacyListener): () => void;
+}
+//# sourceMappingURL=native-host.client.d.ts.map

package/dist/native-host.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-host.client.d.ts","sourceRoot":"","sources":["../src/native-host.client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACpH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAElE,kHAAkH;AAClH,8BAAsB,mBAAoB,SAAQ,iBAAiB,CAAC,YAAY,CAAC;IAChF,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAC3E,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,SAAS,CAAC;IACtF,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IACzC,QAAQ,CAAC,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,iBAAiB,GAAG,MAAM,IAAI;IAClF,QAAQ,CAAC,eAAe,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,IAAI;CACjE"}

package/dist/native-host.client.descriptor.d.ts

@@ -0,0 +1,27 @@
+declare const _default: {
+    id: string;
+    kind: "runtime/client";
+    name?: string | undefined;
+    tags?: string[] | undefined;
+    hardware?: string[] | undefined;
+    enabled?: boolean | undefined;
+    priority?: number | undefined;
+    capabilityId?: string | undefined;
+    requiredContext?: string[] | undefined;
+    optionalContext?: string[] | undefined;
+    config?: unknown;
+    retention?: string | {
+        reason: string;
+        maxAgeDays?: number | undefined;
+        maxEntries?: number | undefined;
+        maxBytes?: number | undefined;
+        cascadeFrom?: string | undefined;
+        ageField?: string | undefined;
+        enforcedBy?: string | undefined;
+    } | undefined;
+    configManifestId?: string | undefined;
+    baseUrl?: string | undefined;
+    description?: string | undefined;
+};
+export default _default;
+//# sourceMappingURL=native-host.client.descriptor.d.ts.map

package/dist/native-host.client.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-host.client.descriptor.d.ts","sourceRoot":"","sources":["../src/native-host.client.descriptor.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,wBAKG"}

package/dist/native-host.client.descriptor.js

@@ -0,0 +1,8 @@
+import { RuntimeClientDescriptorSchema } from '@vibesdotdev/kernel/client';
+export default RuntimeClientDescriptorSchema.parse({
+    id: 'host-cef',
+    kind: 'runtime/client',
+    surfaces: ['browser'],
+    description: 'Lifecycle-owned CEF native calls, events and compatibility messages.'
+});
+//# sourceMappingURL=native-host.client.descriptor.js.map

package/dist/native-host.client.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-host.client.descriptor.js","sourceRoot":"","sources":["../src/native-host.client.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAC;AAE3E,eAAe,6BAA6B,CAAC,KAAK,CAAC;IAClD,EAAE,EAAE,UAAU;IACd,IAAI,EAAE,gBAAgB;IACtB,QAAQ,EAAE,CAAC,SAAS,CAAC;IACrB,WAAW,EAAE,sEAAsE;CACnF,CAAC,CAAC"}

package/dist/native-host.client.impl.browser.d.ts

@@ -0,0 +1,24 @@
+import { type JsonValue } from '@vibesdotdev/kernel/schemas/json';
+import { CefNativeHostClient } from './native-host.client.ts';
+import { type CefReadinessOptions } from './schemas/readiness.ts';
+import { type CefNativeCall, type CefNativeEvent, type CefNativeListener, type CefLegacyListener } from './schemas/native-host.ts';
+export default class CefNativeHostBrowserClient extends CefNativeHostClient {
+    private closed;
+    private readonly cleanups;
+    private readonly legacy;
+    private detachLegacy?;
+    private assertLive;
+    /** A caller lifecycle is lifecycle, like the runtime's own: only the caller's plain signal is `caller-aborted`. */
+    private cancelled;
+    ready(options?: CefReadinessOptions): Promise<{
+        call: (method: string, args?: JsonValue) => Promise<JsonValue>;
+        subscribe?: ((event: string, listener: (value: JsonValue) => void) => () => void) | undefined;
+    }>;
+    call(input: CefNativeCall, optionsInput?: CefReadinessOptions): Promise<JsonValue>;
+    emit(input: CefNativeCall): void;
+    private own;
+    subscribe(input: CefNativeEvent, listenerInput: CefNativeListener): () => void;
+    subscribeLegacy(listenerInput: CefLegacyListener): () => void;
+    protected onDispose(): void;
+}
+//# sourceMappingURL=native-host.client.impl.browser.d.ts.map

package/dist/native-host.client.impl.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-host.client.impl.browser.d.ts","sourceRoot":"","sources":["../src/native-host.client.impl.browser.ts"],"names":[],"mappings":"AAEA,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,kCAAkC,CAAC;AACnF,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,OAAO,EAA6B,KAAK,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7F,OAAO,EAKiB,KAAK,aAAa,EAAE,KAAK,cAAc,EAC9D,KAAK,iBAAiB,EAAE,KAAK,iBAAiB,EAC9C,MAAM,0BAA0B,CAAC;AA8DlC,MAAM,CAAC,OAAO,OAAO,0BAA2B,SAAQ,mBAAmB;IAC1E,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD,OAAO,CAAC,YAAY,CAAC,CAAa;IAElC,OAAO,CAAC,UAAU;IAIlB,mHAAmH;IACnH,OAAO,CAAC,SAAS;IAQjB,KAAK,CAAC,OAAO,GAAE,mBAAwB;;;;IAUjC,IAAI,CAAC,KAAK,EAAE,aAAa,EAAE,YAAY,GAAE,mBAAwB,GAAG,OAAO,CAAC,SAAS,CAAC;IAoD5F,IAAI,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAOhC,OAAO,CAAC,GAAG;IAiBX,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,iBAAiB,GAAG,MAAM,IAAI;IAkB9E,eAAe,CAAC,aAAa,EAAE,iBAAiB,GAAG,MAAM,IAAI;cA+C1C,SAAS,IAAI,IAAI;CASpC"}

package/dist/native-host.client.impl.browser.js

@@ -0,0 +1,279 @@
+import { CapabilityError, settle, settleNow } from '@vibesdotdev/kernel';
+import { JsonValueSchema } from '@vibesdotdev/kernel/schemas/json';
+import { CefNativeHostClient } from "./native-host.client.js";
+import { awaitCefRuntimeNamespace, failureFacts, readCefInput } from "./contracts.js";
+import { CefReadinessOptionsSchema } from "./schemas/readiness.js";
+import { CefNativeAddressSchema, CefNativeCallSchema, CefNativeEventSchema, CefNativeNameSchema, CefNativeListenerSchema, CefLegacyListenerSchema, CefNativeObjectSchema, CefNativeFunctionSchema, CefNativeEmitSchema, CefNativeSubscribeSchema, CefNativeDisposeSchema, CefNativePayloadSchema } from "./schemas/native-host.js";
+function refusal(reason, failure) {
+    return new CapabilityError('The CEF native capability could not be used.', reason === 'cef-native-invalid' ? 'INVALID_INPUT' : 'UNAVAILABLE', {
+        reason, retryable: false,
+        details: failure ? failureFacts(failure) : undefined
+    });
+}
+/**
+ * Read an own member of a native holder. Getters run with their holder as
+ * receiver, matching ordinary property access; callers parse the result
+ * through the owning schema before using it.
+ */
+function member(object, name) {
+    const descriptor = Object.getOwnPropertyDescriptor(object, name);
+    const getter = descriptor?.get;
+    if (getter !== undefined)
+        return getter.call(object);
+    return descriptor?.value;
+}
+/** Resolve only injected own properties; never grant inherited or fallback authority. */
+function target(input) {
+    const address = readCefInput(CefNativeAddressSchema, input);
+    const result = settleNow(() => {
+        let current = CefNativeObjectSchema.parse(globalThis);
+        for (const part of [address.scope, ...(address.namespace?.split('.') ?? [])]) {
+            if (!Object.hasOwn(current, part))
+                throw refusal('cef-native-unavailable');
+            const next = member(current, part);
+            if (next === undefined)
+                throw refusal('cef-native-unavailable');
+            const parsed = CefNativeObjectSchema.safeParse(next);
+            if (!parsed.success)
+                throw refusal('cef-native-invalid');
+            current = parsed.data;
+        }
+        return current;
+    });
+    if (result.ok)
+        return result.value;
+    if (result.cause instanceof CapabilityError)
+        throw result.cause;
+    throw refusal('cef-native-invalid', result.cause);
+}
+function method(object, name, schema) {
+    const result = settleNow(() => {
+        if (!Object.hasOwn(object, name))
+            throw refusal('cef-native-unavailable');
+        const value = member(object, name);
+        if (value === undefined)
+            throw refusal('cef-native-unavailable');
+        const parsed = schema.safeParse(value);
+        if (!parsed.success)
+            throw refusal('cef-native-invalid');
+        return parsed.data;
+    });
+    if (result.ok)
+        return result.value;
+    if (result.cause instanceof CapabilityError)
+        throw result.cause;
+    throw refusal('cef-native-invalid', result.cause);
+}
+function payload(value, serialized = false) {
+    const result = settleNow(() => (serialized ? CefNativePayloadSchema : JsonValueSchema).safeParse(value));
+    if (!result.ok)
+        throw refusal('cef-native-invalid', result.cause);
+    if (!result.value.success)
+        throw refusal('cef-native-invalid', result.value.error);
+    return result.value.data;
+}
+export default class CefNativeHostBrowserClient extends CefNativeHostClient {
+    closed = false;
+    cleanups = new Set();
+    legacy = new Set();
+    detachLegacy;
+    assertLive() {
+        if (this.closed || this.runtime.lifecycle.signal.aborted)
+            throw this.cancelled();
+    }
+    /** A caller lifecycle is lifecycle, like the runtime's own: only the caller's plain signal is `caller-aborted`. */
+    cancelled(lifecycle) {
+        const disposed = this.closed || this.runtime.lifecycle.signal.aborted || lifecycle?.aborted === true;
+        return new CapabilityError('The CEF native operation was cancelled.', 'CANCELLED', {
+            reason: 'wait-aborted', retryable: false,
+            details: { cause: disposed ? 'runtime-disposed' : 'caller-aborted' }
+        });
+    }
+    ready(options = {}) {
+        this.assertLive();
+        const parsed = readCefInput(CefReadinessOptionsSchema, options);
+        const lifecycle = [this.runtime.lifecycle.signal, parsed.lifecycle?.signal].filter((signal) => signal !== undefined);
+        return awaitCefRuntimeNamespace({
+            signal: parsed.signal,
+            lifecycle: { signal: AbortSignal.any(lifecycle) }
+        });
+    }
+    async call(input, optionsInput = {}) {
+        this.assertLive();
+        const request = readCefInput(CefNativeCallSchema, input);
+        const options = readCefInput(CefReadinessOptionsSchema, optionsInput);
+        const signals = [options.signal, options.lifecycle?.signal, this.runtime.lifecycle.signal]
+            .filter((signal) => signal !== undefined);
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const cleanup = () => {
+                this.cleanups.delete(abort);
+                const failures = [];
+                for (const signal of signals) {
+                    const result = settleNow(() => signal.removeEventListener('abort', abort));
+                    if (!result.ok)
+                        failures.push(result.cause);
+                }
+                return failures;
+            };
+            const finish = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                const failures = cleanup();
+                if ('failure' in result) {
+                    // Preserve admission rejection identity, including non-Error throws.
+                    reject(result.failure instanceof Error ? result.failure : result.failure.value);
+                }
+                else if (failures.length)
+                    reject(refusal('cef-native-invalid', failures[0]));
+                else
+                    resolve(result.value);
+            };
+            const abort = () => finish({ failure: this.cancelled(options.lifecycle?.signal) });
+            this.cleanups.add(abort);
+            const registration = settleNow(() => {
+                for (const signal of signals) {
+                    signal.addEventListener('abort', abort, { once: true });
+                    if (settled)
+                        signal.removeEventListener('abort', abort);
+                }
+            });
+            if (!registration.ok) {
+                finish({ failure: refusal('cef-native-invalid', registration.cause) });
+                return;
+            }
+            if (signals.some((signal) => signal.aborted)) {
+                abort();
+                return;
+            }
+            void settle(async () => {
+                if (settled)
+                    return null;
+                const receiver = target(request);
+                const call = method(receiver, 'call', CefNativeFunctionSchema);
+                return payload(await call.call(receiver, request.method, request.args));
+            }).then((result) => {
+                if (result.ok)
+                    finish({ value: result.value });
+                else
+                    finish({ failure: result.cause });
+            });
+        });
+    }
+    emit(input) {
+        this.assertLive();
+        const request = readCefInput(CefNativeCallSchema, input);
+        const receiver = target(request);
+        method(receiver, 'emit', CefNativeEmitSchema).call(receiver, request.method, request.args);
+    }
+    own(dispose) {
+        let active = true;
+        const cleanup = () => {
+            if (!active)
+                return;
+            active = false;
+            this.cleanups.delete(cleanup);
+            const detached = settleNow(() => this.runtime.lifecycle.signal.removeEventListener('abort', cleanup));
+            const disposed = settleNow(dispose);
+            if (!disposed.ok)
+                throw refusal('cef-native-invalid', disposed.cause);
+            if (!detached.ok)
+                throw refusal('cef-native-invalid', detached.cause);
+        };
+        this.cleanups.add(cleanup);
+        this.runtime.lifecycle.signal.addEventListener('abort', cleanup, { once: true });
+        if (this.runtime.lifecycle.signal.aborted)
+            cleanup();
+        return cleanup;
+    }
+    subscribe(input, listenerInput) {
+        this.assertLive();
+        const request = readCefInput(CefNativeEventSchema, input);
+        const listener = readCefInput(CefNativeListenerSchema, listenerInput);
+        const receiver = target(request);
+        let active = true;
+        const unsubscribe = method(receiver, 'subscribe', CefNativeSubscribeSchema).call(receiver, request.event, (value) => {
+            const decoded = payload(value, true);
+            if (active && !this.runtime.lifecycle.signal.aborted)
+                listener(decoded);
+        });
+        const parsed = CefNativeDisposeSchema.safeParse(unsubscribe);
+        if (!parsed.success) {
+            active = false;
+            throw refusal('cef-native-invalid', parsed.error);
+        }
+        return this.own(() => {
+            active = false;
+            parsed.data();
+        });
+    }
+    subscribeLegacy(listenerInput) {
+        this.assertLive();
+        const listener = readCefInput(CefLegacyListenerSchema, listenerInput);
+        const bridge = target({ scope: 'bridge', namespace: null });
+        if (!this.detachLegacy) {
+            const capture = settleNow(() => {
+                const original = Object.getOwnPropertyDescriptor(bridge, 'onMessage');
+                const previous = member(bridge, 'onMessage');
+                return { original, previous };
+            });
+            if (!capture.ok)
+                throw refusal('cef-native-invalid', capture.cause);
+            const { original, previous } = capture.value;
+            const callback = CefLegacyListenerSchema.optional().safeParse(previous);
+            if (!callback.success)
+                throw refusal('cef-native-invalid', callback.error);
+            const forward = (name, value) => {
+                const messageName = CefNativeNameSchema.parse(name);
+                const decoded = payload(value, true);
+                const failures = [];
+                if (callback.data) {
+                    const result = settleNow(() => callback.data?.call(bridge, messageName, value));
+                    if (!result.ok)
+                        failures.push(result.cause);
+                }
+                for (const handler of this.legacy) {
+                    const result = settleNow(() => handler(messageName, decoded));
+                    if (!result.ok)
+                        failures.push(result.cause);
+                }
+                if (failures.length)
+                    throw refusal('cef-native-invalid', new AggregateError(failures));
+            };
+            const installed = settleNow(() => {
+                if (!Reflect.set(bridge, 'onMessage', forward))
+                    throw refusal('cef-native-invalid');
+            });
+            if (!installed.ok)
+                throw refusal('cef-native-invalid', installed.cause);
+            this.detachLegacy = () => {
+                if (member(bridge, 'onMessage') === forward) {
+                    if (original)
+                        Object.defineProperty(bridge, 'onMessage', original);
+                    else if (!Reflect.deleteProperty(bridge, 'onMessage'))
+                        throw refusal('cef-native-invalid');
+                }
+                this.detachLegacy = undefined;
+            };
+        }
+        this.legacy.add(listener);
+        return this.own(() => {
+            this.legacy.delete(listener);
+            if (!this.legacy.size)
+                this.detachLegacy?.();
+        });
+    }
+    onDispose() {
+        this.closed = true;
+        const failures = [];
+        for (const cleanup of this.cleanups) {
+            const result = settleNow(cleanup);
+            if (!result.ok)
+                failures.push(result.cause);
+        }
+        if (failures.length)
+            throw refusal('cef-native-invalid', new AggregateError(failures));
+    }
+}
+//# sourceMappingURL=native-host.client.impl.browser.js.map