oui-spec 0.1.0 → 0.2.0

package/dist/core/index.d.ts

@@ -1,120 +1,134 @@
-import { JSONSchema, OUIActionPolling, OUIActivation, OUISurface } from '../spec/index.js';
-export { OUIAction, OUIActionRequest, OUIActionResult, OUIObservation, OUIObservationUpdate, OUIProtocolEvent, OUISurfaceDeregistration, OUISurfaceRegistration, OUI_PROTOCOL_EVENTS } from '../spec/index.js';
+import { OUISurface } from '../spec/index.js';
+export { JSONSchema, OUIAction, OUIActionPolling, OUIActionRequest, OUIActionResult, OUIActivation, OUIObservation, OUIObservationUpdate, OUIProtocolEvent, OUISurfaceDeregistration, OUISurfaceRegistration, OUI_PROTOCOL_EVENTS } from '../spec/index.js';
+import { D as DefinedSurface, O as OUIBranded } from '../define-surface-DXBop-uB.js';
+export { A as ActionDefinition, a as ActionHandlerResult, b as ActionPollingConfig, c as ObservationDefinition, S as SurfaceDefinition, d as defineSurface } from '../define-surface-DXBop-uB.js';
+import { S as SocketLike, c as OUITransportConfig, b as OUITransport } from '../websocket-CiWvkaz_.js';
 
 /**
- * Configuration for defining an OUI surface with handlers.
- * This is the "integration file" an app provides — it declares both
- * the schema (what the agent sees) and the implementation (what executes).
+ * Compile-time validation for a createOUI configuration.
+ *
+ * These types resolve to a descriptive error type when a rule is broken, so the
+ * failure surfaces at the call site with a message naming the offending id —
+ * not as `Type 'X' is not assignable to type 'never'`.
+ *
+ * Everything here was previously a runtime `throw` inside defineSurface, or
+ * nothing at all. A duplicate action id threw when the surface was constructed,
+ * which in a React app means at render, in a browser, after a deploy. The same
+ * mistake is now a red squiggle.
  */
-interface SurfaceDefinition<TContext = unknown> {
-    id: string;
-    name: string;
-    description: string;
-    version?: string;
-    activation?: OUIActivation;
-    actions: ActionDefinition<TContext>[];
-    observations?: ObservationDefinition[];
-    metadata?: Record<string, unknown>;
-}
+/** A readable compile error. The message lands in the tooltip. */
+type OUIConfigError<TMessage extends string> = {
+    readonly __ouiError: TMessage;
+};
+/** Ids appearing more than once in a tuple of string literals. */
+type Duplicates<T extends readonly string[], Seen extends string = never> = T extends readonly [
+    infer Head extends string,
+    ...infer Rest extends readonly string[]
+] ? Head extends Seen ? Head | Duplicates<Rest, Seen | Head> : Duplicates<Rest, Seen | Head> : never;
 /**
- * Polling config with an optional resolve handler.
- * The spec's OUIActionPolling is the manifest shape (no functions).
- * The core extends it with the resolve implementation for the runtime.
+ * `never` when every id is unique, otherwise the duplicated ids.
+ * Exported for tests — a validation type nobody can assert against is a
+ * validation type nobody can trust.
  */
