@aigne/afs-did-space 1.12.0-beta.5

package/dist/transports/http.mjs

@@ -0,0 +1,54 @@
+import { RemoteUserSpaceAFS } from "../remote-afs.mjs";
+import { AFSUnsupportedError } from "@aigne/afs";
+
+//#region src/transports/http.ts
+const ALLOWED_SCHEMES = new Set(["http:", "https:"]);
+function assertUrlScheme(rawUrl) {
+	let parsed;
+	try {
+		parsed = new URL(rawUrl);
+	} catch {
+		throw new Error(`HttpTransport: invalid URL: ${rawUrl}`);
+	}
+	if (!ALLOWED_SCHEMES.has(parsed.protocol)) throw new Error(`HttpTransport: only http(s) is supported, got ${parsed.protocol} (URL: ${rawUrl})`);
+	return parsed;
+}
+var HttpTransport = class {
+	kind = "http";
+	remote;
+	constructor(options) {
+		assertUrlScheme(options.url);
+		this.remote = new RemoteUserSpaceAFS({
+			baseUrl: options.url,
+			token: options.token
+		});
+	}
+	list(path, options) {
+		return this.remote.list(path, options);
+	}
+	read(path, _options) {
+		return this.remote.read(path);
+	}
+	write(path, payload, _options) {
+		return this.remote.write(path, payload);
+	}
+	delete(path, options) {
+		return this.remote.delete(path, options);
+	}
+	async stat(_path, _options) {
+		throw new AFSUnsupportedError("stat", "HttpTransport does not expose stat (REST has no /op=stat); use the WS transport for stat.");
+	}
+	async search(_path, _query, _options) {
+		throw new AFSUnsupportedError("search", "HttpTransport does not expose search (REST has no /op=search); use the WS transport for search.");
+	}
+	async exec(_path, _args, _options) {
+		throw new AFSUnsupportedError("exec", "HttpTransport does not expose exec; use the WS transport for action execution.");
+	}
+	async explain(_path, _options) {
+		throw new AFSUnsupportedError("explain", "HttpTransport does not expose explain; use the WS transport for explain.");
+	}
+};
+
+//#endregion
+export { HttpTransport };
+//# sourceMappingURL=http.mjs.map

