@holo-js/broadcast 0.1.3

package/dist/chunk-QW6MHEWS.mjs

@@ -0,0 +1,281 @@
+// src/contracts.ts
+var HOLO_BROADCAST_DEFINITION_MARKER = /* @__PURE__ */ Symbol.for("holo-js.broadcast.definition");
+var HOLO_CHANNEL_DEFINITION_MARKER = /* @__PURE__ */ Symbol.for("holo-js.broadcast.channel");
+function isReadonlyArray(value) {
+  return Array.isArray(value);
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function normalizeOptionalString(value, label) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error(`[Holo Broadcast] ${label} must be a non-empty string when provided.`);
+  }
+  return normalized;
+}
+function normalizeDelayValue(value) {
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new TypeError("[Holo Broadcast] Broadcast delay must be a finite number greater than or equal to 0.");
+    }
+    return value;
+  }
+  if (!(value instanceof Date) || Number.isNaN(value.getTime())) {
+    throw new TypeError("[Holo Broadcast] Broadcast delay dates must be valid Date instances.");
+  }
+  return value;
+}
+function normalizeJsonValue(value, path) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return Object.freeze(value.map((entry, index) => normalizeJsonValue(entry, `${path}[${index}]`)));
+  }
+  if (isPlainObject(value)) {
+    return Object.freeze(Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => {
+        if (!key.trim()) {
+          throw new Error(`[Holo Broadcast] ${path} must not include empty payload keys.`);
+        }
+        return [key, normalizeJsonValue(entry, `${path}.${key}`)];
+      })
+    ));
+  }
+  throw new Error(`[Holo Broadcast] ${path} must be JSON-serializable.`);
+}
+function normalizePayload(payload) {
+  const resolved = typeof payload === "function" ? payload() : payload;
+  if (!isPlainObject(resolved)) {
+    throw new Error("[Holo Broadcast] Broadcast payload must be a plain object.");
+  }
+  return normalizeJsonValue(resolved, "Broadcast payload");
+}
+function normalizeQueueOptions(queue) {
+  if (typeof queue === "boolean" || typeof queue === "undefined") {
+    return Object.freeze({
+      queued: queue === true,
+      afterCommit: false
+    });
+  }
+  const connection = normalizeOptionalString(queue.connection, "Broadcast queue connection");
+  const queueName = normalizeOptionalString(queue.queue, "Broadcast queue name");
+  const afterCommit = queue.afterCommit === true;
+  const queued = queue.queued === true;
+  if (!queued && (connection || queueName)) {
+    throw new Error("[Holo Broadcast] Broadcast queue metadata requires queued: true.");
+  }
+  return Object.freeze({
+    queued,
+    ...typeof connection === "undefined" ? {} : { connection },
+    ...typeof queueName === "undefined" ? {} : { queue: queueName },
+    afterCommit
+  });
+}
+function normalizePatternSegment(segment, label) {
+  if (!segment) {
+    throw new Error(`[Holo Broadcast] ${label} must not contain empty path segments.`);
+  }
+  const wildcardMatch = segment.match(/^\{([A-Za-z_][A-Za-z0-9_]*)\}$/);
+  if (wildcardMatch) {
+    return wildcardMatch[1];
+  }
+  if (!/^[A-Za-z0-9_-]+$/.test(segment)) {
+    throw new Error(`[Holo Broadcast] ${label} contains invalid segment "${segment}".`);
+  }
+  return segment;
+}
+function extractChannelPatternParamNames(pattern) {
+  const normalized = normalizeChannelPattern(pattern, "Channel pattern");
+  const params = normalized.split(".").map((segment) => segment.match(/^\{([A-Za-z_][A-Za-z0-9_]*)\}$/)?.[1]).filter((value) => typeof value === "string");
+  const duplicates = params.filter((param, index) => params.indexOf(param) !== index);
+  if (duplicates.length > 0) {
+    throw new Error(`[Holo Broadcast] Channel pattern "${normalized}" contains duplicate params.`);
+  }
+  return Object.freeze(params);
+}
+function normalizeChannelPattern(pattern, label = "Channel pattern") {
+  const normalized = normalizeOptionalString(pattern, label) ?? (() => {
+    throw new Error(`[Holo Broadcast] ${label} must be a non-empty string.`);
+  })();
+  normalized.split(".").forEach((segment) => normalizePatternSegment(segment, label));
+  return normalized;
+}
+function normalizeTargetParams(pattern, params) {
+  const expectedParams = extractChannelPatternParamNames(pattern);
+  const providedEntries = Object.entries(params ?? {}).filter(([, value]) => typeof value !== "undefined").map(([key, value]) => {
+    const normalizedKey = key.trim();
+    if (!normalizedKey) {
+      throw new Error("[Holo Broadcast] Channel target params must not include empty keys.");
+    }
+    return [normalizedKey, String(value)];
+  });
+  const provided = Object.freeze(Object.fromEntries(providedEntries));
+  const providedNames = Object.keys(provided);
+  for (const param of expectedParams) {
+    if (!(param in provided)) {
+      throw new Error(`[Holo Broadcast] Channel target for "${pattern}" must define param "${param}".`);
+    }
+  }
+  for (const param of providedNames) {
+    if (!expectedParams.includes(param)) {
+      throw new Error(`[Holo Broadcast] Channel target for "${pattern}" does not define param "${param}".`);
+    }
+  }
+  return provided;
+}
+function formatChannelPattern(pattern, params) {
+  return normalizeChannelPattern(pattern).replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, key) => {
+    const value = params[key];
+    if (typeof value !== "string") {
+      throw new Error(`[Holo Broadcast] Channel target for "${pattern}" is missing param "${key}".`);
+    }
+    return value;
+  });
+}
+function createChannelTarget(type, pattern, params) {
+  const normalizedPattern = normalizeChannelPattern(pattern, "Channel target pattern");
+  return Object.freeze({
+    type,
+    pattern: normalizedPattern,
+    params: normalizeTargetParams(normalizedPattern, params)
+  });
+}
+function normalizeChannels(input) {
+  const resolved = typeof input === "function" ? input() : input;
+  if (!isReadonlyArray(resolved) || resolved.length === 0) {
+    throw new Error("[Holo Broadcast] Broadcast definitions must target at least one channel.");
+  }
+  const normalizedChannels = resolved.map((channel2, index) => {
+    if (!isBroadcastChannelTarget(channel2)) {
+      throw new Error(`[Holo Broadcast] Broadcast channel at index ${index} must be created through channel helpers.`);
+    }
+    return Object.freeze({
+      type: channel2.type,
+      pattern: normalizeChannelPattern(channel2.pattern, `Broadcast channel ${index} pattern`),
+      params: normalizeTargetParams(channel2.pattern, channel2.params)
+    });
+  });
+  return Object.freeze(normalizedChannels);
+}
+function normalizeWhisperDefinitions(whispers) {
+  const entries = Object.entries(whispers ?? {});
+  const normalizedEntries = entries.map(([name, schema]) => {
+    const normalizedName = normalizeOptionalString(name, "Whisper event name");
+    if (!normalizedName) {
+      throw new Error("[Holo Broadcast] Whisper event names must be non-empty strings.");
+    }
+    if (!schema || typeof schema !== "object" || !("~standard" in schema)) {
+      throw new Error(`[Holo Broadcast] Whisper "${normalizedName}" must be a validation schema.`);
+    }
+    return [normalizedName, schema];
+  });
+  return Object.freeze(Object.fromEntries(normalizedEntries));
+}
+function isBroadcastChannelTarget(value) {
+  return isPlainObject(value) && typeof value.pattern === "string" && typeof value.type === "string" && isPlainObject(value.params);
+}
+function isBroadcastDefinition(value) {
+  return isPlainObject(value) && HOLO_BROADCAST_DEFINITION_MARKER in value;
+}
+function isChannelDefinition(value) {
+  return isPlainObject(value) && HOLO_CHANNEL_DEFINITION_MARKER in value;
+}
+function normalizeBroadcastDefinition(definition) {
+  if (!isPlainObject(definition)) {
+    throw new Error("[Holo Broadcast] Broadcast definitions must be plain objects.");
+  }
+  const normalizedInput = definition;
+  const name = normalizeOptionalString(normalizedInput.name, "Broadcast name");
+  const normalized = {
+    ...typeof name === "undefined" ? {} : { name },
+    channels: normalizeChannels(normalizedInput.channels),
+    payload: normalizePayload(normalizedInput.payload),
+    queue: normalizeQueueOptions(normalizedInput.queue),
+    ...typeof normalizedInput.delay === "undefined" ? {} : { delay: normalizeDelayValue(normalizedInput.delay) }
+  };
+  return normalized;
+}
+function defineBroadcast(definition) {
+  const normalized = { ...normalizeBroadcastDefinition(definition) };
+  Object.defineProperty(normalized, HOLO_BROADCAST_DEFINITION_MARKER, {
+    value: true,
+    enumerable: false
+  });
+  return Object.freeze(normalized);
+}
+function normalizeChannelDefinition(pattern, definition) {
+  if (!isPlainObject(definition) || typeof definition.authorize !== "function") {
+    throw new Error("[Holo Broadcast] Channel definitions must define an authorize(...) function.");
+  }
+  if (definition.type !== "private" && definition.type !== "presence") {
+    throw new Error('[Holo Broadcast] Channel definitions must use type "private" or "presence".');
+  }
+  return {
+    pattern: normalizeChannelPattern(pattern, "Channel pattern"),
+    type: definition.type,
+    authorize: definition.authorize,
+    whispers: normalizeWhisperDefinitions(definition.whispers)
+  };
+}
+function defineChannel(pattern, definition) {
+  const normalized = { ...normalizeChannelDefinition(pattern, definition) };
+  Object.defineProperty(normalized, HOLO_CHANNEL_DEFINITION_MARKER, {
+    value: true,
+    enumerable: false
+  });
+  return Object.freeze(normalized);
+}
+function channel(pattern, params) {
+  return createChannelTarget("public", pattern, params);
+}
+function privateChannel(pattern, params) {
+  return createChannelTarget("private", pattern, params);
+}
+function presenceChannel(pattern, params) {
+  return createChannelTarget("presence", pattern, params);
+}
+var broadcastInternals = {
+  extractChannelPatternParamNames,
+  formatChannelPattern,
+  hasBroadcastDefinitionMarker(value) {
+    return isPlainObject(value) && HOLO_BROADCAST_DEFINITION_MARKER in value;
+  },
+  hasChannelDefinitionMarker(value) {
+    return isPlainObject(value) && HOLO_CHANNEL_DEFINITION_MARKER in value;
+  },
+  isBroadcastChannelTarget,
+  isPlainObject,
+  isReadonlyArray,
+  normalizeBroadcastDefinition,
+  normalizeChannelDefinition,
+  normalizeChannelPattern,
+  normalizeDelayValue,
+  normalizeJsonValue,
+  normalizeQueueOptions,
+  normalizeWhisperDefinitions
+};
+
+export {
+  extractChannelPatternParamNames,
+  normalizeChannelPattern,
+  formatChannelPattern,
+  isBroadcastChannelTarget,
+  isBroadcastDefinition,
+  isChannelDefinition,
+  normalizeBroadcastDefinition,
+  defineBroadcast,
+  normalizeChannelDefinition,
+  defineChannel,
+  channel,
+  privateChannel,
+  presenceChannel,
+  broadcastInternals
+};