-interface ActionPollingConfig<TContext = unknown> extends OUIActionPolling {
-    /**
-     * Called on each poll interval. Receives the dispatch result from the handler
-     * plus the current context. Return { done: true, data } to stop polling,
-     * or { done: false, data } to continue.
-     */
-    resolve?: (dispatchResult: unknown, context: TContext) => Promise<{
-        done: boolean;
-        data: unknown;
-    }>;
-}
+type DuplicateIds<T extends readonly string[]> = Duplicates<T>;
+type IsEmpty<T extends readonly unknown[]> = T extends readonly [] ? true : false;
 /**
- * An action definition includes both the schema (for the agent) and
- * the handler (for execution). This is the single source of truth —
- * no separate YAML, no separate listener, no drift possible.
+ * Validate the surface list, returning the config type when it passes and an
+ * OUIConfigError when it does not.
+ *
+ * The rules, and why each exists:
+ *
+ *   Non-empty — an OUI instance with no surfaces registers nothing and
+ *   dispatches nowhere. It looks connected and does nothing, which is the
+ *   failure mode this whole design is trying to eliminate.
+ *
+ *   Unique surface ids — registration is keyed by surface id, so a duplicate
+ *   silently replaces the first surface's manifest. The agent then sees one
+ *   surface's actions attributed to the other.
+ */
+type ValidateSurfaceIds<TIds extends readonly string[]> = IsEmpty<TIds> extends true ? OUIConfigError<"createOUI requires at least one surface. An instance with no surfaces registers nothing and dispatches nowhere."> : [DuplicateIds<TIds>] extends [never] ? unknown : OUIConfigError<`Duplicate surface id: "${DuplicateIds<TIds>}". Surface registration is keyed by id, so the second would silently replace the first.`>;
+
+/**
+ * createOUI — the only supported way to instantiate OUI.
+ *
+ * WHY THIS EXISTS
+ *
+ * OUI shipped a correct protocol and a correct transport, and its first
+ * integrator used neither. studio-ui imported only the `SocketLike` TYPE from
+ * oui-spec and rebuilt the wire by hand: a literal map of protocol types to
+ * socket names, `oui:` hardcoded so the configurable namespace was unreachable,
+ * payload interfaces re-declared on the server, and an `action:result` channel
+ * mapped but never sent — duplicating the observation channel that already
+ * carries results.
+ *
+ * Nothing was wrong with the spec. Nothing enforced it. Structural typing meant
+ * every hand-rolled piece type-checked, and both ends agreed only by the
+ * coincidence of matching string literals. Rename one and the other keeps
+ * compiling and silently stops receiving.
+ *
+ * So the requirements are gated here:
+ *
+ *   OUI owns the wire. The integrator provides a socket; it cannot provide a
+ *   transport, because `OUITransport` values are branded and only this module
+ *   brands them.
+ *
+ *   OUI owns the result path. Results return through the observation channel,
+ *   as `use-surface` already implements. An integrator cannot add a parallel
+ *   channel because it cannot construct a transport to add one to.
+ *
+ *   The integrator owns content. Surfaces, action schemas, observation schemas
+ *   and handlers all arrive through `defineSurface`, whose output is branded —
+ *   so a plain object shaped like a surface will not compile.
+ *
+ *   Violations fail at compile time with a message naming the offending id.
  */