package/dist/transports/http.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.mjs","names":[],"sources":["../../src/transports/http.ts"],"sourcesContent":["/**\n * HttpTransport — REST adapter for `/api/space/{path}`.\n *\n * Wire format and error mapping are inherited from the legacy\n * `RemoteUserSpaceAFS` (see `../remote-afs.ts` for the full transport\n * implementation). This file is the Phase 3 facade that:\n *\n *   1. Adds the `kind: \"http\"` discriminator so it can be selected via\n *      `connectDIDSpace`.\n *   2. Validates the base URL scheme up front (https/http only — no\n *      file://, javascript:, data:).\n *   3. Throws `AFSUnsupportedError` for the AFS operations the REST\n *      surface does not expose (stat/search/exec/explain). The existing\n *      `arc space` flows only need list/read/write/delete; richer\n *      operations should travel over the WS transport.\n *\n * The class delegates to the same private REST client the previous\n * `RemoteUserSpaceAFS` used. Keeping that class in-place lets sync code\n * paths that reference it during the migration window keep working.\n */\n\nimport type {\n  AFSDeleteOptions,\n  AFSDeleteResult,\n  AFSExecOptions,\n  AFSExecResult,\n  AFSExplainOptions,\n  AFSExplainResult,\n  AFSListOptions,\n  AFSListResult,\n  AFSReadOptions,\n  AFSReadResult,\n  AFSSearchOptions,\n  AFSSearchResult,\n  AFSStatOptions,\n  AFSStatResult,\n  AFSWriteEntryPayload,\n  AFSWriteOptions,\n  AFSWriteResult,\n} from \"@aigne/afs\";\nimport { AFSUnsupportedError } from \"@aigne/afs\";\nimport { RemoteUserSpaceAFS } from \"../remote-afs.js\";\nimport type { Transport } from \"./types.js\";\n\nexport interface HttpTransportOptions {\n  /** Base URL of the DID Space REST server, e.g. `https://computer.afsd.dev`. */\n  url: string;\n  /** Bearer token for authentication. */\n  token: string;\n}\n\nconst ALLOWED_SCHEMES = new Set([\"http:\", \"https:\"]);\n\nfunction assertUrlScheme(rawUrl: string): URL {\n  let parsed: URL;\n  try {\n    parsed = new URL(rawUrl);\n  } catch {\n    throw new Error(`HttpTransport: invalid URL: ${rawUrl}`);\n  }\n  if (!ALLOWED_SCHEMES.has(parsed.protocol)) {\n    throw new Error(\n      `HttpTransport: only http(s) is supported, got ${parsed.protocol} (URL: ${rawUrl})`,\n    );\n  }\n  return parsed;\n}\n\nexport class HttpTransport implements Transport {\n  readonly kind = \"http\" as const;\n  private readonly remote: RemoteUserSpaceAFS;\n\n  constructor(options: HttpTransportOptions) {\n    assertUrlScheme(options.url);\n    // RemoteUserSpaceAFS additionally enforces HTTPS for non-localhost\n    // (defence-in-depth — keep that behaviour by delegating).\n    this.remote = new RemoteUserSpaceAFS({ baseUrl: options.url, token: options.token });\n  }\n\n  list(path: string, options?: AFSListOptions): Promise<AFSListResult> {\n    return this.remote.list(path, options);\n  }\n\n  read(path: string, _options?: AFSReadOptions): Promise<AFSReadResult> {\n    return this.remote.read(path);\n  }\n\n  write(\n    path: string,\n    payload: AFSWriteEntryPayload,\n    _options?: AFSWriteOptions,\n  ): Promise<AFSWriteResult> {\n    return this.remote.write(path, payload);\n  }\n\n  delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult> {\n    return this.remote.delete(path, options) as unknown as Promise<AFSDeleteResult>;\n  }\n\n  async stat(_path: string, _options?: AFSStatOptions): Promise<AFSStatResult> {\n    throw new AFSUnsupportedError(\n      \"stat\",\n      \"HttpTransport does not expose stat (REST has no /op=stat); use the WS transport for stat.\",\n    );\n  }\n\n  async search(\n    _path: string,\n    _query: string,\n    _options?: AFSSearchOptions,\n  ): Promise<AFSSearchResult> {\n    throw new AFSUnsupportedError(\n      \"search\",\n      \"HttpTransport does not expose search (REST has no /op=search); use the WS transport for search.\",\n    );\n  }\n\n  async exec(\n    _path: string,\n    _args: Record<string, unknown>,\n    _options?: AFSExecOptions,\n  ): Promise<AFSExecResult> {\n    throw new AFSUnsupportedError(\n      \"exec\",\n      \"HttpTransport does not expose exec; use the WS transport for action execution.\",\n    );\n  }\n\n  async explain(_path: string, _options?: AFSExplainOptions): Promise<AFSExplainResult> {\n    throw new AFSUnsupportedError(\n      \"explain\",\n      \"HttpTransport does not expose explain; use the WS transport for explain.\",\n    );\n  }\n}\n"],"mappings":";;;;AAmDA,MAAM,kBAAkB,IAAI,IAAI,CAAC,SAAS,SAAS,CAAC;AAEpD,SAAS,gBAAgB,QAAqB;CAC5C,IAAI;AACJ,KAAI;AACF,WAAS,IAAI,IAAI,OAAO;SAClB;AACN,QAAM,IAAI,MAAM,+BAA+B,SAAS;;AAE1D,KAAI,CAAC,gBAAgB,IAAI,OAAO,SAAS,CACvC,OAAM,IAAI,MACR,iDAAiD,OAAO,SAAS,SAAS,OAAO,GAClF;AAEH,QAAO;;AAGT,IAAa,gBAAb,MAAgD;CAC9C,AAAS,OAAO;CAChB,AAAiB;CAEjB,YAAY,SAA+B;AACzC,kBAAgB,QAAQ,IAAI;AAG5B,OAAK,SAAS,IAAI,mBAAmB;GAAE,SAAS,QAAQ;GAAK,OAAO,QAAQ;GAAO,CAAC;;CAGtF,KAAK,MAAc,SAAkD;AACnE,SAAO,KAAK,OAAO,KAAK,MAAM,QAAQ;;CAGxC,KAAK,MAAc,UAAmD;AACpE,SAAO,KAAK,OAAO,KAAK,KAAK;;CAG/B,MACE,MACA,SACA,UACyB;AACzB,SAAO,KAAK,OAAO,MAAM,MAAM,QAAQ;;CAGzC,OAAO,MAAc,SAAsD;AACzE,SAAO,KAAK,OAAO,OAAO,MAAM,QAAQ;;CAG1C,MAAM,KAAK,OAAe,UAAmD;AAC3E,QAAM,IAAI,oBACR,QACA,4FACD;;CAGH,MAAM,OACJ,OACA,QACA,UAC0B;AAC1B,QAAM,IAAI,oBACR,UACA,kGACD;;CAGH,MAAM,KACJ,OACA,OACA,UACwB;AACxB,QAAM,IAAI,oBACR,QACA,iFACD;;CAGH,MAAM,QAAQ,OAAe,UAAyD;AACpF,QAAM,IAAI,oBACR,WACA,2EACD"}

package/dist/transports/static.cjs

@@ -0,0 +1,55 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let _aigne_afs = require("@aigne/afs");
+let _aigne_afs_http_mount = require("@aigne/afs-http-mount");
+
+//#region src/transports/static.ts
+const ALLOWED_SCHEMES = new Set(["http:", "https:"]);
+function assertScheme(rawUrl) {
+	let parsed;
+	try {
+		parsed = new URL(rawUrl);
+	} catch {
+		throw new Error(`StaticReadonlyTransport: invalid URL: ${rawUrl}`);
+	}
+	if (!ALLOWED_SCHEMES.has(parsed.protocol)) throw new Error(`StaticReadonlyTransport: only http(s) is supported, got ${parsed.protocol} (URL: ${rawUrl})`);
+	return parsed;
+}
+var StaticReadonlyTransport = class {
+	kind = "static-readonly";
+	mount;
+	constructor(options) {
+		assertScheme(options.url);
+		this.mount = new _aigne_afs_http_mount.AFSHttpMount({
+			baseUrl: options.url,
+			token: options.token,
+			allowPrivateNetwork: options.allowPrivateNetwork
+		});
+	}
+	list(path, options) {
+		return this.mount.list(path, options);
+	}
+	read(path, options) {
+		return this.mount.read(path, options);
+	}
+	async write(_path, _payload, _options) {
+		throw new _aigne_afs.AFSReadonlyError("StaticReadonlyTransport is read-only");
+	}
+	async delete(_path, _options) {
+		throw new _aigne_afs.AFSReadonlyError("StaticReadonlyTransport is read-only");
+	}
+	stat(path, options) {
+		return this.mount.stat(path, options);
+	}
+	async search(_path, _query, _options) {
+		throw new _aigne_afs.AFSUnsupportedError("search", "StaticReadonlyTransport does not support search; use the WS transport for full-text search.");
+	}
+	async exec(_path, _args, _options) {
+		throw new _aigne_afs.AFSUnsupportedError("exec", "StaticReadonlyTransport does not support exec; static mirrors do not run code.");
+	}
+	explain(path, options) {
+		return this.mount.explain(path, options);
+	}
+};
+
+//#endregion
+exports.StaticReadonlyTransport = StaticReadonlyTransport;

