spectrum-ts 0.0.1 → 0.1.1

package/dist/types-DiKuSemh.d.ts

@@ -0,0 +1,261 @@
+import { Pipe, Tuples, Fn } from 'hotscript';
+import z__default from 'zod';
+import { NonEmptyString } from 'type-fest';
+
+declare const contentSchema: z__default.ZodDiscriminatedUnion<[z__default.ZodObject<{
+    type: z__default.ZodLiteral<"plain_text">;
+    text: z__default.ZodString;
+}, z__default.core.$strip>, z__default.ZodObject<{
+    type: z__default.ZodLiteral<"custom">;
+    raw: z__default.ZodJSONSchema;
+}, z__default.core.$strip>, z__default.ZodObject<{
+    type: z__default.ZodLiteral<"attachment">;
+    data: z__default.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
+    mimeType: z__default.ZodString;
+    name: z__default.ZodString;
+}, z__default.core.$strip>], "type">;
+type Content = z__default.infer<typeof contentSchema>;
+interface ContentBuilder {
+    build(): Promise<Content>;
+}
+declare function text<T extends string>(text: NonEmptyString<T>): ContentBuilder;
+declare function custom(raw: z__default.infer<ReturnType<typeof z__default.json>>): ContentBuilder;
+declare function attachment(input: string | Buffer, options?: {
+    mimeType?: string;
+    name?: string;
+}): ContentBuilder;
+
+interface Space<_Def = unknown> {
+    readonly __platform: string;
+    readonly id: string;
+    responding<T>(fn: () => T | Promise<T>): Promise<T>;
+    send(...content: [ContentBuilder, ...ContentBuilder[]]): Promise<void>;
+    startTyping(): Promise<void>;
+    stopTyping(): Promise<void>;
+}
+
+interface User {
+    readonly __platform: string;
+    readonly id: string;
+}
+
+interface Message<TPlatform extends string = string, TSender extends User = User, TSpace extends Space = Space> {
+    content: Content[];
+    readonly id: string;
+    platform: TPlatform;
+    react(reaction: string): Promise<void>;
+    reply(...content: [ContentBuilder, ...ContentBuilder[]]): Promise<void>;
+    sender: TSender;
+    space: TSpace;
+    timestamp: Date;
+}
+
+type ResolvedSpace = Pick<Space, "id">;
+type SpaceRef = Pick<Space, "id" | "__platform">;
+type ResolvedUser = Pick<User, "id">;
+type AwaitedReturn<T> = T extends (...args: never[]) => Promise<infer R> ? R : never;
+type SchemaInfer<T> = T extends {
+    schema?: infer S extends z__default.ZodType<object>;
+} ? z__default.infer<S> : Record<never, never>;
+type InferSchema<TSchema> = TSchema extends z__default.ZodType<object> ? z__default.infer<TSchema> : Record<never, never>;
+type InferOptionalSchema<TSchema> = TSchema extends z__default.ZodType<object> ? z__default.infer<TSchema> : never;
+type InputSchema<TSchema> = TSchema extends z__default.ZodType<object> ? z__default.input<TSchema> : never;
+type EventProducer<TPayload = unknown, TClient = unknown, TConfig = unknown> = (ctx: {
+    client: TClient;
+    config: TConfig;
+}) => AsyncIterable<TPayload>;
+type ProviderMessage<TSender extends ResolvedUser = ResolvedUser, TSpace extends ResolvedSpace = ResolvedSpace, TExtra extends object = Record<never, never>> = {
+    id: string;
+    content: Content[];
+    sender: TSender;
+    space: TSpace;
+    timestamp?: Date;
+} & TExtra;
+type MergeSchema<TSchema extends z__default.ZodType | undefined, TBase extends object> = TSchema extends z__default.ZodType ? string extends keyof z__default.infer<TSchema> ? TBase : Omit<z__default.infer<TSchema>, keyof TBase> & TBase : TBase;
+type SchemaMessage<TUserSchema extends z__default.ZodType | undefined = undefined, TSpaceSchema extends z__default.ZodType | undefined = undefined> = ProviderMessage<MergeSchema<TUserSchema, ResolvedUser>, MergeSchema<TSpaceSchema, ResolvedSpace>>;
+type InferEventPayload<T> = T extends (ctx: never) => AsyncIterable<infer P> ? P : never;
+type ReservedNames = "stop" | "send" | "__internal" | "__providers";
+interface PlatformDef<_Name extends string = string, _ConfigSchema extends z__default.ZodType<object> = z__default.ZodType<object>, _UserSchema extends z__default.ZodType<object> | undefined = undefined, _SpaceSchema extends z__default.ZodType<object> | undefined = undefined, _SpaceParamsSchema extends z__default.ZodType<object> | undefined = undefined, _Client = unknown, _ResolvedUser extends ResolvedUser = ResolvedUser, _ResolvedSpace extends ResolvedSpace = ResolvedSpace, _MessageSchema extends z__default.ZodType<object> | undefined = undefined, _MessageType extends ProviderMessage<_ResolvedUser, _ResolvedSpace, InferSchema<_MessageSchema>> = ProviderMessage<_ResolvedUser, _ResolvedSpace, InferSchema<_MessageSchema>>, _Events extends {
+    messages: EventProducer<_MessageType, _Client, z__default.infer<_ConfigSchema>>;
+} = {
+    messages: EventProducer<_MessageType, _Client, z__default.infer<_ConfigSchema>>;
+}> {
+    actions: {
+        send: (_: {
+            space: _ResolvedSpace & SpaceRef;
+            content: Content[];
+            client: _Client;
+            config: z__default.infer<_ConfigSchema>;
+        }) => Promise<void>;
+        startTyping?: (_: {
+            space: _ResolvedSpace & SpaceRef;
+            client: _Client;
+            config: z__default.infer<_ConfigSchema>;
+        }) => Promise<void>;
+        stopTyping?: (_: {
+            space: _ResolvedSpace & SpaceRef;
+            client: _Client;
+            config: z__default.infer<_ConfigSchema>;
+        }) => Promise<void>;
+        reactToMessage?: (_: {
+            space: _ResolvedSpace & SpaceRef;
+            messageId: string;
+            reaction: string;
+            client: _Client;
+            config: z__default.infer<_ConfigSchema>;
+        }) => Promise<void>;
+        replyToMessage?: (_: {
+            space: _ResolvedSpace & SpaceRef;
+            messageId: string;
+            content: Content[];
+            client: _Client;
+            config: z__default.infer<_ConfigSchema>;
+        }) => Promise<void>;
+    };
+    config: _ConfigSchema;
+    events: _Events;
+    lifecycle: {
+        createClient: (ctx: {
+            config: z__default.infer<_ConfigSchema>;
+            projectId: string;
+            projectSecret: string;
+        }) => Promise<_Client>;
+        destroyClient: (ctx: {
+            client: _Client;
+        }) => Promise<void>;
+    };
+    message?: {
+        schema?: _MessageSchema;
+    };
+    name: _Name;
+    space: {
+        schema?: _SpaceSchema;
+        params?: _SpaceParamsSchema;
+        resolve: (_: {
+            input: {
+                users: (_ResolvedUser & {
+                    __platform: _Name;
+                })[];
+                params?: _SpaceParamsSchema extends z__default.ZodType<object> ? z__default.infer<_SpaceParamsSchema> : undefined;
+            };
+            client: _Client;
+            config: z__default.infer<_ConfigSchema>;
+        }) => Promise<_ResolvedSpace>;
+    };
+    user: {
+        schema?: _UserSchema;
+        resolve: (_: {
+            input: {
+                userID: string;
+            };
+            client: _Client;
+            config: z__default.infer<_ConfigSchema>;
+        }) => Promise<_ResolvedUser>;
+    };
+}
+interface AnyPlatformDef {
+    actions: {
+        send: (_: any) => Promise<void>;
+        startTyping?: (_: any) => Promise<void>;
+        stopTyping?: (_: any) => Promise<void>;
+        reactToMessage?: (_: any) => Promise<void>;
+        replyToMessage?: (_: any) => Promise<void>;
+    };
+    config: z__default.ZodType<object>;
+    events: {
+        messages: (ctx: any) => AsyncIterable<any>;
+        [key: string]: (ctx: any) => AsyncIterable<any>;
+    };
+    lifecycle: {
+        createClient: (ctx: any) => Promise<any>;
+        destroyClient: (ctx: any) => Promise<void>;
+    };
+    message?: {
+        schema?: z__default.ZodType<object>;
+    };
+    name: string;
+    space: {
+        schema?: z__default.ZodType<object>;
+        params?: z__default.ZodType<object>;
+        resolve: (_: any) => Promise<any>;
+    };
+    user: {
+        schema?: z__default.ZodType<object>;
+        resolve: (_: any) => Promise<any>;
+    };
+}
+interface PlatformProviderConfig<Def extends AnyPlatformDef = AnyPlatformDef> {
+    readonly __def: Def;
+    readonly __definition: AnyPlatformDef;
+    readonly __name: Def["name"];
+    readonly __tag: "PlatformProviderConfig";
+    readonly config: unknown;
+}
+interface MatchesPlatformName<Name extends string> extends Fn {
+    return: this["arg0"] extends PlatformProviderConfig<infer Def> ? Def["name"] extends Name ? true : false : false;
+}
+interface ExtractDef extends Fn {
+    return: this["arg0"] extends PlatformProviderConfig<infer Def> ? Def : never;
+}
+interface ExtractCustomEventNames extends Fn {
+    return: this["arg0"] extends AnyPlatformDef ? Exclude<keyof this["arg0"]["events"], "messages" | symbol | number> : never;
+}
+interface ToCustomEventVariant<EventName extends string> extends Fn {
+    return: this["arg0"] extends PlatformProviderConfig<infer Def> ? EventName extends keyof Def["events"] ? InferEventPayload<Def["events"][EventName]> & {
+        platform: Def["name"];
+    } : never : never;
+}
+type HasProvider<Providers extends PlatformProviderConfig[], Name extends string> = Pipe<Providers, [Tuples.Some<MatchesPlatformName<Name>>]>;
+type AllCustomEventNames<Providers extends PlatformProviderConfig[]> = Pipe<Providers, [
+    Tuples.Map<ExtractDef>,
+    Tuples.Map<ExtractCustomEventNames>,
+    Tuples.ToUnion
+]>;
+type UnifiedCustomEvent<Providers extends PlatformProviderConfig[], EventName extends string> = Pipe<Providers, [
+    Tuples.Map<ToCustomEventVariant<EventName>>,
+    Tuples.ToUnion
+]>;
+type CustomEventStreams<Providers extends PlatformProviderConfig[]> = {
+    [K in Exclude<AllCustomEventNames<Providers>, ReservedNames> & string]: AsyncIterable<UnifiedCustomEvent<Providers, K>>;
+};
+type ResolvedSpaceOf<Def extends AnyPlatformDef> = AwaitedReturn<Def["space"]["resolve"]>;
+type SchemaSpaceOf<Def extends AnyPlatformDef> = InferOptionalSchema<Def["space"]["schema"]>;
+type ResolvedUserOf<Def extends AnyPlatformDef> = AwaitedReturn<Def["user"]["resolve"]>;
+type SpaceShapeOf<Def extends AnyPlatformDef> = [SchemaSpaceOf<Def>] extends [
+    never
+] ? ResolvedSpaceOf<Def> : SchemaSpaceOf<Def>;
+type SpaceParamsInputOf<Def extends AnyPlatformDef> = InputSchema<Def["space"]["params"]>;
+type SpaceArrayArgs<Def extends AnyPlatformDef> = [
+    SpaceParamsInputOf<Def>
+] extends [never] ? [users: PlatformUser<Def>[]] : [users: PlatformUser<Def>[]] | [users: PlatformUser<Def>[], params: SpaceParamsInputOf<Def>] | [params: SpaceParamsInputOf<Def>];
+type SpaceVarargArgs<Def extends AnyPlatformDef> = [
+    SpaceParamsInputOf<Def>
+] extends [never] ? PlatformUser<Def>[] : PlatformUser<Def>[] | [...PlatformUser<Def>[], SpaceParamsInputOf<Def>];
+type SpaceArgs<Def extends AnyPlatformDef> = SpaceArrayArgs<Def> | SpaceVarargArgs<Def>;
+type PlatformSpace<Def extends AnyPlatformDef> = Omit<SpaceShapeOf<Def>, keyof Space> & Space;
+type PlatformMessage<Def extends AnyPlatformDef> = Omit<SchemaInfer<Def["message"]>, keyof Message> & Message<Def["name"], PlatformUser<Def>, PlatformSpace<Def>>;
+type PlatformUser<Def extends AnyPlatformDef> = Omit<ResolvedUserOf<Def>, keyof User> & User;
+type PlatformInstance<Def extends AnyPlatformDef> = {
+    space(...args: SpaceArgs<Def>): Promise<PlatformSpace<Def>>;
+    user(userID: string): Promise<PlatformUser<Def>>;
+} & {
+    [K in Exclude<keyof Def["events"], "messages" | symbol | number> as K extends ReservedNames ? never : K]: AsyncIterable<InferEventPayload<Def["events"][K]>>;
+};
+interface SpectrumLike<Providers extends PlatformProviderConfig[] = PlatformProviderConfig[]> {
+    readonly __internal: {
+        platforms: Map<string, {
+            client: unknown;
+            config: unknown;
+            definition: AnyPlatformDef;
+        }>;
+    };
+    readonly __providers: Providers;
+}
+interface Platform<Def extends AnyPlatformDef> {
+    config(config?: z__default.input<Def["config"]>): PlatformProviderConfig<Def>;
+    <Providers extends PlatformProviderConfig[]>(spectrum: SpectrumLike<Providers>): HasProvider<Providers, Def["name"]> extends true ? PlatformInstance<Def> : never;
+    (space: Space): PlatformSpace<Def>;
+    (message: Message): PlatformMessage<Def>;
+}
+
+export { type AnyPlatformDef as A, type CustomEventStreams as C, type EventProducer as E, type Message as M, type ProviderMessage as P, type SpectrumLike as S, type User as U, type PlatformDef as a, type Platform as b, type PlatformProviderConfig as c, type Space as d, type ContentBuilder as e, type Content as f, type PlatformInstance as g, type PlatformMessage as h, type PlatformSpace as i, type PlatformUser as j, type SchemaMessage as k, attachment as l, custom as m, text as t };

