feat: 기능 추가 과정중

src/adapters/browser-rpc/index.ts

@@ -0,0 +1,17 @@
+export {
+  createBrowserRpcRuntime,
+  type BrowserRpcObservation,
+  type BrowserRpcObservationOutcome,
+  type BrowserRpcObservationSink,
+  type BrowserRpcRuntime,
+  type BrowserRpcRuntimeDependencies,
+} from "./browser-rpc-runtime.ts";
+export {
+  defineBrowserRpcTransport,
+  type BrowserRpcStreamFrame,
+  type BrowserRpcTransport,
+  type BrowserRpcTransportCall,
+  type BrowserRpcTransportFailure,
+  type BrowserRpcUnaryTransportResult,
+} from "./transport.ts";
+export { createUnavailableBrowserRpcTransport } from "./unavailable-browser-rpc-transport.ts";

src/adapters/browser-rpc/transport.ts

@@ -0,0 +1,89 @@
+import type {
+  BrowserRpcKind,
+  BrowserRpcOperationV3,
+  BrowserRpcProtocol,
+  BrowserRpcProviderProfile,
+  BrowserRpcRuntimeBindingIdentity,
+  BrowserRpcTransportFailureCode,
+} from "../../contracts/browser-rpc.ts";
+
+export type BrowserRpcTransportFailure = Readonly<{
+  code: BrowserRpcTransportFailureCode;
+  retryAfterMs?: number;
+}>;
+
+export type BrowserRpcTransportCall = Readonly<{
+  operation: BrowserRpcOperationV3;
+  profile: BrowserRpcProviderProfile;
+  request: unknown;
+  encodedRequestBytes: number;
+  attempt: number;
+  timeoutMs: number;
+  signal: AbortSignal;
+  idempotencyKey?: string;
+}>;
+
+export type BrowserRpcUnaryTransportResult =
+  | Readonly<{
+      ok: true;
+      message: unknown;
+      encodedBytes: number;
+    }>
+  | Readonly<{
+      ok: false;
+      failure: BrowserRpcTransportFailure;
+    }>;
+
+export type BrowserRpcStreamFrame =
+  | Readonly<{
+      kind: "MESSAGE";
+      message: unknown;
+      encodedBytes: number;
+    }>
+  | Readonly<{
+      kind: "TERMINAL";
+      ok: true;
+    }>
+  | Readonly<{
+      kind: "TERMINAL";
+      ok: false;
+      failure: BrowserRpcTransportFailure;
+    }>;
+
+export type BrowserRpcTransport = BrowserRpcRuntimeBindingIdentity &
+  Readonly<{
+    invokeUnary?(
+      call: BrowserRpcTransportCall,
+    ): Promise<BrowserRpcUnaryTransportResult>;
+    openServerStream?(
+      call: BrowserRpcTransportCall,
+    ): AsyncIterable<BrowserRpcStreamFrame>;
+  }>;
+
+export function defineBrowserRpcTransport(
+  transport: BrowserRpcTransport,
+): BrowserRpcTransport {
+  if (
+    !transport.runtimeProfileId ||
+    !transport.providerId ||
+    !isProtocol(transport.protocol) ||
+    !isRpcKind(transport.rpcKind) ||
+    (transport.rpcKind === "UNARY" &&
+      (typeof transport.invokeUnary !== "function" ||
+        transport.openServerStream !== undefined)) ||
+    (transport.rpcKind === "SERVER_STREAM" &&
+      (typeof transport.openServerStream !== "function" ||
+        transport.invokeUnary !== undefined))
+  ) {
+    throw new TypeError("Browser RPC transport is invalid.");
+  }
+  return Object.freeze({ ...transport });
+}
+
+function isProtocol(value: string): value is BrowserRpcProtocol {
+  return value === "CONNECT_HTTP" || value === "GRPC_WEB";
+}
+
+function isRpcKind(value: string): value is BrowserRpcKind {
+  return value === "UNARY" || value === "SERVER_STREAM";
+}

src/adapters/browser-rpc/unavailable-browser-rpc-transport.ts

@@ -0,0 +1,42 @@
+import type {
+  BrowserRpcKind,
+  BrowserRpcProtocol,
+} from "../../contracts/browser-rpc.ts";
+import {
+  defineBrowserRpcTransport,
+  type BrowserRpcTransport,
+} from "./transport.ts";
+
+/**
+ * Explicit fail-closed adapter for an optional Browser RPC profile that has
+ * not been connected to a generated client/provider. It never performs
+ * network I/O and cannot silently fall back to REST.
+ */
+export function createUnavailableBrowserRpcTransport(input: Readonly<{
+  runtimeProfileId: string;
+  providerId: string;
+  protocol: BrowserRpcProtocol;
+  rpcKind: BrowserRpcKind;
+}>): BrowserRpcTransport {
+  if (input.rpcKind === "UNARY") {
+    return defineBrowserRpcTransport({
+      ...input,
+      async invokeUnary() {
+        return Object.freeze({
+          ok: false,
+          failure: Object.freeze({ code: "UNAVAILABLE" }),
+        });
+      },
+    });
+  }
+  return defineBrowserRpcTransport({
+    ...input,
+    async *openServerStream() {
+      yield Object.freeze({
+        kind: "TERMINAL",
+        ok: false,
+        failure: Object.freeze({ code: "UNAVAILABLE" }),
+      });
+    },
+  });
+}