package/dist/transports/static.d.cts

@@ -0,0 +1,28 @@
+import { Transport } from "./types.cjs";
+import { AFSDeleteOptions, AFSDeleteResult, AFSExecOptions, AFSExecResult, AFSExplainOptions, AFSExplainResult, AFSListOptions, AFSListResult, AFSReadOptions, AFSReadResult, AFSSearchOptions, AFSSearchResult, AFSStatOptions, AFSStatResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+
+//#region src/transports/static.d.ts
+interface StaticReadonlyTransportOptions {
+  /** Base URL of the readonly tree (must serve `/.afs/manifest.json`). */
+  url: string;
+  /** Optional bearer token forwarded to every fetch (for private mirrors). */
+  token?: string;
+  /** Allow private/loopback hosts (local dev / fixture servers). */
+  allowPrivateNetwork?: boolean;
+}
+declare class StaticReadonlyTransport implements Transport {
+  readonly kind: "static-readonly";
+  private readonly mount;
+  constructor(options: StaticReadonlyTransportOptions);
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
+  write(_path: string, _payload: AFSWriteEntryPayload, _options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  delete(_path: string, _options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+  stat(path: string, options?: AFSStatOptions): Promise<AFSStatResult>;
+  search(_path: string, _query: string, _options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  exec(_path: string, _args: Record<string, unknown>, _options?: AFSExecOptions): Promise<AFSExecResult>;
+  explain(path: string, options?: AFSExplainOptions): Promise<AFSExplainResult>;
+}
+//#endregion
+export { StaticReadonlyTransport, StaticReadonlyTransportOptions };
+//# sourceMappingURL=static.d.cts.map

package/dist/transports/static.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static.d.cts","names":[],"sources":["../../src/transports/static.ts"],"mappings":";;;;UAgEiB,8BAAA;EAkCZ;EAhCH,GAAA;EAoCkE;EAlClE,KAAA;EAsC6B;EApC7B,mBAAA;AAAA;AAAA,cAGW,uBAAA,YAAmC,SAAA;EAAA,SACrC,IAAA;EAAA,iBACQ,KAAA;cAEL,OAAA,EAAS,8BAAA;EASrB,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAItD,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAIhD,KAAA,CACJ,KAAA,UACA,QAAA,EAAU,oBAAA,EACV,QAAA,GAAW,eAAA,GACV,OAAA,CAAQ,cAAA;EAIL,MAAA,CAAO,KAAA,UAAe,QAAA,GAAW,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAIlE,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAIhD,MAAA,CACJ,KAAA,UACA,MAAA,UACA,QAAA,GAAW,gBAAA,GACV,OAAA,CAAQ,eAAA;EAOL,IAAA,CACJ,KAAA,UACA,KAAA,EAAO,MAAA,mBACP,QAAA,GAAW,cAAA,GACV,OAAA,CAAQ,aAAA;EAOX,OAAA,CAAQ,IAAA,UAAc,OAAA,GAAU,iBAAA,GAAoB,OAAA,CAAQ,gBAAA;AAAA"}

package/dist/transports/static.d.mts

@@ -0,0 +1,28 @@
+import { Transport } from "./types.mjs";
+import { AFSDeleteOptions, AFSDeleteResult, AFSExecOptions, AFSExecResult, AFSExplainOptions, AFSExplainResult, AFSListOptions, AFSListResult, AFSReadOptions, AFSReadResult, AFSSearchOptions, AFSSearchResult, AFSStatOptions, AFSStatResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+
+//#region src/transports/static.d.ts
+interface StaticReadonlyTransportOptions {
+  /** Base URL of the readonly tree (must serve `/.afs/manifest.json`). */
+  url: string;
+  /** Optional bearer token forwarded to every fetch (for private mirrors). */
+  token?: string;
+  /** Allow private/loopback hosts (local dev / fixture servers). */
+  allowPrivateNetwork?: boolean;
+}
+declare class StaticReadonlyTransport implements Transport {
+  readonly kind: "static-readonly";
+  private readonly mount;
+  constructor(options: StaticReadonlyTransportOptions);
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
+  write(_path: string, _payload: AFSWriteEntryPayload, _options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  delete(_path: string, _options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+  stat(path: string, options?: AFSStatOptions): Promise<AFSStatResult>;
+  search(_path: string, _query: string, _options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  exec(_path: string, _args: Record<string, unknown>, _options?: AFSExecOptions): Promise<AFSExecResult>;
+  explain(path: string, options?: AFSExplainOptions): Promise<AFSExplainResult>;
+}
+//#endregion
+export { StaticReadonlyTransport, StaticReadonlyTransportOptions };
+//# sourceMappingURL=static.d.mts.map

package/dist/transports/static.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static.d.mts","names":[],"sources":["../../src/transports/static.ts"],"mappings":";;;;UAgEiB,8BAAA;EAkCZ;EAhCH,GAAA;EAoCkE;EAlClE,KAAA;EAsC6B;EApC7B,mBAAA;AAAA;AAAA,cAGW,uBAAA,YAAmC,SAAA;EAAA,SACrC,IAAA;EAAA,iBACQ,KAAA;cAEL,OAAA,EAAS,8BAAA;EASrB,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAItD,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAIhD,KAAA,CACJ,KAAA,UACA,QAAA,EAAU,oBAAA,EACV,QAAA,GAAW,eAAA,GACV,OAAA,CAAQ,cAAA;EAIL,MAAA,CAAO,KAAA,UAAe,QAAA,GAAW,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAIlE,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAIhD,MAAA,CACJ,KAAA,UACA,MAAA,UACA,QAAA,GAAW,gBAAA,GACV,OAAA,CAAQ,eAAA;EAOL,IAAA,CACJ,KAAA,UACA,KAAA,EAAO,MAAA,mBACP,QAAA,GAAW,cAAA,GACV,OAAA,CAAQ,aAAA;EAOX,OAAA,CAAQ,IAAA,UAAc,OAAA,GAAU,iBAAA,GAAoB,OAAA,CAAQ,gBAAA;AAAA"}

package/dist/transports/static.mjs

@@ -0,0 +1,55 @@
+import { AFSReadonlyError, AFSUnsupportedError } from "@aigne/afs";
+import { AFSHttpMount } from "@aigne/afs-http-mount";
+
+//#region src/transports/static.ts
+const ALLOWED_SCHEMES = new Set(["http:", "https:"]);
+function assertScheme(rawUrl) {
+	let parsed;
+	try {
+		parsed = new URL(rawUrl);
+	} catch {
+		throw new Error(`StaticReadonlyTransport: invalid URL: ${rawUrl}`);
+	}
+	if (!ALLOWED_SCHEMES.has(parsed.protocol)) throw new Error(`StaticReadonlyTransport: only http(s) is supported, got ${parsed.protocol} (URL: ${rawUrl})`);
+	return parsed;
+}
+var StaticReadonlyTransport = class {
+	kind = "static-readonly";
+	mount;
+	constructor(options) {
+		assertScheme(options.url);
+		this.mount = new AFSHttpMount({
+			baseUrl: options.url,
+			token: options.token,
+			allowPrivateNetwork: options.allowPrivateNetwork
+		});
+	}
+	list(path, options) {
+		return this.mount.list(path, options);
+	}
+	read(path, options) {
+		return this.mount.read(path, options);
+	}
+	async write(_path, _payload, _options) {
+		throw new AFSReadonlyError("StaticReadonlyTransport is read-only");
+	}
+	async delete(_path, _options) {
+		throw new AFSReadonlyError("StaticReadonlyTransport is read-only");
+	}
+	stat(path, options) {
+		return this.mount.stat(path, options);
+	}
+	async search(_path, _query, _options) {
+		throw new AFSUnsupportedError("search", "StaticReadonlyTransport does not support search; use the WS transport for full-text search.");
+	}
+	async exec(_path, _args, _options) {
+		throw new AFSUnsupportedError("exec", "StaticReadonlyTransport does not support exec; static mirrors do not run code.");
+	}
+	explain(path, options) {
+		return this.mount.explain(path, options);
+	}
+};
+
+//#endregion
+export { StaticReadonlyTransport };
+//# sourceMappingURL=static.mjs.map

package/dist/transports/static.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"static.mjs","names":[],"sources":["../../src/transports/static.ts"],"sourcesContent":["/**\n * StaticReadonlyTransport — read-only DID Space mirror over HTTPS.\n *\n * A thin facade over `@aigne/afs-http-mount`'s `AFSHttpMount`. The\n * upstream URL is expected to serve:\n *\n *   - `{baseUrl}/.afs/manifest.json` (`{ afs: \"1.0\", type: \"readonly-tree\" }`)\n *   - `{baseUrl}/{path}` raw file bytes for every entry listed there.\n *\n * Behaviour:\n *\n *   - `list` / `read` / `stat` / `explain` — delegated to AFSHttpMount.\n *   - `write` / `delete` — throw `AFSReadonlyError`. Read-only is the\n *     point of this transport, not a runtime accident.\n *   - `search` / `exec` — `AFSUnsupportedError`. Public mirrors do not\n *     run code or full-text search; consumers needing those should\n *     connect over `WsTransport`.\n *   - SSRF — inherits `AFSHttpMount`'s URL validation; private networks\n *     require `allowPrivateNetwork: true`.\n *   - Binary content — passes through whatever `AFSHttpMount.read`\n *     returns; `AFSHttpMount` already classifies text vs binary by mime\n *     and verifies SHA-256 when manifest hashes are present.\n */\n\nimport type {\n  AFSDeleteOptions,\n  AFSDeleteResult,\n  AFSExecOptions,\n  AFSExecResult,\n  AFSExplainOptions,\n  AFSExplainResult,\n  AFSListOptions,\n  AFSListResult,\n  AFSReadOptions,\n  AFSReadResult,\n  AFSSearchOptions,\n  AFSSearchResult,\n  AFSStatOptions,\n  AFSStatResult,\n  AFSWriteEntryPayload,\n  AFSWriteOptions,\n  AFSWriteResult,\n} from \"@aigne/afs\";\nimport { AFSReadonlyError, AFSUnsupportedError } from \"@aigne/afs\";\nimport { AFSHttpMount } from \"@aigne/afs-http-mount\";\nimport type { Transport } from \"./types.js\";\n\nconst ALLOWED_SCHEMES = new Set([\"http:\", \"https:\"]);\n\nfunction assertScheme(rawUrl: string): URL {\n  let parsed: URL;\n  try {\n    parsed = new URL(rawUrl);\n  } catch {\n    throw new Error(`StaticReadonlyTransport: invalid URL: ${rawUrl}`);\n  }\n  if (!ALLOWED_SCHEMES.has(parsed.protocol)) {\n    throw new Error(\n      `StaticReadonlyTransport: only http(s) is supported, got ${parsed.protocol} (URL: ${rawUrl})`,\n    );\n  }\n  return parsed;\n}\n\nexport interface StaticReadonlyTransportOptions {\n  /** Base URL of the readonly tree (must serve `/.afs/manifest.json`). */\n  url: string;\n  /** Optional bearer token forwarded to every fetch (for private mirrors). */\n  token?: string;\n  /** Allow private/loopback hosts (local dev / fixture servers). */\n  allowPrivateNetwork?: boolean;\n}\n\nexport class StaticReadonlyTransport implements Transport {\n  readonly kind = \"static-readonly\" as const;\n  private readonly mount: AFSHttpMount;\n\n  constructor(options: StaticReadonlyTransportOptions) {\n    assertScheme(options.url);\n    this.mount = new AFSHttpMount({\n      baseUrl: options.url,\n      token: options.token,\n      allowPrivateNetwork: options.allowPrivateNetwork,\n    });\n  }\n\n  list(path: string, options?: AFSListOptions): Promise<AFSListResult> {\n    return this.mount.list(path, options);\n  }\n\n  read(path: string, options?: AFSReadOptions): Promise<AFSReadResult> {\n    return this.mount.read(path, options);\n  }\n\n  async write(\n    _path: string,\n    _payload: AFSWriteEntryPayload,\n    _options?: AFSWriteOptions,\n  ): Promise<AFSWriteResult> {\n    throw new AFSReadonlyError(\"StaticReadonlyTransport is read-only\");\n  }\n\n  async delete(_path: string, _options?: AFSDeleteOptions): Promise<AFSDeleteResult> {\n    throw new AFSReadonlyError(\"StaticReadonlyTransport is read-only\");\n  }\n\n  stat(path: string, options?: AFSStatOptions): Promise<AFSStatResult> {\n    return this.mount.stat(path, options);\n  }\n\n  async search(\n    _path: string,\n    _query: string,\n    _options?: AFSSearchOptions,\n  ): Promise<AFSSearchResult> {\n    throw new AFSUnsupportedError(\n      \"search\",\n      \"StaticReadonlyTransport does not support search; use the WS transport for full-text search.\",\n    );\n  }\n\n  async exec(\n    _path: string,\n    _args: Record<string, unknown>,\n    _options?: AFSExecOptions,\n  ): Promise<AFSExecResult> {\n    throw new AFSUnsupportedError(\n      \"exec\",\n      \"StaticReadonlyTransport does not support exec; static mirrors do not run code.\",\n    );\n  }\n\n  explain(path: string, options?: AFSExplainOptions): Promise<AFSExplainResult> {\n    return this.mount.explain(path, options);\n  }\n}\n"],"mappings":";;;;AA+CA,MAAM,kBAAkB,IAAI,IAAI,CAAC,SAAS,SAAS,CAAC;AAEpD,SAAS,aAAa,QAAqB;CACzC,IAAI;AACJ,KAAI;AACF,WAAS,IAAI,IAAI,OAAO;SAClB;AACN,QAAM,IAAI,MAAM,yCAAyC,SAAS;;AAEpE,KAAI,CAAC,gBAAgB,IAAI,OAAO,SAAS,CACvC,OAAM,IAAI,MACR,2DAA2D,OAAO,SAAS,SAAS,OAAO,GAC5F;AAEH,QAAO;;AAYT,IAAa,0BAAb,MAA0D;CACxD,AAAS,OAAO;CAChB,AAAiB;CAEjB,YAAY,SAAyC;AACnD,eAAa,QAAQ,IAAI;AACzB,OAAK,QAAQ,IAAI,aAAa;GAC5B,SAAS,QAAQ;GACjB,OAAO,QAAQ;GACf,qBAAqB,QAAQ;GAC9B,CAAC;;CAGJ,KAAK,MAAc,SAAkD;AACnE,SAAO,KAAK,MAAM,KAAK,MAAM,QAAQ;;CAGvC,KAAK,MAAc,SAAkD;AACnE,SAAO,KAAK,MAAM,KAAK,MAAM,QAAQ;;CAGvC,MAAM,MACJ,OACA,UACA,UACyB;AACzB,QAAM,IAAI,iBAAiB,uCAAuC;;CAGpE,MAAM,OAAO,OAAe,UAAuD;AACjF,QAAM,IAAI,iBAAiB,uCAAuC;;CAGpE,KAAK,MAAc,SAAkD;AACnE,SAAO,KAAK,MAAM,KAAK,MAAM,QAAQ;;CAGvC,MAAM,OACJ,OACA,QACA,UAC0B;AAC1B,QAAM,IAAI,oBACR,UACA,8FACD;;CAGH,MAAM,KACJ,OACA,OACA,UACwB;AACxB,QAAM,IAAI,oBACR,QACA,iFACD;;CAGH,QAAQ,MAAc,SAAwD;AAC5E,SAAO,KAAK,MAAM,QAAQ,MAAM,QAAQ"}

package/dist/transports/types.cjs

@@ -0,0 +1,13 @@
+
+//#region src/transports/types.ts
+/**
+* Runtime check for `TransportConfig.kind`. Useful in factory code
+* where we have an `unknown` config and want a friendly error rather
+* than a raw type cast.
+*/
+function isTransportKind(value) {
+	return value === "http" || value === "ws" || value === "static-readonly";
+}
+
+//#endregion
+exports.isTransportKind = isTransportKind;

package/dist/transports/types.d.cts

@@ -0,0 +1,72 @@
+import { AFSDeleteOptions, AFSDeleteResult, AFSEvent, AFSExecOptions, AFSExecResult, AFSExplainOptions, AFSExplainResult, AFSListOptions, AFSListResult, AFSReadOptions, AFSReadResult, AFSSearchOptions, AFSSearchResult, AFSStatOptions, AFSStatResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+
+//#region src/transports/types.d.ts
+type TransportKind = "http" | "ws" | "static-readonly";
+/**
+ * Unsubscribe callback returned from `subscribe()`. Calling it cancels
+ * the subscription and releases any underlying transport resources
+ * (e.g. RPC handles, watcher state).
+ */
+type Unsubscribe = () => void | Promise<void>;
+/**
+ * Wire-level adapter for a DID Space.
+ *
+ * Implementations must throw AFS-typed errors (`AFSNotFoundError`, …)
+ * for AFS-semantic failures and plain `Error` (or transport-specific
+ * subclasses) for connection / auth / protocol failures.
+ */
+interface Transport {
+  /** Discriminator — used by `connectDIDSpace` to select the right kind. */
+  readonly kind: TransportKind;
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
+  write(path: string, payload: AFSWriteEntryPayload, options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+  stat(path: string, options?: AFSStatOptions): Promise<AFSStatResult>;
+  search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  exec(path: string, args: Record<string, unknown>, options?: AFSExecOptions): Promise<AFSExecResult>;
+  explain(path: string, options?: AFSExplainOptions): Promise<AFSExplainResult>;
+  /**
+   * Optional change subscription. Implementations that support push
+   * (e.g. `WsTransport` via `.changelog/{seq}` virtual path) wire this
+   * up; `HttpTransport` and `StaticReadonlyTransport` may omit it.
+   *
+   * `path` is the AFS sub-tree to watch; `onEvent` is invoked for every
+   * change. The returned `Unsubscribe` releases all resources held by
+   * the subscription.
+   */
+  subscribe?(path: string, onEvent: (event: AFSEvent) => void): Promise<Unsubscribe>;
+  /** Optional tear-down for long-lived transports (WS sockets etc.). */
+  close?(): Promise<void>;
+}
+interface HttpTransportConfig {
+  kind: "http";
+  /** Base URL of the DID Space server, e.g. `https://computer.afsd.dev`. */
+  url: string;
+  /** Bearer token for authentication. */
+  token: string;
+}
+interface WsTransportConfig {
+  kind: "ws";
+  /** WebSocket URL of the DID Space server, e.g. `ws://localhost:9999`. */
+  url: string;
+  /** Bearer token used in the WebSocket subprotocol or `Authorization` header. */
+  token: string;
+  /** Session namespace passed to `session.attach`. Default: `"did-space-client"`. */
+  namespace?: string;
+  /** Request timeout in ms. Default: 30000. */
+  requestTimeout?: number;
+}
+interface StaticReadonlyTransportConfig {
+  kind: "static-readonly";
+  /** HTTPS base URL serving an AFS readonly tree (with `/.afs/manifest.json`). */
+  url: string;
+  /** Optional bearer token forwarded to every fetch (for private mirrors). */
+  token?: string;
+  /** Allow private/loopback hosts (local dev only). */
+  allowPrivateNetwork?: boolean;
+}
+type TransportConfig = HttpTransportConfig | WsTransportConfig | StaticReadonlyTransportConfig;
+//#endregion
+export { HttpTransportConfig, StaticReadonlyTransportConfig, Transport, TransportConfig, TransportKind, Unsubscribe, WsTransportConfig };
+//# sourceMappingURL=types.d.cts.map

package/dist/transports/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/transports/types.ts"],"mappings":";;;KAwDY,aAAA;;;;;;KAOA,WAAA,gBAA2B,OAAA;;;;;;;;UAStB,SAAA;EAiCL;EAAA,SA/BD,IAAA,EAAM,aAAA;EAEf,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EACtD,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EACtD,KAAA,CACE,IAAA,UACA,OAAA,EAAS,oBAAA,EACT,OAAA,GAAU,eAAA,GACT,OAAA,CAAQ,cAAA;EACX,MAAA,CAAO,IAAA,UAAc,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAC1D,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EACtD,MAAA,CAAO,IAAA,UAAc,KAAA,UAAe,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EACzE,IAAA,CACE,IAAA,UACA,IAAA,EAAM,MAAA,mBACN,OAAA,GAAU,cAAA,GACT,OAAA,CAAQ,aAAA;EACX,OAAA,CAAQ,IAAA,UAAc,OAAA,GAAU,iBAAA,GAAoB,OAAA,CAAQ,gBAAA;EAfN;;;;;;;;;EA0BtD,SAAA,EAAW,IAAA,UAAc,OAAA,GAAU,KAAA,EAAO,QAAA,YAAoB,OAAA,CAAQ,WAAA;EAtBpE;EAyBF,KAAA,KAAU,OAAA;AAAA;AAAA,UAOK,mBAAA;EACf,IAAA;EA9BA;EAgCA,GAAA;EAhC+B;EAkC/B,KAAA;AAAA;AAAA,UAGe,iBAAA;EACf,IAAA;EArCK;EAuCL,GAAA;EAvCmB;EAyCnB,KAAA;EAzCsD;EA2CtD,SAAA;EA1CO;EA4CP,cAAA;AAAA;AAAA,UAGe,6BAAA;EACf,IAAA;EAhDyE;EAkDzE,GAAA;EAhDE;EAkDF,KAAA;EAjDE;EAmDF,mBAAA;AAAA;AAAA,KAGU,eAAA,GACR,mBAAA,GACA,iBAAA,GACA,6BAAA"}

package/dist/transports/types.d.mts

@@ -0,0 +1,72 @@
+import { AFSDeleteOptions, AFSDeleteResult, AFSEvent, AFSExecOptions, AFSExecResult, AFSExplainOptions, AFSExplainResult, AFSListOptions, AFSListResult, AFSReadOptions, AFSReadResult, AFSSearchOptions, AFSSearchResult, AFSStatOptions, AFSStatResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+
+//#region src/transports/types.d.ts
+type TransportKind = "http" | "ws" | "static-readonly";
+/**
+ * Unsubscribe callback returned from `subscribe()`. Calling it cancels
+ * the subscription and releases any underlying transport resources
+ * (e.g. RPC handles, watcher state).
+ */
+type Unsubscribe = () => void | Promise<void>;
+/**
+ * Wire-level adapter for a DID Space.
+ *
+ * Implementations must throw AFS-typed errors (`AFSNotFoundError`, …)
+ * for AFS-semantic failures and plain `Error` (or transport-specific
+ * subclasses) for connection / auth / protocol failures.
+ */
+interface Transport {
+  /** Discriminator — used by `connectDIDSpace` to select the right kind. */
+  readonly kind: TransportKind;
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
+  write(path: string, payload: AFSWriteEntryPayload, options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+  stat(path: string, options?: AFSStatOptions): Promise<AFSStatResult>;
+  search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  exec(path: string, args: Record<string, unknown>, options?: AFSExecOptions): Promise<AFSExecResult>;
+  explain(path: string, options?: AFSExplainOptions): Promise<AFSExplainResult>;
+  /**
+   * Optional change subscription. Implementations that support push
+   * (e.g. `WsTransport` via `.changelog/{seq}` virtual path) wire this
+   * up; `HttpTransport` and `StaticReadonlyTransport` may omit it.
+   *
+   * `path` is the AFS sub-tree to watch; `onEvent` is invoked for every
+   * change. The returned `Unsubscribe` releases all resources held by
+   * the subscription.
+   */
+  subscribe?(path: string, onEvent: (event: AFSEvent) => void): Promise<Unsubscribe>;
+  /** Optional tear-down for long-lived transports (WS sockets etc.). */
+  close?(): Promise<void>;
+}
+interface HttpTransportConfig {
+  kind: "http";
+  /** Base URL of the DID Space server, e.g. `https://computer.afsd.dev`. */
+  url: string;
+  /** Bearer token for authentication. */
+  token: string;
+}
+interface WsTransportConfig {
+  kind: "ws";
+  /** WebSocket URL of the DID Space server, e.g. `ws://localhost:9999`. */
+  url: string;
+  /** Bearer token used in the WebSocket subprotocol or `Authorization` header. */
+  token: string;
+  /** Session namespace passed to `session.attach`. Default: `"did-space-client"`. */
+  namespace?: string;
+  /** Request timeout in ms. Default: 30000. */
+  requestTimeout?: number;
+}
+interface StaticReadonlyTransportConfig {
+  kind: "static-readonly";
+  /** HTTPS base URL serving an AFS readonly tree (with `/.afs/manifest.json`). */
+  url: string;
+  /** Optional bearer token forwarded to every fetch (for private mirrors). */
+  token?: string;
+  /** Allow private/loopback hosts (local dev only). */
+  allowPrivateNetwork?: boolean;
+}
+type TransportConfig = HttpTransportConfig | WsTransportConfig | StaticReadonlyTransportConfig;
+//#endregion
+export { HttpTransportConfig, StaticReadonlyTransportConfig, Transport, TransportConfig, TransportKind, Unsubscribe, WsTransportConfig };
+//# sourceMappingURL=types.d.mts.map

package/dist/transports/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/transports/types.ts"],"mappings":";;;KAwDY,aAAA;;;;;;KAOA,WAAA,gBAA2B,OAAA;;;;;;;;UAStB,SAAA;EAiCL;EAAA,SA/BD,IAAA,EAAM,aAAA;EAEf,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EACtD,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EACtD,KAAA,CACE,IAAA,UACA,OAAA,EAAS,oBAAA,EACT,OAAA,GAAU,eAAA,GACT,OAAA,CAAQ,cAAA;EACX,MAAA,CAAO,IAAA,UAAc,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAC1D,IAAA,CAAK,IAAA,UAAc,OAAA,GAAU,cAAA,GAAiB,OAAA,CAAQ,aAAA;EACtD,MAAA,CAAO,IAAA,UAAc,KAAA,UAAe,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EACzE,IAAA,CACE,IAAA,UACA,IAAA,EAAM,MAAA,mBACN,OAAA,GAAU,cAAA,GACT,OAAA,CAAQ,aAAA;EACX,OAAA,CAAQ,IAAA,UAAc,OAAA,GAAU,iBAAA,GAAoB,OAAA,CAAQ,gBAAA;EAfN;;;;;;;;;EA0BtD,SAAA,EAAW,IAAA,UAAc,OAAA,GAAU,KAAA,EAAO,QAAA,YAAoB,OAAA,CAAQ,WAAA;EAtBpE;EAyBF,KAAA,KAAU,OAAA;AAAA;AAAA,UAOK,mBAAA;EACf,IAAA;EA9BA;EAgCA,GAAA;EAhC+B;EAkC/B,KAAA;AAAA;AAAA,UAGe,iBAAA;EACf,IAAA;EArCK;EAuCL,GAAA;EAvCmB;EAyCnB,KAAA;EAzCsD;EA2CtD,SAAA;EA1CO;EA4CP,cAAA;AAAA;AAAA,UAGe,6BAAA;EACf,IAAA;EAhDyE;EAkDzE,GAAA;EAhDE;EAkDF,KAAA;EAjDE;EAmDF,mBAAA;AAAA;AAAA,KAGU,eAAA,GACR,mBAAA,GACA,iBAAA,GACA,6BAAA"}

package/dist/transports/types.mjs

@@ -0,0 +1,13 @@
+//#region src/transports/types.ts
+/**
+* Runtime check for `TransportConfig.kind`. Useful in factory code
+* where we have an `unknown` config and want a friendly error rather
+* than a raw type cast.
+*/
+function isTransportKind(value) {
+	return value === "http" || value === "ws" || value === "static-readonly";
+}
+
+//#endregion
+export { isTransportKind };
+//# sourceMappingURL=types.mjs.map

package/dist/transports/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":[],"sources":["../../src/transports/types.ts"],"sourcesContent":["/**\n * Phase 3 — Transport interface.\n *\n * A `Transport` is the wire-level adapter a `DIDSpaceClient` uses to talk\n * to a DID Space. It is intentionally narrower than `AFSModule`:\n *\n *   1. No mount/lifecycle hooks (`onMount` / `setEventSink` / etc.) —\n *      those belong to the wrapping `DIDSpaceClient` provider, not to\n *      individual transports.\n *   2. Shape mirrors the AFS surface (list/read/write/delete/stat/search/\n *      exec/explain) so a transport can be 1:1 with a remote DID Space.\n *   3. Failure semantics are explicitly *transport* failures — connection\n *      drops, auth errors, sidecar buffering issues — not AFS semantic\n *      errors. The AFS error mapping (`AFSNotFoundError`, …) is decoded\n *      from the wire response and re-thrown by the transport so callers\n *      get one coherent error model.\n *\n * Three kinds are supported in Phase 3:\n *\n *   - `http`             — REST over HTTPS (`/api/space/{path}`). What\n *                          today's `RemoteUserSpaceAFS` did, extracted.\n *   - `ws`               — WebSocket via `@aigne/afs-session` (`session.attach`\n *                          + `afs.*` RPC + `afs.subscribe` push).\n *   - `static-readonly`  — Read-only HTTP tree backed by an `AFSHttpMount`\n *                          manifest. Useful for public DID Space mirrors.\n *\n * Design note: the interface is a discriminated union via the `kind`\n * field. Adding a new transport (e.g. an in-process transport for\n * tests) is a matter of adding a new variant.\n */\n\nimport type {\n  AFSDeleteOptions,\n  AFSDeleteResult,\n  AFSEvent,\n  AFSExecOptions,\n  AFSExecResult,\n  AFSExplainOptions,\n  AFSExplainResult,\n  AFSListOptions,\n  AFSListResult,\n  AFSReadOptions,\n  AFSReadResult,\n  AFSSearchOptions,\n  AFSSearchResult,\n  AFSStatOptions,\n  AFSStatResult,\n  AFSWriteEntryPayload,\n  AFSWriteOptions,\n  AFSWriteResult,\n} from \"@aigne/afs\";\n\n// ---------------------------------------------------------------------------\n// Transport interface\n// ---------------------------------------------------------------------------\n\nexport type TransportKind = \"http\" | \"ws\" | \"static-readonly\";\n\n/**\n * Unsubscribe callback returned from `subscribe()`. Calling it cancels\n * the subscription and releases any underlying transport resources\n * (e.g. RPC handles, watcher state).\n */\nexport type Unsubscribe = () => void | Promise<void>;\n\n/**\n * Wire-level adapter for a DID Space.\n *\n * Implementations must throw AFS-typed errors (`AFSNotFoundError`, …)\n * for AFS-semantic failures and plain `Error` (or transport-specific\n * subclasses) for connection / auth / protocol failures.\n */\nexport interface Transport {\n  /** Discriminator — used by `connectDIDSpace` to select the right kind. */\n  readonly kind: TransportKind;\n\n  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;\n  read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;\n  write(\n    path: string,\n    payload: AFSWriteEntryPayload,\n    options?: AFSWriteOptions,\n  ): Promise<AFSWriteResult>;\n  delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult>;\n  stat(path: string, options?: AFSStatOptions): Promise<AFSStatResult>;\n  search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;\n  exec(\n    path: string,\n    args: Record<string, unknown>,\n    options?: AFSExecOptions,\n  ): Promise<AFSExecResult>;\n  explain(path: string, options?: AFSExplainOptions): Promise<AFSExplainResult>;\n\n  /**\n   * Optional change subscription. Implementations that support push\n   * (e.g. `WsTransport` via `.changelog/{seq}` virtual path) wire this\n   * up; `HttpTransport` and `StaticReadonlyTransport` may omit it.\n   *\n   * `path` is the AFS sub-tree to watch; `onEvent` is invoked for every\n   * change. The returned `Unsubscribe` releases all resources held by\n   * the subscription.\n   */\n  subscribe?(path: string, onEvent: (event: AFSEvent) => void): Promise<Unsubscribe>;\n\n  /** Optional tear-down for long-lived transports (WS sockets etc.). */\n  close?(): Promise<void>;\n}\n\n// ---------------------------------------------------------------------------\n// Per-kind config — input to `connectDIDSpace`\n// ---------------------------------------------------------------------------\n\nexport interface HttpTransportConfig {\n  kind: \"http\";\n  /** Base URL of the DID Space server, e.g. `https://computer.afsd.dev`. */\n  url: string;\n  /** Bearer token for authentication. */\n  token: string;\n}\n\nexport interface WsTransportConfig {\n  kind: \"ws\";\n  /** WebSocket URL of the DID Space server, e.g. `ws://localhost:9999`. */\n  url: string;\n  /** Bearer token used in the WebSocket subprotocol or `Authorization` header. */\n  token: string;\n  /** Session namespace passed to `session.attach`. Default: `\"did-space-client\"`. */\n  namespace?: string;\n  /** Request timeout in ms. Default: 30000. */\n  requestTimeout?: number;\n}\n\nexport interface StaticReadonlyTransportConfig {\n  kind: \"static-readonly\";\n  /** HTTPS base URL serving an AFS readonly tree (with `/.afs/manifest.json`). */\n  url: string;\n  /** Optional bearer token forwarded to every fetch (for private mirrors). */\n  token?: string;\n  /** Allow private/loopback hosts (local dev only). */\n  allowPrivateNetwork?: boolean;\n}\n\nexport type TransportConfig =\n  | HttpTransportConfig\n  | WsTransportConfig\n  | StaticReadonlyTransportConfig;\n\n/**\n * Runtime check for `TransportConfig.kind`. Useful in factory code\n * where we have an `unknown` config and want a friendly error rather\n * than a raw type cast.\n */\nexport function isTransportKind(value: unknown): value is TransportKind {\n  return value === \"http\" || value === \"ws\" || value === \"static-readonly\";\n}\n"],"mappings":";;;;;;AAwJA,SAAgB,gBAAgB,OAAwC;AACtE,QAAO,UAAU,UAAU,UAAU,QAAQ,UAAU"}