package/package.json

@@ -1,7 +1,52 @@
 {
   "name": "spectrum-ts",
-  "version": "0.0.1",
-  "description": "Spectrum for TypeScript",
-  "main": "index.js",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./providers/imessage": {
+      "types": "./dist/providers/imessage/index.d.ts",
+      "bun": "./src/providers/imessage/index.ts",
+      "default": "./dist/providers/imessage/index.js"
+    },
+    "./providers/terminal": {
+      "types": "./dist/providers/terminal/index.d.ts",
+      "bun": "./src/providers/terminal/index.ts",
+      "default": "./dist/providers/terminal/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "dependencies": {
+    "@photon-ai/advanced-imessage": "^0.1.0",
+    "@photon-ai/imessage-kit": "^2.1.2",
+    "@repeaterjs/repeater": "^3.0.6",
+    "better-grpc": "^0.3.2",
+    "mime-types": "^3.0.1",
+    "type-fest": "^5.4.1",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/mime-types": "^3.0.1",
+    "hotscript": "^1.0.13",
+    "tsup": "^8.4.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
   "license": "MIT"
 }

package/src/index.ts

@@ -0,0 +1,26 @@
+// biome-ignore lint/performance/noBarrelFile: library entry point
+export { definePlatform } from "./platform/define";
+export type {
+  AnyPlatformDef,
+  EventProducer,
+  Platform,
+  PlatformDef,
+  PlatformInstance,
+  PlatformMessage,
+  PlatformProviderConfig,
+  PlatformSpace,
+  PlatformUser,
+  SchemaMessage,
+} from "./platform/types";
+export { Spectrum, type SpectrumInstance } from "./spectrum";
+export {
+  attachment,
+  type Content,
+  type ContentBuilder,
+  custom,
+  text,
+} from "./types/content";
+export type { Message } from "./types/message";
+export type { Space } from "./types/space";
+export type { User } from "./types/user";
+export { type ManagedStream, mergeStreams, stream } from "./utils/stream";