package/dist/contracts.d.ts

@@ -0,0 +1,287 @@
+import { NormalizedHoloBroadcastConfig } from '@holo-js/config';
+import { ValidationSchema, InferSchemaData } from '@holo-js/validation';
+
+type BroadcastJsonPrimitive = string | number | boolean | null;
+type BroadcastJsonValue = BroadcastJsonPrimitive | readonly BroadcastJsonValue[] | BroadcastJsonObject;
+type BroadcastJsonObject = {
+    readonly [key: string]: BroadcastJsonValue;
+};
+type BroadcastChannelType = 'public' | 'private' | 'presence';
+type BroadcastDelayValue = number | Date;
+type ExtractChannelPatternParamNames<TPattern extends string> = TPattern extends `${string}{${infer TParam}}${infer TRest}` ? TParam | ExtractChannelPatternParamNames<TRest> : never;
+type ChannelPatternParams<TPattern extends string> = [ExtractChannelPatternParamNames<TPattern>] extends [never] ? Record<string, never> : Readonly<Record<ExtractChannelPatternParamNames<TPattern>, string>>;
+interface BroadcastTargetParamInput {
+    readonly [key: string]: string | number | boolean | null | undefined;
+}
+interface BroadcastChannelTarget<TType extends BroadcastChannelType = BroadcastChannelType, TPattern extends string = string, TParams extends Record<string, string> = Record<string, string>> {
+    readonly type: TType;
+    readonly pattern: TPattern;
+    readonly params: Readonly<TParams>;
+}
+interface BroadcastQueueOptions {
+    readonly queued?: boolean;
+    readonly connection?: string;
+    readonly queue?: string;
+    readonly afterCommit?: boolean;
+}
+interface NormalizedBroadcastQueueOptions {
+    readonly queued: boolean;
+    readonly connection?: string;
+    readonly queue?: string;
+    readonly afterCommit: boolean;
+}
+interface BroadcastDefinitionInput<TName extends string = string, TPayload extends BroadcastJsonObject = BroadcastJsonObject, TChannels extends readonly BroadcastChannelTarget[] = readonly BroadcastChannelTarget[]> {
+    readonly name?: TName;
+    readonly channels?: TChannels | (() => TChannels);
+    readonly payload?: TPayload | (() => TPayload);
+    readonly queue?: boolean | BroadcastQueueOptions;
+    readonly delay?: BroadcastDelayValue;
+}
+interface BroadcastDefinition<TName extends string = string, TPayload extends BroadcastJsonObject = BroadcastJsonObject, TChannels extends readonly BroadcastChannelTarget[] = readonly BroadcastChannelTarget[]> {
+    readonly name?: TName;
+    readonly channels: Readonly<TChannels>;
+    readonly payload: Readonly<TPayload>;
+    readonly queue: NormalizedBroadcastQueueOptions;
+    readonly delay?: BroadcastDelayValue;
+}
+type ExportedBroadcastDefinition<TValue> = Extract<TValue, BroadcastDefinition> extends never ? BroadcastDefinition : Extract<TValue, BroadcastDefinition>;
+type BroadcastAuthorizeResult<TType extends BroadcastChannelType, TPresenceMember extends BroadcastJsonObject> = TType extends 'presence' ? false | TPresenceMember : boolean;
+type BroadcastWhisperSchema = ValidationSchema;
+type BroadcastWhisperDefinitions = Readonly<Record<string, BroadcastWhisperSchema>>;
+type InferBroadcastWhisperPayload<TSchema> = TSchema extends {
+    readonly $data?: infer TData;
+} ? TData : never;
+interface ChannelDefinitionInput<TPattern extends string = string, TType extends Extract<BroadcastChannelType, 'private' | 'presence'> = Extract<BroadcastChannelType, 'private' | 'presence'>, TUser = unknown, TPresenceMember extends BroadcastJsonObject = BroadcastJsonObject, TWhispers extends BroadcastWhisperDefinitions = BroadcastWhisperDefinitions> {
+    readonly type: TType;
+    readonly authorize: (user: TUser, params: ChannelPatternParams<TPattern>) => BroadcastAuthorizeResult<TType, TPresenceMember> | Promise<BroadcastAuthorizeResult<TType, TPresenceMember>>;
+    readonly whispers?: TWhispers;
+}
+interface ChannelDefinition<TPattern extends string = string, TType extends Extract<BroadcastChannelType, 'private' | 'presence'> = Extract<BroadcastChannelType, 'private' | 'presence'>, TUser = unknown, TPresenceMember extends BroadcastJsonObject = BroadcastJsonObject, TWhispers extends BroadcastWhisperDefinitions = BroadcastWhisperDefinitions> {
+    readonly pattern: TPattern;
+    readonly type: TType;
+    readonly authorize: ChannelDefinitionInput<TPattern, TType, TUser, TPresenceMember, TWhispers>['authorize'];
+    readonly whispers: Readonly<TWhispers>;
+}
+type ExportedChannelDefinition<TValue> = Extract<TValue, ChannelDefinition> extends never ? ChannelDefinition : Extract<TValue, ChannelDefinition>;
+interface RawBroadcastSendInput<TPayload extends BroadcastJsonObject = BroadcastJsonObject> {
+    readonly connection?: string;
+    readonly event: string;
+    readonly channels: readonly string[];
+    readonly payload: Readonly<TPayload>;
+    readonly socketId?: string;
+}
+interface ResolvedRawBroadcastSendInput<TPayload extends BroadcastJsonObject = BroadcastJsonObject> {
+    readonly connection: string;
+    readonly event: string;
+    readonly channels: readonly string[];
+    readonly payload: Readonly<TPayload>;
+    readonly socketId?: string;
+}
+interface BroadcastSendResult {
+    readonly connection: string;
+    readonly driver: string;
+    readonly queued: boolean;
+    readonly publishedChannels: readonly string[];
+    readonly messageId?: string;
+    readonly provider?: Readonly<Record<string, unknown>>;
+}
+interface BroadcastDispatchOptions {
+    readonly broadcaster?: string;
+    readonly connection?: string;
+    readonly queue?: string;
+    readonly delay?: BroadcastDelayValue;
+    readonly afterCommit?: boolean;
+}
+interface BroadcastSendInput {
+    readonly broadcast: BroadcastDefinition;
+    readonly raw: ResolvedRawBroadcastSendInput;
+    readonly options: Readonly<BroadcastDispatchOptions>;
+}
+interface BroadcastRuntimeBindings {
+    readonly config?: NormalizedHoloBroadcastConfig;
+    publish?(input: ResolvedRawBroadcastSendInput, context: BroadcastDriverExecutionContext): BroadcastSendResult | Promise<BroadcastSendResult>;
+    readonly channelAuth?: BroadcastChannelAuthRuntimeBindings;
+}
+interface BroadcastRuntimeFacade {
+    broadcast(definition: BroadcastDefinition | BroadcastDefinitionInput): PendingBroadcastDispatch<BroadcastSendResult>;
+    broadcastRaw(input: RawBroadcastSendInput): PendingBroadcastDispatch<BroadcastSendResult>;
+}
+interface PendingBroadcastDispatch<TResult = BroadcastSendResult> extends PromiseLike<TResult> {
+    using(name: string): PendingBroadcastDispatch<TResult>;
+    onConnection(name: string): PendingBroadcastDispatch<TResult>;
+    onQueue(name: string): PendingBroadcastDispatch<TResult>;
+    delay(value: BroadcastDelayValue): PendingBroadcastDispatch<TResult>;
+    afterCommit(): PendingBroadcastDispatch<TResult>;
+    then<TResult1 = TResult, TResult2 = never>(onfulfilled?: ((value: TResult) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult1 = never>(onrejected?: ((reason: unknown) => TResult1 | PromiseLike<TResult1>) | null): Promise<TResult | TResult1>;
+    finally(onfinally?: (() => void) | null): Promise<TResult>;
+}
+interface BroadcastDriverExecutionContext {
+    readonly connection: string;
+    readonly driver: string;
+    readonly queued: boolean;
+    readonly delayed: boolean;
+}
+interface BroadcastDriver {
+    send(input: ResolvedRawBroadcastSendInput, context: BroadcastDriverExecutionContext): BroadcastSendResult | Promise<BroadcastSendResult>;
+}
+interface RegisterBroadcastDriverOptions {
+    readonly replace?: boolean;
+}
+interface RegisteredBroadcastDriver {
+    readonly name: string;
+    readonly driver: BroadcastDriver;
+}
+interface BuiltInBroadcastDriverRegistry {
+    readonly holo: BroadcastDriver;
+    readonly pusher: BroadcastDriver;
+    readonly ably: BroadcastDriver;
+    readonly log: BroadcastDriver;
+    readonly null: BroadcastDriver;
+}
+interface HoloBroadcastDriverRegistry {
+}
+interface HoloBroadcastRegistry {
+}
+interface HoloChannelRegistry {
+}
+type BroadcastDriverName = keyof BuiltInBroadcastDriverRegistry | keyof HoloBroadcastDriverRegistry | (string & {});
+interface GeneratedChannelAuthRegistryEntry {
+    readonly sourcePath: string;
+    readonly pattern: string;
+    readonly exportName?: string;
+    readonly type: 'private' | 'presence';
+    readonly params: readonly string[];
+    readonly whispers: readonly string[];
+}
+interface BroadcastChannelAuthRuntimeBindings {
+    readonly definitions?: Readonly<Record<string, ChannelDefinition>> | readonly ChannelDefinition[];
+    readonly registry?: {
+        readonly projectRoot: string;
+        readonly channels: readonly GeneratedChannelAuthRegistryEntry[];
+    };
+    readonly resolveUser?: (connection: {
+        readonly headers: Headers;
+        readonly socketId: string;
+        readonly channel: string;
+        readonly appId: string;
+        readonly connection: string;
+    }) => unknown | Promise<unknown>;
+    readonly importModule?: (absolutePath: string) => Promise<unknown>;
+}
+interface BroadcastChannelAuthRequest {
+    readonly channel: string;
+    readonly socketId?: string;
+    readonly user: unknown;
+}
+interface BroadcastChannelAuthSuccess {
+    readonly ok: true;
+    readonly channel: string;
+    readonly type: 'private' | 'presence';
+    readonly pattern: string;
+    readonly params: Readonly<Record<string, string>>;
+    readonly whispers: readonly string[];
+    readonly member?: Readonly<BroadcastJsonObject>;
+}
+interface BroadcastChannelAuthFailure {
+    readonly ok: false;
+    readonly channel: string;
+    readonly code: 'unauthorized' | 'not-found';
+}
+type BroadcastChannelAuthResult = BroadcastChannelAuthSuccess | BroadcastChannelAuthFailure;
+interface BroadcastAuthEndpointPayload {
+    readonly channel: string;
+    readonly socketId?: string;
+}
+interface BroadcastAuthEndpointSuccessBody {
+    readonly ok: true;
+    readonly channel: string;
+    readonly type: 'private' | 'presence';
+    readonly params: Readonly<Record<string, string>>;
+    readonly whispers: readonly string[];
+    readonly member?: Readonly<BroadcastJsonObject>;
+}
+interface BroadcastAuthEndpointErrorBody {
+    readonly ok: false;
+    readonly error: 'invalid-request' | 'unauthenticated' | 'not-found' | 'unauthorized' | 'method-not-allowed';
+    readonly message: string;
+}
+type BroadcastAuthEndpointBody = BroadcastAuthEndpointSuccessBody | BroadcastAuthEndpointErrorBody;
+interface BroadcastAuthEndpointOptions {
+    readonly user?: unknown;
+    readonly resolveUser?: (request: Request) => unknown | Promise<unknown>;
+    readonly channelAuth?: BroadcastChannelAuthRuntimeBindings;
+}
+interface BroadcastWhisperValidationResult<TPayload extends BroadcastJsonObject = BroadcastJsonObject> {
+    readonly channel: string;
+    readonly event: string;
+    readonly payload: Readonly<TPayload>;
+}
+type KnownBroadcastName = Extract<keyof HoloBroadcastRegistry, string>;
+type KnownChannelPattern = Extract<keyof HoloChannelRegistry, string>;
+type BroadcastPayloadFor<TName extends string> = TName extends KnownBroadcastName ? HoloBroadcastRegistry[TName] extends BroadcastDefinition<string, infer TPayload, readonly BroadcastChannelTarget[]> ? TPayload : BroadcastJsonObject : BroadcastJsonObject;
+type BroadcastChannelsFor<TName extends string> = TName extends KnownBroadcastName ? HoloBroadcastRegistry[TName] extends BroadcastDefinition<string, BroadcastJsonObject, infer TChannels> ? TChannels : readonly BroadcastChannelTarget[] : readonly BroadcastChannelTarget[];
+type ChannelDefinitionFor<TPattern extends string> = TPattern extends KnownChannelPattern ? HoloChannelRegistry[TPattern] extends ChannelDefinition ? HoloChannelRegistry[TPattern] : ChannelDefinition : ChannelDefinition;
+type ChannelPresenceMemberFor<TPattern extends string> = ChannelDefinitionFor<TPattern> extends ChannelDefinition<string, 'presence', unknown, infer TPresenceMember, BroadcastWhisperDefinitions> ? TPresenceMember : never;
+type ChannelWhisperPayloadFor<TPattern extends string, TName extends string> = ChannelDefinitionFor<TPattern> extends ChannelDefinition<string, Extract<BroadcastChannelType, 'private' | 'presence'>, unknown, BroadcastJsonObject, infer TWhispers> ? TName extends keyof TWhispers ? InferBroadcastWhisperPayload<TWhispers[TName]> : never : never;
+interface GeneratedBroadcastManifestEvent {
+    readonly name: string;
+    readonly channels: readonly {
+        readonly type: BroadcastChannelType;
+        readonly pattern: string;
+    }[];
+}
+interface GeneratedBroadcastManifestChannel {
+    readonly name: string;
+    readonly pattern: string;
+    readonly type: Extract<BroadcastChannelType, 'private' | 'presence'>;
+    readonly params: readonly string[];
+    readonly whispers: readonly string[];
+    readonly member?: Readonly<BroadcastJsonObject>;
+}
+interface GeneratedBroadcastManifest {
+    readonly version: 1;
+    readonly generatedAt: string;
+    readonly events: readonly GeneratedBroadcastManifestEvent[];
+    readonly channels: readonly GeneratedBroadcastManifestChannel[];
+}
+declare function isReadonlyArray(value: unknown): value is readonly unknown[];
+declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+declare function normalizeDelayValue(value: BroadcastDelayValue | undefined): BroadcastDelayValue | undefined;
+declare function normalizeJsonValue(value: unknown, path: string): BroadcastJsonValue;
+declare function normalizeQueueOptions(queue: boolean | BroadcastQueueOptions | undefined): NormalizedBroadcastQueueOptions;
+declare function extractChannelPatternParamNames(pattern: string): readonly string[];
+declare function normalizeChannelPattern(pattern: string, label?: string): string;
+declare function formatChannelPattern<TPattern extends string>(pattern: TPattern, params: ChannelPatternParams<TPattern>): string;
+declare function normalizeWhisperDefinitions<TWhispers extends BroadcastWhisperDefinitions | undefined>(whispers: TWhispers): Readonly<TWhispers extends BroadcastWhisperDefinitions ? TWhispers : BroadcastWhisperDefinitions>;
+declare function isBroadcastChannelTarget(value: unknown): value is BroadcastChannelTarget;
+declare function isBroadcastDefinition(value: unknown): value is BroadcastDefinition;
+declare function isChannelDefinition(value: unknown): value is ChannelDefinition;
+declare function normalizeBroadcastDefinition<TName extends string, TPayload extends BroadcastJsonObject, TChannels extends readonly BroadcastChannelTarget[]>(definition: BroadcastDefinitionInput<TName, TPayload, TChannels>): BroadcastDefinition<TName, TPayload, TChannels>;
+declare function defineBroadcast<TName extends string, TPayload extends BroadcastJsonObject, TChannels extends readonly BroadcastChannelTarget[]>(definition: BroadcastDefinitionInput<TName, TPayload, TChannels>): BroadcastDefinition<TName, TPayload, TChannels>;
+declare function normalizeChannelDefinition<TPattern extends string, TType extends Extract<BroadcastChannelType, 'private' | 'presence'>, TUser, TPresenceMember extends BroadcastJsonObject, TWhispers extends BroadcastWhisperDefinitions>(pattern: TPattern, definition: ChannelDefinitionInput<TPattern, TType, TUser, TPresenceMember, TWhispers>): ChannelDefinition<TPattern, TType, TUser, TPresenceMember, TWhispers>;
+declare function defineChannel<TPattern extends string, TType extends Extract<BroadcastChannelType, 'private' | 'presence'>, TUser, TPresenceMember extends BroadcastJsonObject, TWhispers extends BroadcastWhisperDefinitions>(pattern: TPattern, definition: ChannelDefinitionInput<TPattern, TType, TUser, TPresenceMember, TWhispers>): ChannelDefinition<TPattern, TType, TUser, TPresenceMember, TWhispers>;
+declare function channel<TPattern extends string>(pattern: TPattern, params?: BroadcastTargetParamInput): BroadcastChannelTarget<'public', TPattern>;
+declare function privateChannel<TPattern extends string>(pattern: TPattern, params?: BroadcastTargetParamInput): BroadcastChannelTarget<'private', TPattern>;
+declare function presenceChannel<TPattern extends string>(pattern: TPattern, params?: BroadcastTargetParamInput): BroadcastChannelTarget<'presence', TPattern>;
+type InferChannelPresenceMember<TChannel> = TChannel extends ChannelDefinition<string, 'presence', unknown, infer TPresenceMember, BroadcastWhisperDefinitions> ? TPresenceMember : never;
+type InferChannelWhisperPayload<TChannel, TName extends string> = TChannel extends ChannelDefinition<string, Extract<BroadcastChannelType, 'private' | 'presence'>, unknown, BroadcastJsonObject, infer TWhispers> ? TName extends keyof TWhispers ? InferBroadcastWhisperPayload<TWhispers[TName]> : never : never;
+type InferSchemaOutput<TSchema extends ValidationSchema> = InferSchemaData<TSchema['fields']>;
+declare const broadcastInternals: {
+    extractChannelPatternParamNames: typeof extractChannelPatternParamNames;
+    formatChannelPattern: typeof formatChannelPattern;
+    hasBroadcastDefinitionMarker(value: unknown): boolean;
+    hasChannelDefinitionMarker(value: unknown): boolean;
+    isBroadcastChannelTarget: typeof isBroadcastChannelTarget;
+    isPlainObject: typeof isPlainObject;
+    isReadonlyArray: typeof isReadonlyArray;
+    normalizeBroadcastDefinition: typeof normalizeBroadcastDefinition;
+    normalizeChannelDefinition: typeof normalizeChannelDefinition;
+    normalizeChannelPattern: typeof normalizeChannelPattern;
+    normalizeDelayValue: typeof normalizeDelayValue;
+    normalizeJsonValue: typeof normalizeJsonValue;
+    normalizeQueueOptions: typeof normalizeQueueOptions;
+    normalizeWhisperDefinitions: typeof normalizeWhisperDefinitions;
+};
+
+export { type BroadcastAuthEndpointBody, type BroadcastAuthEndpointErrorBody, type BroadcastAuthEndpointOptions, type BroadcastAuthEndpointPayload, type BroadcastAuthEndpointSuccessBody, type BroadcastAuthorizeResult, type BroadcastChannelAuthFailure, type BroadcastChannelAuthRequest, type BroadcastChannelAuthResult, type BroadcastChannelAuthRuntimeBindings, type BroadcastChannelAuthSuccess, type BroadcastChannelTarget, type BroadcastChannelType, type BroadcastChannelsFor, type BroadcastDefinition, type BroadcastDefinitionInput, type BroadcastDelayValue, type BroadcastDispatchOptions, type BroadcastDriver, type BroadcastDriverExecutionContext, type BroadcastDriverName, type BroadcastJsonObject, type BroadcastJsonPrimitive, type BroadcastJsonValue, type BroadcastPayloadFor, type BroadcastQueueOptions, type BroadcastRuntimeBindings, type BroadcastRuntimeFacade, type BroadcastSendInput, type BroadcastSendResult, type BroadcastTargetParamInput, type BroadcastWhisperDefinitions, type BroadcastWhisperSchema, type BroadcastWhisperValidationResult, type BuiltInBroadcastDriverRegistry, type ChannelDefinition, type ChannelDefinitionFor, type ChannelDefinitionInput, type ChannelPatternParams, type ChannelPresenceMemberFor, type ChannelWhisperPayloadFor, type ExportedBroadcastDefinition, type ExportedChannelDefinition, type GeneratedBroadcastManifest, type GeneratedBroadcastManifestChannel, type GeneratedBroadcastManifestEvent, type GeneratedChannelAuthRegistryEntry, type HoloBroadcastDriverRegistry, type HoloBroadcastRegistry, type HoloChannelRegistry, type InferBroadcastWhisperPayload, type InferChannelPresenceMember, type InferChannelWhisperPayload, type InferSchemaOutput, type NormalizedBroadcastQueueOptions, type PendingBroadcastDispatch, type RawBroadcastSendInput, type RegisterBroadcastDriverOptions, type RegisteredBroadcastDriver, type ResolvedRawBroadcastSendInput, broadcastInternals, channel, defineBroadcast, defineChannel, extractChannelPatternParamNames, formatChannelPattern, isBroadcastChannelTarget, isBroadcastDefinition, isChannelDefinition, normalizeBroadcastDefinition, normalizeChannelDefinition, normalizeChannelPattern, presenceChannel, privateChannel };

package/dist/contracts.mjs

@@ -0,0 +1,32 @@
+import {
+  broadcastInternals,
+  channel,
+  defineBroadcast,
+  defineChannel,
+  extractChannelPatternParamNames,
+  formatChannelPattern,
+  isBroadcastChannelTarget,
+  isBroadcastDefinition,
+  isChannelDefinition,
+  normalizeBroadcastDefinition,
+  normalizeChannelDefinition,
+  normalizeChannelPattern,
+  presenceChannel,
+  privateChannel
+} from "./chunk-QW6MHEWS.mjs";
+export {
+  broadcastInternals,
+  channel,
+  defineBroadcast,
+  defineChannel,
+  extractChannelPatternParamNames,
+  formatChannelPattern,
+  isBroadcastChannelTarget,
+  isBroadcastDefinition,
+  isChannelDefinition,
+  normalizeBroadcastDefinition,
+  normalizeChannelDefinition,
+  normalizeChannelPattern,
+  presenceChannel,
+  privateChannel
+};