@takosjp/yurucommu-core 4.0.0 → 4.1.1

package/README.en.md

@@ -87,6 +87,9 @@ Takos core. See [`AGENTS.md`](AGENTS.md) for the full product boundary.
 
 ## Documentation
 
+- [Runtime lanes](docs/design/runtime-lanes.md) — how the bindings differ between
+  a raw-Cloudflare deployment and one on a host that projects the portable
+  facades, and how a deployment declares which it is
 - [Deployment guide](https://yurucommu.com/help/deployment.html)
 - [Getting started](https://yurucommu.com/help/getting-started.html)
 - [Help site](https://yurucommu.com/help/)

package/README.md

@@ -86,6 +86,8 @@ Yurucommu は ActivityPub 連合・コンテンツ配送・ユーザー identity
 
 ## ドキュメント
 
+- [Runtime lanes](docs/design/runtime-lanes.md) — raw Cloudflare binding と
+  portable facade で binding の形が変わる点と、その宣言方法
 - [Deployment guide](https://yurucommu.com/help/deployment.html)
 - [Getting started](https://yurucommu.com/help/getting-started.html)
 - [Help site](https://yurucommu.com/help/)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takosjp/yurucommu-core",
-  "version": "4.0.0",
+  "version": "4.1.1",
   "license": "AGPL-3.0-only",
   "type": "module",
   "workspaces": [
@@ -59,8 +59,9 @@
     "start": "bun src/backend/server.ts",
     "dev": "bun src/backend/server.ts",
     "dev:server": "bun src/backend/server.ts",
-    "check": "bun run fmt:check && tsc --noEmit && bun run check:no-opentofu-artifacts && bun run test",
+    "check": "bun run fmt:check && tsc --noEmit && bun run check:no-opentofu-artifacts && bun run check:worker-bundle && bun run test",
     "check:no-opentofu-artifacts": "bun scripts/check-no-opentofu-artifacts.mjs",
+    "check:worker-bundle": "bun scripts/check-worker-bundle-portable.mjs",
     "test": "bun run build:api && bun test test/ src/backend/ packages/api/src/ scripts/check-publish-version-discipline.test.ts scripts/publish-package-resumable.test.ts && bun run check:release-contents",
     "test:backend": "bun test src/backend/",
     "build": "bun run build:api",

package/packages/api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takosjp/yurucommu-api",
-  "version": "4.0.0",
+  "version": "4.1.1",
   "description": "Typed client SDK and public API contract for yurucommu-server clients.",
   "license": "AGPL-3.0-only",
   "type": "module",

package/src/backend/index.ts

@@ -5,9 +5,12 @@ import type { Env, EnvVars, Variables } from "./types.ts";
 import { extractActorFromSession } from "./lib/session-actor.ts";
 import { isBackendPath } from "./lib/backend-paths.ts";
 import {
-  wrapCloudflareBindings,
-  wrapCloudflareMessageBatch,
-} from "./runtime/cloudflare.ts";
+  resolveRuntimeLane,
+  wrapRuntimeBindings,
+  wrapRuntimeMessageBatch,
+  type PortableWorkerBindings,
+} from "./runtime/lane.ts";
+import type { EdgeQueueBatch } from "./runtime/edge-facades.ts";
 import {
   getMobileOidcAudience,
   getOidcClientCredentials,
@@ -992,15 +995,17 @@ export async function handleYurucommuQueueBatch(
   batch.ackAll();
 }
 
-type WorkerBindings = EnvVars & {
-  DB: D1Database;
-  MEDIA?: R2Bucket;
-  KV: KVNamespace;
+/**
+ * Bindings that are not the runtime ports, and so pass through whichever lane
+ * wrapper runs. Durable Objects live here: Takoform's Worker Version form has
+ * no Durable Object binding, so on the portable lane both are simply unbound
+ * and the routes that need them answer 503, exactly as on a Cloudflare
+ * deployment that did not declare them.
+ */
+type PassthroughBindings = EnvVars & {
   ASSETS?: Fetcher;
-  DELIVERY_QUEUE?: Queue<DeliveryQueueMessageV1>;
-  DELIVERY_DLQ?: Queue<DeliveryDlqMessageV1>;
-  // Signaling hub Durable Object namespace (call feature). wrapCloudflareBindings
-  // spreads it through untouched (it is not DB/MEDIA/KV/ASSETS) so app code and
+  // Signaling hub Durable Object namespace (call feature). The lane wrappers
+  // spread it through untouched (it is not DB/MEDIA/KV/ASSETS) so app code and
   // the rtc routes read it as c.env.CALL_SIGNALING.
   CALL_SIGNALING?: DurableObjectNamespace;
   // Per-user realtime event stream Durable Object namespace. Same pass-through
@@ -1009,6 +1014,26 @@ type WorkerBindings = EnvVars & {
   REALTIME_STREAM?: DurableObjectNamespace;
 };
 
+/**
+ * What this Worker may be handed.
+ *
+ * Raw Cloudflare bindings, or the portable facades a wrapper host projects.
+ * `wrapRuntimeBindings` decides which by reading the deployment's declared
+ * `YURUCOMMU_RUNTIME_LANE` and proving it against the bindings that actually
+ * arrived; see runtime/lane.ts.
+ */
+type WorkerBindings = PassthroughBindings &
+  (
+    | {
+        DB: D1Database;
+        MEDIA?: R2Bucket;
+        KV: KVNamespace;
+        DELIVERY_QUEUE?: Queue<DeliveryQueueMessageV1>;
+        DELIVERY_DLQ?: Queue<DeliveryDlqMessageV1>;
+      }
+    | PortableWorkerBindings
+  );
+
 function isMaterializedRuntimeEnv(
   bindings: WorkerBindings | Env,
 ): bindings is Env {
@@ -1021,16 +1046,19 @@ export default {
     bindings: WorkerBindings,
     ctx: ExecutionContext,
   ): Promise<Response> {
-    return app.fetch(request, wrapCloudflareBindings(bindings), ctx);
+    return app.fetch(request, wrapRuntimeBindings(bindings), ctx);
   },
 
   async queue(
-    batch: MessageBatch<DeliveryQueueMessageV1 | DeliveryDlqMessageV1>,
+    batch:
+      | MessageBatch<DeliveryQueueMessageV1 | DeliveryDlqMessageV1>
+      | EdgeQueueBatch,
     bindings: WorkerBindings,
   ): Promise<void> {
+    const lane = resolveRuntimeLane(bindings.YURUCOMMU_RUNTIME_LANE);
     return handleYurucommuQueueBatch(
-      wrapCloudflareMessageBatch(batch),
-      wrapCloudflareBindings(bindings),
+      wrapRuntimeMessageBatch(batch, lane),
+      wrapRuntimeBindings(bindings),
     );
   },
 
@@ -1041,7 +1069,7 @@ export default {
   ): Promise<void> {
     const env = isMaterializedRuntimeEnv(bindings)
       ? bindings
-      : wrapCloudflareBindings(bindings);
+      : wrapRuntimeBindings(bindings);
     await runYurucommuRetention(env);
   },
 };

package/src/backend/public.ts

@@ -36,6 +36,66 @@ export {
   createManagedRelationalDatabase,
   type ManagedRelationalDatabaseOptions,
 } from "./runtime/managed-relational.ts";
+// The portable lane: the binding facades a wrapper host projects, and the lane
+// selector that proves a deployment's declared lane against the bindings that
+// actually arrived.
+export {
+  DEFAULT_RUNTIME_LANE,
+  RUNTIME_LANE_VAR,
+  RUNTIME_LANES,
+  RuntimeLaneError,
+  assertRuntimeLaneBindings,
+  resolveRuntimeLane,
+  type CloudflareWorkerBindings,
+  type PortableWorkerBindings,
+  type RuntimeLane,
+  wrapPortableBindings,
+  wrapRuntimeBindings,
+  wrapRuntimeMessageBatch,
+} from "./runtime/lane.ts";
+export {
+  EDGE_KV_MAX_EXPIRATION_TTL_SECONDS,
+  EDGE_KV_MIN_EXPIRATION_TTL_SECONDS,
+  isEdgeObjectsBinding,
+  isEdgeQueueBatch,
+  isEdgeSqlBinding,
+  isNativeD1Database,
+  isNativeR2Bucket,
+  type EdgeKvBinding,
+  type EdgeObjectsBinding,
+  type EdgeQueueBatch,
+  type EdgeQueueBinding,
+  type EdgeSqlBinding,
+  type EdgeSqlResult,
+  type EdgeSqlValue,
+} from "./runtime/edge-facades.ts";
+export {
+  EdgeKeyValueOptionError,
+  EdgeKeyValueStore,
+  EdgeKeyValueValueError,
+  wrapEdgeKv,
+} from "./runtime/edge-kv.ts";
+export {
+  EdgeSqlShapeError,
+  createEdgeSqlDatabase,
+} from "./runtime/edge-sql.ts";
+export {
+  ProxyColumnMismatchError,
+  positionalRow,
+  rewriteProjection,
+  type ProjectedStatement,
+  type RewrittenStatement,
+} from "./runtime/sqlite-proxy-rows.ts";
+export {
+  EdgeQueueShapeError,
+  wrapEdgeMessageBatch,
+  wrapEdgeQueue,
+} from "./runtime/edge-queue.ts";
+export {
+  EdgeObjectStorage,
+  EdgeObjectsShapeError,
+  wrapEdgeObjects,
+} from "./runtime/edge-objects.ts";
 export type {
   IKeyValueStore,
   ObjectStore,

package/src/backend/routes/media.ts

@@ -234,6 +234,10 @@ media.post("/upload", async (c) => {
     // transcode pipeline, and buffering a 40MB video would pressure the Worker
     // memory budget.
     if (isVideo) {
+      // The Blob is handed over whole rather than as a bare stream: an
+      // ObjectStore adapter reads `File.size` from it, so the portable
+      // `edge.objects` lane can declare the length while streaming instead of
+      // buffering the whole video in the Worker to discover it.
       await media.put(r2Key, file, {
         contentType,
       });

package/src/backend/runtime/bun.ts

@@ -24,7 +24,7 @@ import {
   assertPathChainWithinBasePath,
   isPathWithinBasePath,
   resolvePathWithinBasePath,
-} from "./shared.ts";
+} from "./node-paths.ts";
 import { MemoryKV } from "./memory-kv.ts";
 import { isBackendPath } from "../lib/backend-paths.ts";
 import { loadBunSqlite } from "./compat-bun/types.ts";

package/src/backend/runtime/edge-facades.ts

@@ -0,0 +1,353 @@
+/**
+ * The portable binding facades a Takoserver-hosted Worker receives.
+ *
+ * A Worker Version published through Takoform onto a Takoserver Host does not
+ * get Cloudflare's native `KVNamespace` / `D1Database` / `Queue` / `R2Bucket`
+ * objects. The Host's generated entrypoint replaces `env` with an object whose
+ * bindings are the exact facades named by the Interface the Version declared —
+ * `edge.kv@1.0.0`, `edge.sql@1.0.0`, `edge.queue@1.0.0`, `edge.objects@1.0.0`.
+ * The managed Cloudflare backend and the self-host backend project the SAME
+ * facade: same methods, same option keys, same error names. Takoserver's
+ * ADR 0005 states this explicitly for object storage, and its self-host wrapper
+ * repeats it for all four.
+ *
+ * This module is a TYPE MIRROR of that contract plus the structural probes the
+ * lane selector uses. It deliberately contains no behaviour: the adapters that
+ * map a facade onto this repo's runtime ports live in `edge-kv.ts`,
+ * `edge-sql.ts`, `edge-queue.ts`, and `edge-objects.ts`.
+ *
+ * Source of truth (read, do not re-derive from memory):
+ *   takoserver `src/providers/cloudflare-managed-worker-wrapper.ts`
+ *     — `projectEnv`, `createKvAdapter`, `createSqlAdapter`,
+ *       `createQueueAdapter`, `createEdgeObjectsR2Adapter`
+ *   takoserver `src/providers/selfhost-worker-wrapper.ts`
+ *     — `projectEnv`, `createKvAdapter`, `createSqlAdapter`,
+ *       `createQueueAdapter`, `createObjectsAdapter`
+ *
+ * Every method rejects with an `Error` whose `name` is the portable error code
+ * (`invalid_key`, `invalid_value`, `value_too_large`, `metadata_too_large`,
+ * `invalid_cursor`, `invalid_argument`, `sql_error`, `numeric_out_of_range`,
+ * `busy`, `not_found`, `precondition_failed`, `range_not_satisfiable`,
+ * `invalid_body`, `message_too_large`, `batch_too_large`, `invalid_part`,
+ * `already_settled`, `backend_unavailable`). The adapters let those propagate
+ * unchanged so a caller sees the Host's own vocabulary.
+ */
+
+/** Limits the facades enforce. Mirrored so the adapters can fail before the
+ *  round-trip instead of surfacing an opaque `invalid_*` from the Host. */
+export const EDGE_KV_MAX_KEY_BYTES = 467;
+export const EDGE_KV_MAX_VALUE_BYTES = 26214400;
+/** `expirationTtlSeconds` is rejected outside this range by both backends. */
+export const EDGE_KV_MIN_EXPIRATION_TTL_SECONDS = 60;
+export const EDGE_KV_MAX_EXPIRATION_TTL_SECONDS = 315360000;
+export const EDGE_KV_MAX_LIST_LIMIT = 1000;
+export const EDGE_SQL_MAX_STATEMENTS = 100;
+export const EDGE_SQL_MAX_PARAMETERS = 100;
+export const EDGE_SQL_MAX_ROWS = 10000;
+export const EDGE_SQL_MAX_COLUMNS = 100;
+export const EDGE_QUEUE_MAX_MESSAGES = 100;
+
+/** A byte string on the wire. The facades never hand out raw `Uint8Array`. */
+export interface EdgeEncodedBytes {
+  readonly encoding: "base64";
+  readonly data: string;
+}
+
+/** Exactly what `edge.sql` accepts as a bound parameter and returns in a row. */
+export type EdgeSqlValue = null | number | string | EdgeEncodedBytes;
+
+export interface EdgeSqlStatement {
+  readonly sql: string;
+  readonly params?: readonly EdgeSqlValue[];
+}
+
+/**
+ * One statement's result. `rows` are RECORDS keyed by result-column name, not
+ * positional arrays — the single most consequential difference from D1, and the
+ * reason the lane has to rewrite the projection list (`sqlite-proxy-rows.ts`)
+ * before it can hand anything to Drizzle.
+ */
+export interface EdgeSqlResult {
+  readonly rows: readonly Readonly<Record<string, EdgeSqlValue>>[];
+  readonly rowsWritten: number;
+}
+
+/** `edge.sql@1.0.0`. */
+export interface EdgeSqlBinding {
+  execute(
+    sql: string,
+    params?: readonly EdgeSqlValue[],
+  ): Promise<EdgeSqlResult>;
+  /** `execute` restricted to statements that write nothing. */
+  query(sql: string, params?: readonly EdgeSqlValue[]): Promise<EdgeSqlResult>;
+  /** All-or-none. 1..100 statements, ordered, one Host round trip. */
+  transaction(
+    statements: readonly EdgeSqlStatement[],
+  ): Promise<readonly EdgeSqlResult[]>;
+}
+
+export interface EdgeKvPutOptions {
+  readonly expirationTtlSeconds?: number;
+  /** String values only; the Host projects a record of strings. */
+  readonly metadata?: Record<string, string>;
+}
+
+export interface EdgeKvListOptions {
+  readonly prefix?: string;
+  readonly cursor?: string;
+  readonly limit?: number;
+}
+
+/**
+ * A listed key carries its NAME ONLY. Neither backend returns the expiration or
+ * the metadata it stored, so `IKeyValueStore.list` reports those as absent on
+ * this lane.
+ */
+export interface EdgeKvListResult {
+  readonly keys: readonly { readonly name: string }[];
+  readonly listComplete: boolean;
+  readonly cursor?: string;
+}
+
+/** `edge.kv@1.0.0`. Values are always bytes; there is no `type` option. */
+export interface EdgeKvBinding {
+  get(key: string): Promise<ArrayBuffer | null>;
+  getWithMetadata(key: string): Promise<{
+    readonly value: ArrayBuffer;
+    readonly metadata?: Record<string, string>;
+  } | null>;
+  put(
+    key: string,
+    value: string | ArrayBuffer | ArrayBufferView,
+    options?: EdgeKvPutOptions,
+  ): Promise<void>;
+  delete(key: string): Promise<void>;
+  list(options?: EdgeKvListOptions): Promise<EdgeKvListResult>;
+}
+
+export interface EdgeQueueSendOptions {
+  readonly delaySeconds?: number;
+}
+
+export interface EdgeQueueBatchItem {
+  readonly body: string | ArrayBuffer | ArrayBufferView;
+  readonly delaySeconds?: number;
+}
+
+/**
+ * `edge.queue@1.0.0` producer. Bodies are BYTES — there is no structured-clone
+ * path, so a JavaScript object has to be serialized by the caller. `send`
+ * returns the Host's acceptance id, which is not a provider dedupe id.
+ */
+export interface EdgeQueueBinding {
+  send(
+    body: string | ArrayBuffer | ArrayBufferView,
+    options?: EdgeQueueSendOptions,
+  ): Promise<string>;
+  sendBatch(
+    messages: readonly EdgeQueueBatchItem[],
+  ): Promise<readonly string[]>;
+}
+
+/** One message as the Host hands it to a declared `queue` handler. */
+export interface EdgeQueueMessage {
+  readonly id: string;
+  readonly timestampMillis: number;
+  readonly attempts: number;
+  readonly body: EdgeEncodedBytes;
+  acknowledge(): void;
+  /** `delaySeconds`, when given, must be >= 1. */
+  retry(options?: { readonly delaySeconds?: number }): void;
+}
+
+export interface EdgeQueueBatch {
+  readonly batchId: string;
+  readonly queue: string;
+  readonly messages: readonly EdgeQueueMessage[];
+  acknowledgeAll(): void;
+  retryAll(options?: { readonly delaySeconds?: number }): void;
+}
+
+export interface EdgeObjectMetadata {
+  readonly etag: string;
+  readonly size: number;
+  readonly contentType?: string;
+  readonly uploadedAtMillis?: number;
+}
+
+export interface EdgeObjectBody extends EdgeObjectMetadata {
+  readonly body: ReadableStream;
+  readonly partial: boolean;
+  readonly range?: { readonly offset: number; readonly length: number };
+}
+
+export interface EdgeObjectListResult {
+  readonly objects: readonly (EdgeObjectMetadata & { readonly key: string })[];
+  readonly prefixes: readonly string[];
+  readonly truncated: boolean;
+  readonly cursor?: string;
+}
+
+/**
+ * `edge.objects@1.0.0`. Note the fixed arities — the Host counts
+ * `arguments.length`, so `get(key)` with one argument is a type error and the
+ * adapter must pass `undefined` explicitly. There is no `customMetadata`, and a
+ * streaming `put` requires `contentLength`.
+ */
+export interface EdgeObjectsBinding {
+  head(key: string): Promise<EdgeObjectMetadata | null>;
+  get(
+    key: string,
+    options:
+      undefined | { readonly range?: { offset: number; length?: number } },
+  ): Promise<EdgeObjectBody | null>;
+  put(
+    key: string,
+    body: string | ArrayBuffer | ArrayBufferView | ReadableStream,
+    options:
+      | undefined
+      | {
+          readonly contentLength?: number;
+          readonly contentType?: string;
+        },
+  ): Promise<{ readonly etag: string; readonly size: number }>;
+  delete(key: string): Promise<void>;
+  list(
+    options:
+      | undefined
+      | {
+          readonly prefix?: string;
+          readonly delimiter?: string;
+          readonly cursor?: string;
+          readonly limit?: number;
+        },
+  ): Promise<EdgeObjectListResult>;
+}
+
+function hasMethods(value: unknown, names: readonly string[]): boolean {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value as Record<string, unknown>;
+  for (const name of names) {
+    if (typeof record[name] !== "function") return false;
+  }
+  return true;
+}
+
+/**
+ * Structural probes.
+ *
+ * Only ONE binding can be told apart by shape, and the difference matters:
+ *
+ *   decisive   `DB`     — `execute`/`query`/`transaction` (facade) against
+ *                         `prepare`/`batch` (D1). Disjoint method sets.
+ *   decisive   a queue *batch* — `acknowledgeAll` (facade) against `ackAll`
+ *                         (Cloudflare `MessageBatch`).
+ *   AMBIGUOUS  `KV`     — `edge.kv` and `KVNamespace` expose the same five
+ *                         method names.
+ *   AMBIGUOUS  a queue *producer* — both are `send`/`sendBatch`.
+ *   AMBIGUOUS  `MEDIA`  — `edge.objects@1.0.0` is R2's method set by design,
+ *                         multipart helpers included. See below.
+ *
+ * That is why the lane is a DECLARED variable rather than something sniffed:
+ * three of the five bindings cannot be identified at all. The declaration is
+ * then cross-checked against the decisive bindings, so a Worker whose var and
+ * whose bindings disagree refuses to start instead of calling
+ * `kv.get(key, {type})` on a facade that would silently treat the options
+ * object as nothing.
+ */
+export function isEdgeSqlBinding(value: unknown): value is EdgeSqlBinding {
+  return (
+    hasMethods(value, ["execute", "query", "transaction"]) &&
+    typeof (value as Record<string, unknown>).prepare !== "function"
+  );
+}
+
+/** Cloudflare's `D1Database` is the `prepare`/`batch`/`exec` shape. */
+export function isNativeD1Database(value: unknown): boolean {
+  return (
+    hasMethods(value, ["prepare", "batch"]) &&
+    typeof (value as Record<string, unknown>).execute !== "function"
+  );
+}
+
+export function isEdgeQueueBatch(value: unknown): value is EdgeQueueBatch {
+  return (
+    hasMethods(value, ["acknowledgeAll", "retryAll"]) &&
+    Array.isArray((value as Record<string, unknown>).messages)
+  );
+}
+
+/**
+ * A bucket-shaped binding with `edge.objects@1.0.0`'s call signatures.
+ *
+ * NOT DECISIVE, and never a lane test. The facade is R2's method set on
+ * purpose — `head`, `get`, `put`, `delete`, `list`, and the four multipart
+ * calls — so that an app written against R2 ports over unchanged. A real
+ * `R2Bucket` therefore answers `true` here too. Use it to check that SOMETHING
+ * bucket-shaped arrived, never to decide which host projected it: that is what
+ * `YURUCOMMU_RUNTIME_LANE` is for.
+ *
+ * The arity check is the facade's own contract rather than a discriminator:
+ * the Host counts `arguments.length`, so `get` takes its options slot even when
+ * that slot is `undefined`.
+ */
+export function isEdgeObjectsBinding(
+  value: unknown,
+): value is EdgeObjectsBinding {
+  return (
+    hasMethods(value, ["head", "get", "put", "delete", "list"]) &&
+    (value as { get: (...args: unknown[]) => unknown }).get.length === 2
+  );
+}
+
+/**
+ * Cloudflare's `R2Bucket` — and, unavoidably, the `edge.objects` facade.
+ *
+ * A method-name test cannot separate the two, because Takoserver's facade
+ * carries `createMultipartUpload` as well (`selfhost-worker-wrapper.ts`
+ * `createObjectsAdapter`). 4.1.0 used this function to refuse the portable
+ * lane and so refused every self-hosted deployment. Keep it for describing a
+ * binding; do not let it decide a lane.
+ */
+export function isNativeR2Bucket(value: unknown): boolean {
+  return hasMethods(value, [
+    "head",
+    "get",
+    "put",
+    "delete",
+    "list",
+    "createMultipartUpload",
+  ]);
+}
+
+/** Decode one `{encoding:"base64"}` value into bytes. */
+export function decodeEdgeBytes(value: EdgeEncodedBytes): Uint8Array {
+  const binary = atob(value.data);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+
+/** Encode bytes into the facade's wire value. */
+export function encodeEdgeBytes(bytes: Uint8Array): EdgeEncodedBytes {
+  let binary = "";
+  // Chunked so a large blob does not blow the argument limit of `apply`.
+  const CHUNK = 0x8000;
+  for (let index = 0; index < bytes.length; index += CHUNK) {
+    binary += String.fromCharCode(
+      ...bytes.subarray(index, Math.min(index + CHUNK, bytes.length)),
+    );
+  }
+  return { encoding: "base64", data: btoa(binary) };
+}
+
+export function isEdgeEncodedBytes(value: unknown): value is EdgeEncodedBytes {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    (value as EdgeEncodedBytes).encoding === "base64" &&
+    typeof (value as EdgeEncodedBytes).data === "string"
+  );
+}