package/src/platform/define.ts

@@ -0,0 +1,309 @@
+import type z from "zod";
+import type { ContentBuilder } from "../types/content";
+import type { Message } from "../types/message";
+import type { Space } from "../types/space";
+import type {
+  AnyPlatformDef,
+  Platform,
+  PlatformDef,
+  PlatformInstance,
+  PlatformMessage,
+  PlatformProviderConfig,
+  PlatformSpace,
+  PlatformUser,
+  ProviderMessage,
+  SpectrumLike,
+} from "./types";
+
+function createPlatformInstance<
+  Def extends AnyPlatformDef,
+  _Client,
+  _ConfigSchema extends z.ZodType<object>,
+>(
+  def: Def,
+  runtime: { client: unknown; config: unknown }
+): PlatformInstance<Def> {
+  const isPlatformUser = (value: unknown): value is PlatformUser<Def> => {
+    return (
+      typeof value === "object" &&
+      value !== null &&
+      "__platform" in value &&
+      (value as { __platform?: unknown }).__platform === def.name
+    );
+  };
+
+  const normalizeSpaceArgs = (
+    args: unknown[]
+  ): { users: PlatformUser<Def>[]; params: unknown } => {
+    if (args.length === 0) {
+      return { users: [], params: undefined };
+    }
+
+    const [first, ...rest] = args;
+    if (Array.isArray(first)) {
+      return {
+        users: first as PlatformUser<Def>[],
+        params: rest[0],
+      };
+    }
+
+    if (!isPlatformUser(first)) {
+      return {
+        users: [],
+        params: first,
+      };
+    }
+
+    const last = args.at(-1);
+    if (last !== undefined && !isPlatformUser(last)) {
+      return {
+        users: args.slice(0, -1) as PlatformUser<Def>[],
+        params: last,
+      };
+    }
+
+    return {
+      users: args as PlatformUser<Def>[],
+      params: undefined,
+    };
+  };
+
+  const base = {
+    async user(userID: string) {
+      const resolved = await def.user.resolve({
+        input: { userID },
+        client: runtime.client as _Client,
+        config: runtime.config as z.infer<_ConfigSchema>,
+      });
+      return {
+        ...resolved,
+        __platform: def.name,
+      } as PlatformUser<Def>;
+    },
+
+    async space(...args: unknown[]) {
+      const { users, params } = normalizeSpaceArgs(args);
+      let parsedParams = params;
+      if (params !== undefined && def.space.params) {
+        parsedParams = def.space.params.parse(params);
+      }
+      const resolved = await def.space.resolve({
+        input: { users, params: parsedParams },
+        client: runtime.client as _Client,
+        config: runtime.config as z.infer<_ConfigSchema>,
+      });
+      const parsedSpace = def.space.schema
+        ? def.space.schema.parse(resolved)
+        : resolved;
+      const spaceRef = {
+        id: parsedSpace.id,
+        __platform: def.name,
+      };
+      const typingCtx = {
+        space: spaceRef,
+        client: runtime.client as _Client,
+        config: runtime.config as z.infer<_ConfigSchema>,
+      };
+      return {
+        ...parsedSpace,
+        ...spaceRef,
+        send: async (...content: [ContentBuilder, ...ContentBuilder[]]) => {
+          const built = await Promise.all(content.map((c) => c.build()));
+          await def.actions.send({
+            ...typingCtx,
+            content: built,
+          });
+        },
+        startTyping: async () => {
+          await def.actions.startTyping?.(typingCtx);
+        },
+        stopTyping: async () => {
+          await def.actions.stopTyping?.(typingCtx);
+        },
+        responding: async <T>(fn: () => T | Promise<T>): Promise<T> => {
+          await def.actions.startTyping?.(typingCtx);
+          try {
+            return await fn();
+          } finally {
+            await def.actions.stopTyping?.(typingCtx).catch(() => {});
+          }
+        },
+      } as PlatformSpace<Def>;
+    },
+  };
+
+  // Add flat event properties for custom events (non-messages)
+  const eventProperties: Record<string, AsyncIterable<unknown>> = {};
+  for (const eventName of Object.keys(def.events)) {
+    if (eventName === "messages") {
+      continue;
+    }
+    const producer = def.events[eventName] as
+      | ((ctx: { client: unknown; config: unknown }) => AsyncIterable<unknown>)
+      | undefined;
+    if (producer) {
+      eventProperties[eventName] = producer({
+        client: runtime.client,
+        config: runtime.config,
+      });
+    }
+  }
+
+  return Object.assign(base, eventProperties) as PlatformInstance<Def>;
+}
+
+export function definePlatform<
+  _Name extends string,
+  _ConfigSchema extends z.ZodType<object>,
+  _UserSchema extends z.ZodType<object> | undefined,
+  _SpaceSchema extends z.ZodType<object> | undefined,
+  _SpaceParamsSchema extends z.ZodType<object> | undefined,
+  _Client,
+  _ResolvedUser extends { id: string },
+  _ResolvedSpace extends { id: string },
+  _MessageSchema extends z.ZodType<object> | undefined = undefined,
+  _MessageType extends ProviderMessage<
+    _ResolvedUser,
+    _ResolvedSpace,
+    _MessageSchema extends z.ZodType<object>
+      ? z.infer<_MessageSchema>
+      : Record<never, never>
+  > = ProviderMessage<
+    _ResolvedUser,
+    _ResolvedSpace,
+    _MessageSchema extends z.ZodType<object>
+      ? z.infer<_MessageSchema>
+      : Record<never, never>
+  >,
+  _Events extends {
+    messages: (ctx: {
+      client: _Client;
+      config: z.infer<_ConfigSchema>;
+    }) => AsyncIterable<_MessageType>;
+  } = {
+    messages: (ctx: {
+      client: _Client;
+      config: z.infer<_ConfigSchema>;
+    }) => AsyncIterable<_MessageType>;
+  },
+  _Static extends Record<string, unknown> = Record<never, never>,
+>(
+  name: _Name,
+  def: Omit<
+    PlatformDef<
+      _Name,
+      _ConfigSchema,
+      _UserSchema,
+      _SpaceSchema,
+      _SpaceParamsSchema,
+      _Client,
+      _ResolvedUser,
+      _ResolvedSpace,
+      _MessageSchema,
+      _MessageType,
+      _Events
+    >,
+    "name"
+  > & { static?: _Static }
+): Platform<
+  PlatformDef<
+    _Name,
+    _ConfigSchema,
+    _UserSchema,
+    _SpaceSchema,
+    _SpaceParamsSchema,
+    _Client,
+    _ResolvedUser,
+    _ResolvedSpace,
+    _MessageSchema,
+    _MessageType,
+    _Events
+  >
+> &
+  Readonly<_Static> {
+  type Def = PlatformDef<
+    _Name,
+    _ConfigSchema,
+    _UserSchema,
+    _SpaceSchema,
+    _SpaceParamsSchema,
+    _Client,
+    _ResolvedUser,
+    _ResolvedSpace,
+    _MessageSchema,
+    _MessageType,
+    _Events
+  >;
+
+  const fullDef = { name, ...def };
+
+  const platformCache = new WeakMap<SpectrumLike, PlatformInstance<Def>>();
+
+  const narrowSpectrum = (spectrum: SpectrumLike) => {
+    const cached = platformCache.get(spectrum);
+    if (cached) {
+      return cached;
+    }
+
+    const runtime = spectrum.__internal.platforms.get(name);
+    if (!runtime) {
+      throw new Error(`Platform "${name}" is not registered`);
+    }
+
+    const instance = createPlatformInstance<Def, _Client, _ConfigSchema>(
+      fullDef as Def & AnyPlatformDef,
+      runtime
+    );
+    platformCache.set(spectrum, instance);
+    return instance;
+  };
+
+  const narrowSpace = (input: Space) => {
+    if (input.__platform !== name) {
+      throw new Error(
+        `Expected space from "${name}", got "${input.__platform}"`
+      );
+    }
+    return input as PlatformSpace<Def>;
+  };
+
+  const narrowMessage = (input: Message) => {
+    if (input.platform !== name) {
+      throw new Error(
+        `Expected message from "${name}", got "${input.platform}"`
+      );
+    }
+    return input as PlatformMessage<Def>;
+  };
+
+  const narrower = ((input: SpectrumLike | Space | Message) => {
+    if ("__providers" in input && "__internal" in input) {
+      return narrowSpectrum(input as SpectrumLike);
+    }
+    if ("__platform" in input && "send" in input) {
+      return narrowSpace(input as Space);
+    }
+    if ("platform" in input && "sender" in input && "space" in input) {
+      return narrowMessage(input as Message);
+    }
+    throw new Error("Invalid input to platform narrowing function");
+  }) as Platform<Def>;
+
+  narrower.config = (
+    config: z.input<_ConfigSchema> = {} as z.input<_ConfigSchema>
+  ) => {
+    return {
+      __tag: "PlatformProviderConfig" as const,
+      __def: undefined as unknown as Def,
+      __name: name,
+      config,
+      __definition: fullDef as AnyPlatformDef,
+    } satisfies PlatformProviderConfig<Def> as PlatformProviderConfig<Def>;
+  };
+
+  if (def.static) {
+    Object.assign(narrower, def.static);
+  }
+
+  return narrower as Platform<Def> & Readonly<_Static>;
+}