-interface ActionDefinition<TContext = unknown> {
-    id: string;
-    description: string;
-    input: JSONSchema;
-    output?: JSONSchema;
-    confirm?: boolean;
-    async?: boolean;
+
+/** A transport OUI constructed. Integrators cannot produce one. */
+type OwnedTransport = OUITransport & OUIBranded<"transport">;
+/** Surface ids as literal types, for the duplicate check. */
+type SurfaceIds<T extends readonly DefinedSurface<never>[]> = {
+    [K in keyof T]: T[K]["id"];
+};
+interface OUIConfig<TSurfaces extends readonly DefinedSurface<never>[]> {
     /**
-     * Polling/subscription config for async actions.
-     * After the handler returns, the OUI runtime starts polling or subscribing
-     * and pushes observation updates until the operation completes.
-     * Extends the spec's OUIActionPolling with an optional resolve handler.
+     * The socket OUI will speak over. The integrator owns the connection —
+     * auth, reconnection, lifecycle — and OUI owns what travels on it.
      */
-    polling?: ActionPollingConfig<TContext>;
-    usage?: string;
-    preconditions?: string;
-    estimatedDuration?: string;
-    tags?: string[];
+    socket: SocketLike;
     /**
-     * The handler that executes when the agent invokes this action.
-     * Receives typed params and a context object (app-specific state/utilities).
-     * Returns a result that the agent sees as the tool output.
+     * Surfaces produced by `defineSurface`. A plain object with the same shape
+     * will not compile: DefinedSurface is branded.
      */
-    handler: (params: Record<string, unknown>, context: TContext) => Promise<ActionHandlerResult>;
-}
-interface ActionHandlerResult {
-    success: boolean;
-    data?: unknown;
-    error?: {
-        code: string;
-        message: string;
-        details?: unknown;
+    surfaces: TSurfaces;
+    /**
+     * Wire configuration. `namespace` defaults to 'oui' and is the supported way
+     * to change the event prefix — hardcoding it at the call site is what made
+     * this option unreachable in the first integration.
+     */
+    transport?: Omit<OUITransportConfig, "namespace"> & {
+        namespace?: string;
     };
-    /** For async actions: metadata passed to the polling resolver */
-    dispatchMeta?: Record<string, unknown>;
 }
-interface ObservationDefinition {
-    id: string;
-    description: string;
-    schema: JSONSchema;
-    /** Function that returns the current observation value */
-    getValue?: () => unknown;
+/** A live OUI instance. */
+interface OUIInstance {
+    /** The transport OUI owns. Exposed for wiring, not for reimplementation. */
+    readonly transport: OwnedTransport;
+    /** Manifests for every registered surface, as the agent sees them. */
+    readonly manifests: readonly OUISurface[];
+    /** Register every surface and connect. */
+    start(): Promise<void>;
+    /** Deregister every surface and disconnect. */
+    stop(): void;
+    /** Look up a registered surface by id. */
+    getSurface(id: string): DefinedSurface<never> | undefined;
 }
 /**
- * Define an OUI surface — the single entry point for integrating
- * an application feature with the OUI protocol.
- *
- * This function validates the definition and returns a typed surface
- * object that can be registered with an agent runtime or transport layer.
+ * Instantiate OUI.
  *
- * @example
- * ```typescript
- * const mySurface = defineSurface({
- *   id: 'my-feature',
- *   name: 'My Feature',
- *   description: 'Does something cool',
- *   actions: [
- *     {
- *       id: 'do_thing',
- *       description: 'Does the thing',
- *       input: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] },
- *       handler: async (params) => {
- *         const result = await doTheThing(params.name);
- *         return { success: true, data: result };
- *       },
- *     },
- *   ],
- * });
- * ```
+ * `const` on the type parameter captures surface ids as literal types, which is
+ * what allows duplicate detection to name the offending id rather than failing
+ * with an unassignable-to-never error.
  */
-declare function defineSurface<TContext = unknown>(definition: SurfaceDefinition<TContext>): DefinedSurface<TContext>;
-/** A fully defined surface with both manifest extraction and execution capabilities */
-interface DefinedSurface<TContext = unknown> extends SurfaceDefinition<TContext> {
-    toManifest(): OUISurface;
-    executeAction(actionId: string, params: Record<string, unknown>, context: TContext): Promise<ActionHandlerResult>;
-    getActionIds(): string[];
-    /** Get the polling config for an action (if async) */
-    getPollingConfig(actionId: string): OUIActionPolling | undefined;
-}
+declare function createOUI<const TSurfaces extends readonly DefinedSurface<never>[]>(config: OUIConfig<TSurfaces> & ValidateSurfaceIds<SurfaceIds<TSurfaces>>): OUIInstance;
 
-export { type ActionDefinition, type ActionHandlerResult, type ActionPollingConfig, type DefinedSurface, JSONSchema, OUIActivation, OUISurface, type ObservationDefinition, type SurfaceDefinition, defineSurface };
+export { DefinedSurface, type DuplicateIds, OUIBranded, type OUIConfig, type OUIConfigError, type OUIInstance, OUISurface, type OwnedTransport, type ValidateSurfaceIds, createOUI };

package/dist/core/index.js

@@ -1,4 +1,5 @@
-export { defineSurface } from '../chunk-JO5LGOB6.js';
+export { createOUI, defineSurface } from '../chunk-ILUTAHUJ.js';
 export { OUI_PROTOCOL_EVENTS } from '../chunk-CVUUSPF4.js';
+import '../chunk-YDMGV72W.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/define-surface-D6XPtoqu.d.cts

@@ -0,0 +1,151 @@
+import { JSONSchema, OUIActionPolling, OUIActivation, OUISurface } from './spec/index.cjs';
+
+/**
+ * Nominal branding for values OUI must construct itself.
+ *
+ * Structural typing means any object with the right shape satisfies an
+ * interface. That is how Closure Studio ended up hand-rolling OUI's transport:
+ * `SocketLike` was importable, `OUITransport` was a plain interface, so an
+ * integrator could satisfy every type without ever calling OUI. The result was
+ * a second implementation of the wire — hardcoded namespace, re-declared
+ * payload types on the server, and a dead `action:result` mapping alongside the
+ * observation channel that already carried results.
+ *
+ * A unique symbol cannot be produced outside this module. Branding the types
+ * OUI owns turns "you should use our constructor" into "you cannot compile
+ * without it".
+ */
+declare const OUI_BRAND: unique symbol;
+/** Marks a value as constructed by OUI itself. */
+interface OUIBranded<TKind extends string> {
+    readonly [OUI_BRAND]: TKind;
+}
+
+/**
+ * Configuration for defining an OUI surface with handlers.
+ * This is the "integration file" an app provides — it declares both
+ * the schema (what the agent sees) and the implementation (what executes).
+ */
+interface SurfaceDefinition<TContext = unknown> {
+    id: string;
+    name: string;
+    description: string;
+    version?: string;
+    activation?: OUIActivation;
+    actions: ActionDefinition<TContext>[];
+    observations?: ObservationDefinition[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Polling config with an optional resolve handler.
+ * The spec's OUIActionPolling is the manifest shape (no functions).
+ * The core extends it with the resolve implementation for the runtime.
+ */
+interface ActionPollingConfig<TContext = unknown> extends OUIActionPolling {
+    /**
+     * Called on each poll interval. Receives the dispatch result from the handler
+     * plus the current context. Return { done: true, data } to stop polling,
+     * or { done: false, data } to continue.
+     */
+    resolve?: (dispatchResult: unknown, context: TContext) => Promise<{
+        done: boolean;
+        data: unknown;
+    }>;
+}
+/**
+ * An action definition includes both the schema (for the agent) and
+ * the handler (for execution). This is the single source of truth —
+ * no separate YAML, no separate listener, no drift possible.
+ */
+interface ActionDefinition<TContext = unknown> {
+    id: string;
+    description: string;
+    input: JSONSchema;
+    output?: JSONSchema;
+    confirm?: boolean;
+    async?: boolean;
+    /**
+     * Polling/subscription config for async actions.
+     * After the handler returns, the OUI runtime starts polling or subscribing
+     * and pushes observation updates until the operation completes.
+     * Extends the spec's OUIActionPolling with an optional resolve handler.
+     */
+    polling?: ActionPollingConfig<TContext>;
+    usage?: string;
+    preconditions?: string;
+    estimatedDuration?: string;
+    tags?: string[];
+    /**
+     * The handler that executes when the agent invokes this action.
+     * Receives typed params and a context object (app-specific state/utilities).
+     * Returns a result that the agent sees as the tool output.
+     */
+    handler: (params: Record<string, unknown>, context: TContext) => Promise<ActionHandlerResult>;
+}
+interface ActionHandlerResult {
+    success: boolean;
+    data?: unknown;
+    error?: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+    /** For async actions: metadata passed to the polling resolver */
+    dispatchMeta?: Record<string, unknown>;
+}
+interface ObservationDefinition {
+    id: string;
+    description: string;
+    schema: JSONSchema;
+    /** Function that returns the current observation value */
+    getValue?: () => unknown;
+}
+/**
+ * Define an OUI surface — the single entry point for integrating
+ * an application feature with the OUI protocol.
+ *
+ * This function validates the definition and returns a typed surface
+ * object that can be registered with an agent runtime or transport layer.
+ *
+ * @example
+ * ```typescript
+ * const mySurface = defineSurface({
+ *   id: 'my-feature',
+ *   name: 'My Feature',
+ *   description: 'Does something cool',
+ *   actions: [
+ *     {
+ *       id: 'do_thing',
+ *       description: 'Does the thing',
+ *       input: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] },
+ *       handler: async (params) => {
+ *         const result = await doTheThing(params.name);
+ *         return { success: true, data: result };
+ *       },
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+declare function defineSurface<TContext = unknown, const TId extends string = string>(definition: SurfaceDefinition<TContext> & {
+    id: TId;
+}): DefinedSurface<TContext> & {
+    id: TId;
+};
+/** A fully defined surface with both manifest extraction and execution capabilities */
+/**
+ * Branded so it can only come from `defineSurface`.
+ *
+ * Without the brand a plain object literal satisfies this interface
+ * structurally, which is how an integrator can assemble a surface that never
+ * ran defineSurface's duplicate-id checks and never produced a real manifest.
+ */
+interface DefinedSurface<TContext = unknown> extends SurfaceDefinition<TContext>, OUIBranded<"surface"> {
+    toManifest(): OUISurface;
+    executeAction(actionId: string, params: Record<string, unknown>, context: TContext): Promise<ActionHandlerResult>;
+    getActionIds(): string[];
+    /** Get the polling config for an action (if async) */
+    getPollingConfig(actionId: string): OUIActionPolling | undefined;
+}
+
+export { type ActionDefinition as A, type DefinedSurface as D, type OUIBranded as O, type SurfaceDefinition as S, type ActionHandlerResult as a, type ActionPollingConfig as b, type ObservationDefinition as c, defineSurface as d };

package/dist/define-surface-DXBop-uB.d.ts

@@ -0,0 +1,151 @@
+import { JSONSchema, OUIActionPolling, OUIActivation, OUISurface } from './spec/index.js';
+
+/**
+ * Nominal branding for values OUI must construct itself.
+ *
+ * Structural typing means any object with the right shape satisfies an
+ * interface. That is how Closure Studio ended up hand-rolling OUI's transport:
+ * `SocketLike` was importable, `OUITransport` was a plain interface, so an
+ * integrator could satisfy every type without ever calling OUI. The result was
+ * a second implementation of the wire — hardcoded namespace, re-declared
+ * payload types on the server, and a dead `action:result` mapping alongside the
+ * observation channel that already carried results.
+ *
+ * A unique symbol cannot be produced outside this module. Branding the types
+ * OUI owns turns "you should use our constructor" into "you cannot compile
+ * without it".
+ */
+declare const OUI_BRAND: unique symbol;
+/** Marks a value as constructed by OUI itself. */
+interface OUIBranded<TKind extends string> {
+    readonly [OUI_BRAND]: TKind;
+}
+
+/**
+ * Configuration for defining an OUI surface with handlers.
+ * This is the "integration file" an app provides — it declares both
+ * the schema (what the agent sees) and the implementation (what executes).
+ */
+interface SurfaceDefinition<TContext = unknown> {
+    id: string;
+    name: string;
+    description: string;
+    version?: string;
+    activation?: OUIActivation;
+    actions: ActionDefinition<TContext>[];
+    observations?: ObservationDefinition[];
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Polling config with an optional resolve handler.
+ * The spec's OUIActionPolling is the manifest shape (no functions).
+ * The core extends it with the resolve implementation for the runtime.
+ */
+interface ActionPollingConfig<TContext = unknown> extends OUIActionPolling {
+    /**
+     * Called on each poll interval. Receives the dispatch result from the handler
+     * plus the current context. Return { done: true, data } to stop polling,
+     * or { done: false, data } to continue.
+     */
+    resolve?: (dispatchResult: unknown, context: TContext) => Promise<{
+        done: boolean;
+        data: unknown;
+    }>;
+}
+/**
+ * An action definition includes both the schema (for the agent) and
+ * the handler (for execution). This is the single source of truth —
+ * no separate YAML, no separate listener, no drift possible.
+ */
+interface ActionDefinition<TContext = unknown> {
+    id: string;
+    description: string;
+    input: JSONSchema;
+    output?: JSONSchema;
+    confirm?: boolean;
+    async?: boolean;
+    /**
+     * Polling/subscription config for async actions.
+     * After the handler returns, the OUI runtime starts polling or subscribing
+     * and pushes observation updates until the operation completes.
+     * Extends the spec's OUIActionPolling with an optional resolve handler.
+     */
+    polling?: ActionPollingConfig<TContext>;
+    usage?: string;
+    preconditions?: string;
+    estimatedDuration?: string;
+    tags?: string[];
+    /**
+     * The handler that executes when the agent invokes this action.
+     * Receives typed params and a context object (app-specific state/utilities).
+     * Returns a result that the agent sees as the tool output.
+     */
+    handler: (params: Record<string, unknown>, context: TContext) => Promise<ActionHandlerResult>;
+}
+interface ActionHandlerResult {
+    success: boolean;
+    data?: unknown;
+    error?: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+    /** For async actions: metadata passed to the polling resolver */
+    dispatchMeta?: Record<string, unknown>;
+}
+interface ObservationDefinition {
+    id: string;
+    description: string;
+    schema: JSONSchema;
+    /** Function that returns the current observation value */
+    getValue?: () => unknown;
+}
+/**
+ * Define an OUI surface — the single entry point for integrating
+ * an application feature with the OUI protocol.
+ *
+ * This function validates the definition and returns a typed surface
+ * object that can be registered with an agent runtime or transport layer.
+ *
+ * @example
+ * ```typescript
+ * const mySurface = defineSurface({
+ *   id: 'my-feature',
+ *   name: 'My Feature',
+ *   description: 'Does something cool',
+ *   actions: [
+ *     {
+ *       id: 'do_thing',
+ *       description: 'Does the thing',
+ *       input: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'] },
+ *       handler: async (params) => {
+ *         const result = await doTheThing(params.name);
+ *         return { success: true, data: result };
+ *       },
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+declare function defineSurface<TContext = unknown, const TId extends string = string>(definition: SurfaceDefinition<TContext> & {
+    id: TId;
+}): DefinedSurface<TContext> & {
+    id: TId;
+};
+/** A fully defined surface with both manifest extraction and execution capabilities */
+/**
+ * Branded so it can only come from `defineSurface`.
+ *
+ * Without the brand a plain object literal satisfies this interface
+ * structurally, which is how an integrator can assemble a surface that never
+ * ran defineSurface's duplicate-id checks and never produced a real manifest.
+ */
+interface DefinedSurface<TContext = unknown> extends SurfaceDefinition<TContext>, OUIBranded<"surface"> {
+    toManifest(): OUISurface;
+    executeAction(actionId: string, params: Record<string, unknown>, context: TContext): Promise<ActionHandlerResult>;
+    getActionIds(): string[];
+    /** Get the polling config for an action (if async) */
+    getPollingConfig(actionId: string): OUIActionPolling | undefined;
+}
+
+export { type ActionDefinition as A, type DefinedSurface as D, type OUIBranded as O, type SurfaceDefinition as S, type ActionHandlerResult as a, type ActionPollingConfig as b, type ObservationDefinition as c, defineSurface as d };

package/dist/index.cjs

@@ -1,15 +1,20 @@
 'use strict';
 
-var chunkLEXIU2MH_cjs = require('./chunk-LEXIU2MH.cjs');
+var chunkHK7OXB2W_cjs = require('./chunk-HK7OXB2W.cjs');
 var chunk3DCIL4FV_cjs = require('./chunk-3DCIL4FV.cjs');
 var chunk2ON5IEXB_cjs = require('./chunk-2ON5IEXB.cjs');
-var chunkWZXUKJ7E_cjs = require('./chunk-WZXUKJ7E.cjs');
+var chunk5TQ6AVQH_cjs = require('./chunk-5TQ6AVQH.cjs');
+var chunkMTMEW6MM_cjs = require('./chunk-MTMEW6MM.cjs');
 
 
 
+Object.defineProperty(exports, "createOUI", {
+  enumerable: true,
+  get: function () { return chunkHK7OXB2W_cjs.createOUI; }
+});
 Object.defineProperty(exports, "defineSurface", {
   enumerable: true,
-  get: function () { return chunkLEXIU2MH_cjs.defineSurface; }
+  get: function () { return chunkHK7OXB2W_cjs.defineSurface; }
 });
 Object.defineProperty(exports, "OUI_PROTOCOL_EVENTS", {
   enumerable: true,
@@ -25,11 +30,11 @@ Object.defineProperty(exports, "useSurface", {
 });
 Object.defineProperty(exports, "createDirectTransportPair", {
   enumerable: true,
-  get: function () { return chunkWZXUKJ7E_cjs.createDirectTransportPair; }
+  get: function () { return chunk5TQ6AVQH_cjs.createDirectTransportPair; }
 });
 Object.defineProperty(exports, "createWebSocketTransport", {
   enumerable: true,
-  get: function () { return chunkWZXUKJ7E_cjs.createWebSocketTransport; }
+  get: function () { return chunkMTMEW6MM_cjs.createWebSocketTransport; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/index.d.cts

@@ -1,4 +1,6 @@
 export { JSONSchema, OUIAction, OUIActionPolling, OUIActionRequest, OUIActionResult, OUIActivation, OUIObservation, OUIObservationUpdate, OUIProtocolEvent, OUISurface, OUISurfaceDeregistration, OUISurfaceRegistration, OUI_PROTOCOL_EVENTS } from './spec/index.cjs';
-export { ActionDefinition, ActionHandlerResult, ActionPollingConfig, DefinedSurface, ObservationDefinition, SurfaceDefinition, defineSurface } from './core/index.cjs';
+export { A as ActionDefinition, a as ActionHandlerResult, b as ActionPollingConfig, D as DefinedSurface, O as OUIBranded, c as ObservationDefinition, S as SurfaceDefinition, d as defineSurface } from './define-surface-D6XPtoqu.cjs';
+export { DuplicateIds, OUIConfig, OUIConfigError, OUIInstance, OwnedTransport, ValidateSurfaceIds, createOUI } from './core/index.cjs';
 export { UseSurfaceOptions, useObservation, useSurface } from './react/index.cjs';
-export { OUIActionHandler, OUIObservationHandler, OUITransport, OUITransportConfig, SocketLike, createDirectTransportPair, createWebSocketTransport } from './transport/index.cjs';
+export { O as OUIActionHandler, a as OUIObservationHandler, b as OUITransport, c as OUITransportConfig, S as SocketLike, d as createWebSocketTransport } from './websocket-CrI0yRNo.cjs';
+export { createDirectTransportPair } from './transport/index.cjs';

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { JSONSchema, OUIAction, OUIActionPolling, OUIActionRequest, OUIActionResult, OUIActivation, OUIObservation, OUIObservationUpdate, OUIProtocolEvent, OUISurface, OUISurfaceDeregistration, OUISurfaceRegistration, OUI_PROTOCOL_EVENTS } from './spec/index.js';
-export { ActionDefinition, ActionHandlerResult, ActionPollingConfig, DefinedSurface, ObservationDefinition, SurfaceDefinition, defineSurface } from './core/index.js';
+export { A as ActionDefinition, a as ActionHandlerResult, b as ActionPollingConfig, D as DefinedSurface, O as OUIBranded, c as ObservationDefinition, S as SurfaceDefinition, d as defineSurface } from './define-surface-DXBop-uB.js';
+export { DuplicateIds, OUIConfig, OUIConfigError, OUIInstance, OwnedTransport, ValidateSurfaceIds, createOUI } from './core/index.js';
 export { UseSurfaceOptions, useObservation, useSurface } from './react/index.js';
-export { OUIActionHandler, OUIObservationHandler, OUITransport, OUITransportConfig, SocketLike, createDirectTransportPair, createWebSocketTransport } from './transport/index.js';
+export { O as OUIActionHandler, a as OUIObservationHandler, b as OUITransport, c as OUITransportConfig, S as SocketLike, d as createWebSocketTransport } from './websocket-CiWvkaz_.js';
+export { createDirectTransportPair } from './transport/index.js';

package/dist/index.js

@@ -1,6 +1,7 @@
-export { defineSurface } from './chunk-JO5LGOB6.js';
+export { createOUI, defineSurface } from './chunk-ILUTAHUJ.js';
 export { OUI_PROTOCOL_EVENTS } from './chunk-CVUUSPF4.js';
 export { useObservation, useSurface } from './chunk-UIGRLZOX.js';
-export { createDirectTransportPair, createWebSocketTransport } from './chunk-7EXSMPGR.js';
+export { createDirectTransportPair } from './chunk-O6EI77LD.js';
+export { createWebSocketTransport } from './chunk-YDMGV72W.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/react/index.d.cts

@@ -1,5 +1,5 @@
 import { OUIActionRequest, OUISurface } from '../spec/index.cjs';
-import { DefinedSurface } from '../core/index.cjs';
+import { D as DefinedSurface } from '../define-surface-D6XPtoqu.cjs';
 
 /**
  * Configuration for the useSurface hook.

package/dist/react/index.d.ts

@@ -1,5 +1,5 @@
 import { OUIActionRequest, OUISurface } from '../spec/index.js';
-import { DefinedSurface } from '../core/index.js';
+import { D as DefinedSurface } from '../define-surface-DXBop-uB.js';
 
 /**
  * Configuration for the useSurface hook.

package/dist/transport/index.cjs

@@ -1,16 +1,17 @@
 'use strict';
 
-var chunkWZXUKJ7E_cjs = require('../chunk-WZXUKJ7E.cjs');
+var chunk5TQ6AVQH_cjs = require('../chunk-5TQ6AVQH.cjs');
+var chunkMTMEW6MM_cjs = require('../chunk-MTMEW6MM.cjs');
 
 
 
 Object.defineProperty(exports, "createDirectTransportPair", {
   enumerable: true,
-  get: function () { return chunkWZXUKJ7E_cjs.createDirectTransportPair; }
+  get: function () { return chunk5TQ6AVQH_cjs.createDirectTransportPair; }
 });
 Object.defineProperty(exports, "createWebSocketTransport", {
   enumerable: true,
-  get: function () { return chunkWZXUKJ7E_cjs.createWebSocketTransport; }
+  get: function () { return chunkMTMEW6MM_cjs.createWebSocketTransport; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map