@capxul/sdk 0.2.0-alpha.4 → 0.2.0-alpha.5

package/dist/node/index.d.mts

@@ -0,0 +1,55 @@
+import { _ as AuthCachePortTag, g as AuthCachePort, h as AuthCacheError, t as CapxulSigner, v as CachedJwt } from "../signer-oaYGfjDe.mjs";
+import { Effect, Layer } from "effect";
+import { AuthSession } from "@capxul/types";
+import { Hex } from "viem";
+import * as PlatformFileSystem from "@effect/platform/FileSystem";
+import * as PlatformPath from "@effect/platform/Path";
+
+//#region src/adapters/auth-cache/FileSystemAuthCacheAdapter.d.ts
+type FileSystemRuntime = PlatformFileSystem.FileSystem | PlatformPath.Path;
+declare class FileSystemAuthCacheAdapter implements AuthCachePort {
+  private readonly path;
+  private readonly runtime;
+  readonly getSession: Effect.Effect<AuthSession | null, AuthCacheError>;
+  readonly setSession: (session: AuthSession) => Effect.Effect<void, AuthCacheError>;
+  readonly clearSession: Effect.Effect<void, AuthCacheError>;
+  readonly getJwt: Effect.Effect<CachedJwt | null, AuthCacheError>;
+  readonly setJwt: (jwt: CachedJwt) => Effect.Effect<void, AuthCacheError>;
+  readonly clearJwt: Effect.Effect<void, AuthCacheError>;
+  constructor(path: string, runtime?: Layer.Layer<FileSystemRuntime>);
+  private read;
+  private write;
+  private run;
+}
+declare function FileSystemAuthCacheLayer(input: {
+  readonly path: string;
+  readonly runtime?: Layer.Layer<FileSystemRuntime>;
+}): Layer.Layer<AuthCachePortTag, AuthCacheError>;
+//#endregion
+//#region src/node/index.d.ts
+interface DetectNodeAuthCacheAdapterOptions {
+  readonly authCachePath?: string;
+  readonly resolveHomeDirectory?: () => string;
+}
+/**
+ * Node `CapxulSigner` backed by a raw private key. Signs the EIP-712 `SafeOp`
+ * digest the backend returns for a prepared deployment UserOperation. The
+ * reference CLI builds this from `DEPLOYER_PRIVATE_KEY` for the live capstone.
+ */
+declare function localPrivateKeySigner(input: {
+  readonly privateKey: Hex;
+}): CapxulSigner;
+/**
+ * Node-aware auth-cache detection. Mirrors the historic default order:
+ * 1. Browser localStorage → BrowserAuthCacheAdapter
+ * 2. Node.js process → FileSystemAuthCacheAdapter
+ *    (`~/.config/capxul/auth-cache.json`)
+ * 3. Neither detected → InMemoryAuthCacheAdapter
+ *
+ * Use this from a Node entrypoint and pass the result to
+ * `createCapxulClient({ authCache })` for on-disk session persistence.
+ */
+declare function detectNodeAuthCacheAdapter(options?: DetectNodeAuthCacheAdapterOptions): AuthCachePort;
+//#endregion
+export { DetectNodeAuthCacheAdapterOptions, FileSystemAuthCacheAdapter, FileSystemAuthCacheLayer, detectNodeAuthCacheAdapter, localPrivateKeySigner };
+//# sourceMappingURL=index.d.mts.map

package/dist/node/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/adapters/auth-cache/FileSystemAuthCacheAdapter.ts","../../src/node/index.ts"],"mappings":";;;;;;;;KAqBK,iBAAA,GAAoB,kBAAA,CAAmB,UAAA,GAAa,YAAA,CAAa,IAAI;AAAA,cAQ7D,0BAAA,YAAsC,aAAA;EAAA,iBAChC,IAAA;EAAA,iBACA,OAAA;EAAA,SACR,UAAA,EAAY,MAAA,CAAO,MAAA,CAAO,WAAA,SAAoB,cAAA;EAAA,SAC9C,UAAA,GAAa,OAAA,EAAS,WAAA,KAAgB,MAAA,CAAO,MAAA,OAAa,cAAA;EAAA,SAC1D,YAAA,EAAc,MAAA,CAAO,MAAA,OAAa,cAAA;EAAA,SAClC,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,SAAkB,cAAA;EAAA,SACxC,MAAA,GAAS,GAAA,EAAK,SAAA,KAAc,MAAA,CAAO,MAAA,OAAa,cAAA;EAAA,SAChD,QAAA,EAAU,MAAA,CAAO,MAAA,OAAa,cAAA;cAE3B,IAAA,UAAc,OAAA,GAAS,KAAA,CAAM,KAAA,CAAM,iBAAA;EAAA,QAyCvC,IAAA;EAAA,QAyBA,KAAA;EAAA,QAgBA,GAAA;AAAA;AAAA,iBAWM,wBAAA,CAAyB,KAAA;EAAA,SAC9B,IAAA;EAAA,SACA,OAAA,GAAU,KAAA,CAAM,KAAA,CAAM,iBAAA;AAAA,IAC7B,KAAA,CAAM,KAAA,CAAM,gBAAA,EAAkB,cAAA;;;UC9GjB,iCAAA;EAAA,SACN,aAAA;EAAA,SACA,oBAAoB;AAAA;ADdC;;;;;AAAA,iBCsBhB,qBAAA,CAAsB,KAAA;EAAA,SAAkB,UAAA,EAAY,GAAA;AAAA,IAAQ,YAAY;;ADdd;AAQ1E;;;;;;;;iBC+BgB,0BAAA,CACd,OAAA,GAAS,iCAAA,GACR,aAAa"}

package/dist/node/index.mjs

@@ -0,0 +1,159 @@
+import { a as AuthCacheError, i as parseCachedJwt, n as BrowserAuthCacheAdapter, o as AuthCachePortTag, r as parseAuthSession, t as InMemoryAuthCacheAdapter } from "../InMemoryAuthCacheAdapter-BK-B_ERB.mjs";
+import { Effect, Layer } from "effect";
+import { toAddress } from "@capxul/types";
+import { privateKeyToAccount } from "viem/accounts";
+import * as os from "node:os";
+import { join } from "node:path";
+import * as PlatformFileSystem from "@effect/platform/FileSystem";
+import * as PlatformPath from "@effect/platform/Path";
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import * as NodePath from "@effect/platform-node/NodePath";
+//#region src/adapters/auth-cache/FileSystemAuthCacheAdapter.ts
+function emptyPayload() {
+	return {
+		session: null,
+		jwt: null
+	};
+}
+const nodeFileSystemRuntime = Layer.merge(NodeFileSystem.layer, NodePath.layer);
+var FileSystemAuthCacheAdapter = class {
+	path;
+	runtime;
+	getSession;
+	setSession;
+	clearSession;
+	getJwt;
+	setJwt;
+	clearJwt;
+	constructor(path, runtime = nodeFileSystemRuntime) {
+		this.path = path;
+		this.runtime = runtime;
+		this.getSession = this.run("getSession", this.read().pipe(Effect.map((payload) => payload.session)));
+		this.setSession = (session) => this.run("setSession", Effect.gen(this, function* () {
+			const cur = yield* this.read();
+			yield* this.write({
+				session,
+				jwt: cur.jwt
+			});
+		}));
+		this.clearSession = this.run("clearSession", Effect.gen(this, function* () {
+			const cur = yield* this.read();
+			yield* this.write({
+				session: null,
+				jwt: cur.jwt
+			});
+		}));
+		this.getJwt = this.run("getJwt", this.read().pipe(Effect.map((payload) => payload.jwt)));
+		this.setJwt = (jwt) => this.run("setJwt", Effect.gen(this, function* () {
+			const cur = yield* this.read();
+			yield* this.write({
+				session: cur.session,
+				jwt
+			});
+		}));
+		this.clearJwt = this.run("clearJwt", Effect.gen(this, function* () {
+			const cur = yield* this.read();
+			yield* this.write({
+				session: cur.session,
+				jwt: null
+			});
+		}));
+	}
+	read() {
+		return Effect.gen(this, function* () {
+			const fs = yield* PlatformFileSystem.FileSystem;
+			if (!(yield* fs.exists(this.path))) return emptyPayload();
+			const raw = yield* fs.readFileString(this.path, "utf-8");
+			let parsed;
+			try {
+				parsed = JSON.parse(raw);
+			} catch {
+				return emptyPayload();
+			}
+			if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return emptyPayload();
+			const payload = parsed;
+			return {
+				session: parseAuthSession(payload.session),
+				jwt: parseCachedJwt(payload.jwt)
+			};
+		});
+	}
+	write(payload) {
+		return Effect.gen(this, function* () {
+			const fs = yield* PlatformFileSystem.FileSystem;
+			const dir = (yield* PlatformPath.Path).dirname(this.path);
+			if (!(yield* fs.exists(dir))) yield* fs.makeDirectory(dir, {
+				recursive: true,
+				mode: 448
+			});
+			yield* fs.writeFileString(this.path, JSON.stringify(payload), { mode: 384 });
+			yield* fs.chmod(this.path, 384);
+		});
+	}
+	run(operation, effect) {
+		return effect.pipe(Effect.mapError((cause) => toAuthCacheError(operation, cause)), Effect.provide(this.runtime));
+	}
+};
+function FileSystemAuthCacheLayer(input) {
+	return Layer.effect(AuthCachePortTag, Effect.sync(() => new FileSystemAuthCacheAdapter(input.path, input.runtime)).pipe(Effect.mapError((cause) => toAuthCacheError("initialize", cause))));
+}
+function toAuthCacheError(operation, cause) {
+	return new AuthCacheError({
+		operation,
+		cause
+	});
+}
+//#endregion
+//#region src/node/index.ts
+/**
+* Node `CapxulSigner` backed by a raw private key. Signs the EIP-712 `SafeOp`
+* digest the backend returns for a prepared deployment UserOperation. The
+* reference CLI builds this from `DEPLOYER_PRIVATE_KEY` for the live capstone.
+*/
+function localPrivateKeySigner(input) {
+	const account = privateKeyToAccount(input.privateKey);
+	return {
+		source: "local-private-key",
+		async getAddress() {
+			return toAddress(account.address);
+		},
+		async signUserOpHash(hash) {
+			return account.sign({ hash });
+		}
+	};
+}
+/**
+* Node-aware auth-cache detection. Mirrors the historic default order:
+* 1. Browser localStorage → BrowserAuthCacheAdapter
+* 2. Node.js process → FileSystemAuthCacheAdapter
+*    (`~/.config/capxul/auth-cache.json`)
+* 3. Neither detected → InMemoryAuthCacheAdapter
+*
+* Use this from a Node entrypoint and pass the result to
+* `createCapxulClient({ authCache })` for on-disk session persistence.
+*/
+function detectNodeAuthCacheAdapter(options = {}) {
+	const globalAny = globalThis;
+	if (globalAny.window?.localStorage !== void 0) return new BrowserAuthCacheAdapter(globalAny.window.localStorage);
+	if (globalAny.process?.versions?.node !== void 0) {
+		const authCachePath = normalizeConfiguredAuthCachePath(options.authCachePath) ?? resolveDefaultAuthCachePath(options.resolveHomeDirectory ?? os.homedir);
+		if (authCachePath !== null) return new FileSystemAuthCacheAdapter(authCachePath);
+	}
+	return new InMemoryAuthCacheAdapter();
+}
+function normalizeConfiguredAuthCachePath(path) {
+	if (path === void 0) return null;
+	const trimmed = path.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function resolveDefaultAuthCachePath(resolveHomeDirectory) {
+	try {
+		return join(resolveHomeDirectory(), ".config", "capxul", "auth-cache.json");
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { FileSystemAuthCacheAdapter, FileSystemAuthCacheLayer, detectNodeAuthCacheAdapter, localPrivateKeySigner };
+
+//# sourceMappingURL=index.mjs.map

package/dist/node/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/adapters/auth-cache/FileSystemAuthCacheAdapter.ts","../../src/node/index.ts"],"sourcesContent":["import type * as PlatformError from \"@effect/platform/Error\";\nimport * as PlatformFileSystem from \"@effect/platform/FileSystem\";\nimport * as PlatformPath from \"@effect/platform/Path\";\nimport * as NodeFileSystem from \"@effect/platform-node/NodeFileSystem\";\nimport * as NodePath from \"@effect/platform-node/NodePath\";\nimport { Effect, Layer } from \"effect\";\nimport type { AuthSession } from \"@capxul/types\";\n\nimport {\n  AuthCacheError,\n  AuthCachePortTag,\n  type AuthCachePort,\n  type CachedJwt,\n} from \"../../ports/auth-cache\";\nimport { parseAuthSession, parseCachedJwt } from \"./serialization\";\n\ninterface FilePayload {\n  readonly session: AuthSession | null;\n  readonly jwt: CachedJwt | null;\n}\n\ntype FileSystemRuntime = PlatformFileSystem.FileSystem | PlatformPath.Path;\n\nfunction emptyPayload(): FilePayload {\n  return { session: null, jwt: null };\n}\n\nconst nodeFileSystemRuntime = Layer.merge(NodeFileSystem.layer, NodePath.layer);\n\nexport class FileSystemAuthCacheAdapter implements AuthCachePort {\n  private readonly path: string;\n  private readonly runtime: Layer.Layer<FileSystemRuntime>;\n  readonly getSession: Effect.Effect<AuthSession | null, AuthCacheError>;\n  readonly setSession: (session: AuthSession) => Effect.Effect<void, AuthCacheError>;\n  readonly clearSession: Effect.Effect<void, AuthCacheError>;\n  readonly getJwt: Effect.Effect<CachedJwt | null, AuthCacheError>;\n  readonly setJwt: (jwt: CachedJwt) => Effect.Effect<void, AuthCacheError>;\n  readonly clearJwt: Effect.Effect<void, AuthCacheError>;\n\n  constructor(path: string, runtime: Layer.Layer<FileSystemRuntime> = nodeFileSystemRuntime) {\n    this.path = path;\n    this.runtime = runtime;\n\n    this.getSession = this.run(\n      \"getSession\",\n      this.read().pipe(Effect.map((payload) => payload.session)),\n    );\n    this.setSession = (session: AuthSession) =>\n      this.run(\n        \"setSession\",\n        Effect.gen(this, function* () {\n          const cur = yield* this.read();\n          yield* this.write({ session, jwt: cur.jwt });\n        }),\n      );\n    this.clearSession = this.run(\n      \"clearSession\",\n      Effect.gen(this, function* () {\n        const cur = yield* this.read();\n        yield* this.write({ session: null, jwt: cur.jwt });\n      }),\n    );\n    this.getJwt = this.run(\"getJwt\", this.read().pipe(Effect.map((payload) => payload.jwt)));\n    this.setJwt = (jwt: CachedJwt) =>\n      this.run(\n        \"setJwt\",\n        Effect.gen(this, function* () {\n          const cur = yield* this.read();\n          yield* this.write({ session: cur.session, jwt });\n        }),\n      );\n    this.clearJwt = this.run(\n      \"clearJwt\",\n      Effect.gen(this, function* () {\n        const cur = yield* this.read();\n        yield* this.write({ session: cur.session, jwt: null });\n      }),\n    );\n  }\n\n  private read(): Effect.Effect<FilePayload, PlatformError.PlatformError, FileSystemRuntime> {\n    return Effect.gen(this, function* () {\n      const fs = yield* PlatformFileSystem.FileSystem;\n      const exists = yield* fs.exists(this.path);\n      if (!exists) return emptyPayload();\n      const raw = yield* fs.readFileString(this.path, \"utf-8\");\n\n      let parsed: unknown;\n      try {\n        parsed = JSON.parse(raw);\n      } catch {\n        return emptyPayload();\n      }\n      if (typeof parsed !== \"object\" || parsed === null || Array.isArray(parsed)) {\n        return emptyPayload();\n      }\n      const payload = parsed as { readonly session?: unknown; readonly jwt?: unknown };\n\n      return {\n        session: parseAuthSession(payload.session),\n        jwt: parseCachedJwt(payload.jwt),\n      };\n    });\n  }\n\n  private write(\n    payload: FilePayload,\n  ): Effect.Effect<void, PlatformError.PlatformError, FileSystemRuntime> {\n    return Effect.gen(this, function* () {\n      const fs = yield* PlatformFileSystem.FileSystem;\n      const path = yield* PlatformPath.Path;\n      const dir = path.dirname(this.path);\n      const dirExists = yield* fs.exists(dir);\n      if (!dirExists) {\n        yield* fs.makeDirectory(dir, { recursive: true, mode: 0o700 });\n      }\n      yield* fs.writeFileString(this.path, JSON.stringify(payload), { mode: 0o600 });\n      yield* fs.chmod(this.path, 0o600);\n    });\n  }\n\n  private run<T>(\n    operation: string,\n    effect: Effect.Effect<T, PlatformError.PlatformError, FileSystemRuntime>,\n  ): Effect.Effect<T, AuthCacheError> {\n    return effect.pipe(\n      Effect.mapError((cause) => toAuthCacheError(operation, cause)),\n      Effect.provide(this.runtime),\n    );\n  }\n}\n\nexport function FileSystemAuthCacheLayer(input: {\n  readonly path: string;\n  readonly runtime?: Layer.Layer<FileSystemRuntime>;\n}): Layer.Layer<AuthCachePortTag, AuthCacheError> {\n  return Layer.effect(\n    AuthCachePortTag,\n    Effect.sync(() => new FileSystemAuthCacheAdapter(input.path, input.runtime)).pipe(\n      Effect.mapError((cause) => toAuthCacheError(\"initialize\", cause)),\n    ),\n  );\n}\n\nfunction toAuthCacheError(operation: string, cause: unknown): AuthCacheError {\n  return new AuthCacheError({ operation, cause });\n}\n","// `@capxul/sdk/node` — node-only entry (published-package-boundaries.md).\n//\n// The default `@capxul/sdk` entry is browser-clean: it never statically reaches\n// `@effect/platform-node`. Node consumers import the on-disk auth cache and the\n// node key `CapxulSigner` from here.\n\nimport * as os from \"node:os\";\nimport { join } from \"node:path\";\n\nimport { toAddress } from \"@capxul/types\";\nimport { privateKeyToAccount } from \"viem/accounts\";\nimport type { Hex } from \"viem\";\n\nimport { BrowserAuthCacheAdapter } from \"../adapters/auth-cache/BrowserAuthCacheAdapter\";\nimport { FileSystemAuthCacheAdapter } from \"../adapters/auth-cache/FileSystemAuthCacheAdapter\";\nimport { InMemoryAuthCacheAdapter } from \"../adapters/auth-cache/InMemoryAuthCacheAdapter\";\nimport type { WindowLike } from \"../client/window-like\";\nimport type { AuthCachePort } from \"../ports/auth-cache\";\nimport type { CapxulSigner } from \"../signer\";\n\nexport {\n  FileSystemAuthCacheAdapter,\n  FileSystemAuthCacheLayer,\n} from \"../adapters/auth-cache/FileSystemAuthCacheAdapter\";\n\nexport interface DetectNodeAuthCacheAdapterOptions {\n  readonly authCachePath?: string;\n  readonly resolveHomeDirectory?: () => string;\n}\n\n/**\n * Node `CapxulSigner` backed by a raw private key. Signs the EIP-712 `SafeOp`\n * digest the backend returns for a prepared deployment UserOperation. The\n * reference CLI builds this from `DEPLOYER_PRIVATE_KEY` for the live capstone.\n */\nexport function localPrivateKeySigner(input: { readonly privateKey: Hex }): CapxulSigner {\n  const account = privateKeyToAccount(input.privateKey);\n  return {\n    source: \"local-private-key\",\n    async getAddress() {\n      return toAddress(account.address);\n    },\n    async signUserOpHash(hash: Hex): Promise<Hex> {\n      // `sign({ hash })` signs the already-computed SafeOp digest directly.\n      // `signMessage({ message: { raw: hash } })` would add an EIP-191 prefix.\n      return account.sign({ hash });\n    },\n  };\n}\n\n/**\n * Node-aware auth-cache detection. Mirrors the historic default order:\n * 1. Browser localStorage → BrowserAuthCacheAdapter\n * 2. Node.js process → FileSystemAuthCacheAdapter\n *    (`~/.config/capxul/auth-cache.json`)\n * 3. Neither detected → InMemoryAuthCacheAdapter\n *\n * Use this from a Node entrypoint and pass the result to\n * `createCapxulClient({ authCache })` for on-disk session persistence.\n */\nexport function detectNodeAuthCacheAdapter(\n  options: DetectNodeAuthCacheAdapterOptions = {},\n): AuthCachePort {\n  const globalAny = globalThis as unknown as {\n    readonly window?: WindowLike;\n    readonly process?: { readonly versions?: { readonly node?: string } };\n  };\n  if (globalAny.window?.localStorage !== undefined) {\n    return new BrowserAuthCacheAdapter(globalAny.window.localStorage);\n  }\n  if (globalAny.process?.versions?.node !== undefined) {\n    const authCachePath =\n      normalizeConfiguredAuthCachePath(options.authCachePath) ??\n      resolveDefaultAuthCachePath(options.resolveHomeDirectory ?? os.homedir);\n    if (authCachePath !== null) return new FileSystemAuthCacheAdapter(authCachePath);\n  }\n  return new InMemoryAuthCacheAdapter();\n}\n\nfunction normalizeConfiguredAuthCachePath(path: string | undefined): string | null {\n  if (path === undefined) return null;\n  const trimmed = path.trim();\n  return trimmed.length > 0 ? trimmed : null;\n}\n\nfunction resolveDefaultAuthCachePath(resolveHomeDirectory: () => string): string | null {\n  try {\n    return join(resolveHomeDirectory(), \".config\", \"capxul\", \"auth-cache.json\");\n  } catch {\n    return null;\n  }\n}\n"],"mappings":"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"}

package/dist/ports/safe-deployment.d.mts

@@ -0,0 +1,2 @@
+import { a as SafeDeploymentEvidence, c as SafeDeploymentPortTag, i as SafeDeploymentError, l as safeDeploymentErrorFromCapxul, n as SafeDeploymentConfig, o as SafeDeploymentInput, r as SafeDeploymentDeployedQuery, s as SafeDeploymentPort, t as PreparedSafeAccount } from "../safe-deployment-Vni46k3t.mjs";
+export { PreparedSafeAccount, SafeDeploymentConfig, SafeDeploymentDeployedQuery, SafeDeploymentError, SafeDeploymentEvidence, SafeDeploymentInput, SafeDeploymentPort, SafeDeploymentPortTag, safeDeploymentErrorFromCapxul };

package/dist/ports/safe-deployment.mjs

@@ -0,0 +1,38 @@
+import { Context, Data } from "effect";
+//#region src/ports/safe-deployment.ts
+/**
+* Typed error for SafeDeploymentPort operations. Mirrors the shape used
+* by `SmartAccountError` (see `ports/smart-account.ts`) so the two
+* domain ports compose uniformly into the deploy slice (#161).
+*/
+var SafeDeploymentError = class extends Data.TaggedError("SafeDeploymentError") {};
+/**
+* Wrap a `CapxulError` as a `SafeDeploymentError`. Adapter helper —
+* used at every failure boundary inside a `SafeDeploymentPort` method
+* to preserve the operation that failed alongside the typed public
+* error.
+*
+* Mirrors the `smartAccountErrorFromCapxul` helper on `SmartAccountPort`
+* — both ports follow the same Effect-native pattern: tagged port-error
+* carries `operation` + `publicCode` + `publicError`, and the helper
+* keeps `details` optional so the call site doesn't have to.
+*
+* @param operation - The port method that failed (e.g. `"deploy"`)
+* @param error - The originating `CapxulError`
+* @param cause - Underlying cause; defaults to `error` itself
+* @returns A `SafeDeploymentError` ready to throw via `Effect.fail`
+*/
+function safeDeploymentErrorFromCapxul(operation, error, cause = error) {
+	return new SafeDeploymentError({
+		operation,
+		publicCode: error.code,
+		publicError: error,
+		cause,
+		...error.details === void 0 ? {} : { details: error.details }
+	});
+}
+var SafeDeploymentPortTag = class extends Context.Tag("@capxul/sdk/ports/SafeDeploymentPort")() {};
+//#endregion
+export { SafeDeploymentError, SafeDeploymentPortTag, safeDeploymentErrorFromCapxul };
+
+//# sourceMappingURL=safe-deployment.mjs.map

package/dist/ports/safe-deployment.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-deployment.mjs","names":[],"sources":["../../src/ports/safe-deployment.ts"],"sourcesContent":["import { Context, Data, Effect } from \"effect\";\nimport type { Account } from \"viem\";\n\nimport type { CapxulError, CapxulErrorCode, CapxulErrorDetails } from \"@capxul/config\";\nimport type { Address, BlockNumber, ChainId, DurationMs, Email, TxHash } from \"@capxul/types\";\n\n/**\n * Configuration for a Safe deployment: the chain + RPC endpoint +\n * gas-sponsorship policy the adapter should use.\n *\n * `receiptTimeoutMs` is optional; the production adapter applies a\n * default when omitted. The in-memory adapter ignores it.\n */\nexport type SafeDeploymentConfig = {\n  readonly chainId: ChainId;\n  readonly rpcUrl: string;\n  readonly gasPolicyId: string;\n  readonly receiptTimeoutMs?: DurationMs;\n};\n\n/**\n * Result of `prepare`: the counterfactual Safe address derived from\n * `(signerAddress, email)` without any on-chain side effect.\n */\nexport type PreparedSafeAccount = {\n  readonly chainId: ChainId;\n  readonly signerAddress: Address;\n  readonly safeAddress: Address;\n};\n\n/**\n * Evidence of a successful Safe deployment.\n *\n * Every field except `chainId` / `signerAddress` / `safeAddress` is\n * optional because the AC8 precheck short-circuit path (Safe already\n * on-chain at this address; off-chain receipt evidence unavailable)\n * calls the persistence step WITHOUT a `userOpHash`, `txHash`, or\n * `blockNumber` — there is no recoverable transaction. Aaron's rule:\n * \"If there is no TX and it hasn't been deployed then there shouldn't\n * be a hash.\" End-to-end nullable: `v.optional(v.string())` in the\n * backend schema.\n *\n * **`deployedAt` is NOT a field on this type.** The SDK is never the\n * oracle for `deployedAt`. The backend (`confirmDeployment` action —\n * Convex mutations cannot `fetch`, so the chain re-verification lives\n * in an action) derives it from on-chain data — `eth_getUserOperationReceipt`\n * for the real-userOp path or `eth_getLogs` for the precheck path —\n * then resolves the receipt block's timestamp via `eth_getBlockByNumber`.\n * See `docs/canon/ports/smart-account.md` for the γ-B trust-model\n * section.\n */\nexport type SafeDeploymentEvidence = {\n  readonly chainId: ChainId;\n  readonly signerAddress: Address;\n  readonly safeAddress: Address;\n  readonly txHash?: TxHash;\n  readonly userOpHash?: TxHash;\n  readonly blockNumber?: BlockNumber;\n};\n\nexport type SafeDeploymentInput = {\n  readonly signer: Account;\n  readonly email: Email;\n  readonly config: SafeDeploymentConfig;\n};\n\nexport type SafeDeploymentDeployedQuery = {\n  readonly safeAddress: Address;\n  readonly config: SafeDeploymentConfig;\n};\n\n/**\n * Typed error for SafeDeploymentPort operations. Mirrors the shape used\n * by `SmartAccountError` (see `ports/smart-account.ts`) so the two\n * domain ports compose uniformly into the deploy slice (#161).\n */\nexport class SafeDeploymentError extends Data.TaggedError(\"SafeDeploymentError\")<{\n  readonly operation: string;\n  readonly publicCode: CapxulErrorCode;\n  readonly publicError: CapxulError;\n  readonly cause: unknown;\n  readonly details?: CapxulErrorDetails;\n}> {}\n\n/**\n * Wrap a `CapxulError` as a `SafeDeploymentError`. Adapter helper —\n * used at every failure boundary inside a `SafeDeploymentPort` method\n * to preserve the operation that failed alongside the typed public\n * error.\n *\n * Mirrors the `smartAccountErrorFromCapxul` helper on `SmartAccountPort`\n * — both ports follow the same Effect-native pattern: tagged port-error\n * carries `operation` + `publicCode` + `publicError`, and the helper\n * keeps `details` optional so the call site doesn't have to.\n *\n * @param operation - The port method that failed (e.g. `\"deploy\"`)\n * @param error - The originating `CapxulError`\n * @param cause - Underlying cause; defaults to `error` itself\n * @returns A `SafeDeploymentError` ready to throw via `Effect.fail`\n */\nexport function safeDeploymentErrorFromCapxul(\n  operation: string,\n  error: CapxulError,\n  cause: unknown = error,\n): SafeDeploymentError {\n  return new SafeDeploymentError({\n    operation,\n    publicCode: error.code,\n    publicError: error,\n    cause,\n    ...(error.details === undefined ? {} : { details: error.details }),\n  });\n}\n\n/**\n * Domain port for off-chain + on-chain Safe lifecycle operations.\n *\n * Sibling to `SmartAccountPort` (the Convex-side aggregate). The deploy\n * slice (#161) composes both: `SafeDeploymentPort.deploy` to mint a Safe\n * on-chain, then `SmartAccountPort.confirmDeployment` to persist\n * evidence to Convex. `confirmDeployment` is NOT on this port — that\n * would couple persistence into chain-execution.\n *\n * NOT a member of `PlatformPorts` — domain ports are composed by\n * consumers per the hexagonal Option C decision. See\n * `docs/canon/ports/smart-account.md` for the precedent.\n */\nexport interface SafeDeploymentPort {\n  /**\n   * Off-chain derivation only: compute the counterfactual Safe address\n   * for `(signer, email)`. Pure — no I/O, no state mutation.\n   */\n  prepare(\n    input: SafeDeploymentInput,\n  ): Effect.Effect<PreparedSafeAccount, SafeDeploymentError, never>;\n\n  /**\n   * Deploy the Safe on-chain via the bundler + paymaster (production)\n   * or simulate the deployment in memory (testing). Idempotent on\n   * `(signer, email)` — repeated calls produce the same `safeAddress`.\n   */\n  deploy(\n    input: SafeDeploymentInput,\n  ): Effect.Effect<SafeDeploymentEvidence, SafeDeploymentError, never>;\n\n  /**\n   * Returns true if `safeAddress` is already deployed on-chain\n   * (`extcodesize > 0`). Used by `client._internal.account.deploySafe`\n   * to short-circuit the deploy path when a partial-failure retry would\n   * otherwise submit a second UserOp against an already-deployed Safe\n   * (slice 5B · AC8).\n   */\n  isDeployed(\n    input: SafeDeploymentDeployedQuery,\n  ): Effect.Effect<boolean, SafeDeploymentError, never>;\n}\n\nexport class SafeDeploymentPortTag extends Context.Tag(\"@capxul/sdk/ports/SafeDeploymentPort\")<\n  SafeDeploymentPortTag,\n  SafeDeploymentPort\n>() {}\n"],"mappings":";;;;;;;AA4EA,IAAa,sBAAb,cAAyC,KAAK,YAAY,qBAAqB,EAM5E,CAAC;;;;;;;;;;;;;;;;;AAkBJ,SAAgB,8BACd,WACA,OACA,QAAiB,OACI;CACrB,OAAO,IAAI,oBAAoB;EAC7B;EACA,YAAY,MAAM;EAClB,aAAa;EACb;EACA,GAAI,MAAM,YAAY,KAAA,IAAY,CAAC,IAAI,EAAE,SAAS,MAAM,QAAQ;CAClE,CAAC;AACH;AA6CA,IAAa,wBAAb,cAA2C,QAAQ,IAAI,sCAAsC,EAG3F,EAAE,CAAC"}

package/dist/safe-deployment-Vni46k3t.d.mts

@@ -0,0 +1,137 @@
+import { Context, Effect } from "effect";
+import { CapxulError, CapxulErrorCode, CapxulErrorDetails } from "@capxul/config";
+import { Address, BlockNumber, ChainId, DurationMs, Email, TxHash } from "@capxul/types";
+import { Account as Account$1 } from "viem";
+
+//#region src/ports/safe-deployment.d.ts
+/**
+ * Configuration for a Safe deployment: the chain + RPC endpoint +
+ * gas-sponsorship policy the adapter should use.
+ *
+ * `receiptTimeoutMs` is optional; the production adapter applies a
+ * default when omitted. The in-memory adapter ignores it.
+ */
+type SafeDeploymentConfig = {
+  readonly chainId: ChainId;
+  readonly rpcUrl: string;
+  readonly gasPolicyId: string;
+  readonly receiptTimeoutMs?: DurationMs;
+};
+/**
+ * Result of `prepare`: the counterfactual Safe address derived from
+ * `(signerAddress, email)` without any on-chain side effect.
+ */
+type PreparedSafeAccount = {
+  readonly chainId: ChainId;
+  readonly signerAddress: Address;
+  readonly safeAddress: Address;
+};
+/**
+ * Evidence of a successful Safe deployment.
+ *
+ * Every field except `chainId` / `signerAddress` / `safeAddress` is
+ * optional because the AC8 precheck short-circuit path (Safe already
+ * on-chain at this address; off-chain receipt evidence unavailable)
+ * calls the persistence step WITHOUT a `userOpHash`, `txHash`, or
+ * `blockNumber` — there is no recoverable transaction. Aaron's rule:
+ * "If there is no TX and it hasn't been deployed then there shouldn't
+ * be a hash." End-to-end nullable: `v.optional(v.string())` in the
+ * backend schema.
+ *
+ * **`deployedAt` is NOT a field on this type.** The SDK is never the
+ * oracle for `deployedAt`. The backend (`confirmDeployment` action —
+ * Convex mutations cannot `fetch`, so the chain re-verification lives
+ * in an action) derives it from on-chain data — `eth_getUserOperationReceipt`
+ * for the real-userOp path or `eth_getLogs` for the precheck path —
+ * then resolves the receipt block's timestamp via `eth_getBlockByNumber`.
+ * See `docs/canon/ports/smart-account.md` for the γ-B trust-model
+ * section.
+ */
+type SafeDeploymentEvidence = {
+  readonly chainId: ChainId;
+  readonly signerAddress: Address;
+  readonly safeAddress: Address;
+  readonly txHash?: TxHash;
+  readonly userOpHash?: TxHash;
+  readonly blockNumber?: BlockNumber;
+};
+type SafeDeploymentInput = {
+  readonly signer: Account$1;
+  readonly email: Email;
+  readonly config: SafeDeploymentConfig;
+};
+type SafeDeploymentDeployedQuery = {
+  readonly safeAddress: Address;
+  readonly config: SafeDeploymentConfig;
+};
+declare const SafeDeploymentError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "SafeDeploymentError";
+} & Readonly<A>;
+/**
+ * Typed error for SafeDeploymentPort operations. Mirrors the shape used
+ * by `SmartAccountError` (see `ports/smart-account.ts`) so the two
+ * domain ports compose uniformly into the deploy slice (#161).
+ */
+declare class SafeDeploymentError extends SafeDeploymentError_base<{
+  readonly operation: string;
+  readonly publicCode: CapxulErrorCode;
+  readonly publicError: CapxulError;
+  readonly cause: unknown;
+  readonly details?: CapxulErrorDetails;
+}> {}
+/**
+ * Wrap a `CapxulError` as a `SafeDeploymentError`. Adapter helper —
+ * used at every failure boundary inside a `SafeDeploymentPort` method
+ * to preserve the operation that failed alongside the typed public
+ * error.
+ *
+ * Mirrors the `smartAccountErrorFromCapxul` helper on `SmartAccountPort`
+ * — both ports follow the same Effect-native pattern: tagged port-error
+ * carries `operation` + `publicCode` + `publicError`, and the helper
+ * keeps `details` optional so the call site doesn't have to.
+ *
+ * @param operation - The port method that failed (e.g. `"deploy"`)
+ * @param error - The originating `CapxulError`
+ * @param cause - Underlying cause; defaults to `error` itself
+ * @returns A `SafeDeploymentError` ready to throw via `Effect.fail`
+ */
+declare function safeDeploymentErrorFromCapxul(operation: string, error: CapxulError, cause?: unknown): SafeDeploymentError;
+/**
+ * Domain port for off-chain + on-chain Safe lifecycle operations.
+ *
+ * Sibling to `SmartAccountPort` (the Convex-side aggregate). The deploy
+ * slice (#161) composes both: `SafeDeploymentPort.deploy` to mint a Safe
+ * on-chain, then `SmartAccountPort.confirmDeployment` to persist
+ * evidence to Convex. `confirmDeployment` is NOT on this port — that
+ * would couple persistence into chain-execution.
+ *
+ * NOT a member of `PlatformPorts` — domain ports are composed by
+ * consumers per the hexagonal Option C decision. See
+ * `docs/canon/ports/smart-account.md` for the precedent.
+ */
+interface SafeDeploymentPort {
+  /**
+   * Off-chain derivation only: compute the counterfactual Safe address
+   * for `(signer, email)`. Pure — no I/O, no state mutation.
+   */
+  prepare(input: SafeDeploymentInput): Effect.Effect<PreparedSafeAccount, SafeDeploymentError, never>;
+  /**
+   * Deploy the Safe on-chain via the bundler + paymaster (production)
+   * or simulate the deployment in memory (testing). Idempotent on
+   * `(signer, email)` — repeated calls produce the same `safeAddress`.
+   */
+  deploy(input: SafeDeploymentInput): Effect.Effect<SafeDeploymentEvidence, SafeDeploymentError, never>;
+  /**
+   * Returns true if `safeAddress` is already deployed on-chain
+   * (`extcodesize > 0`). Used by `client._internal.account.deploySafe`
+   * to short-circuit the deploy path when a partial-failure retry would
+   * otherwise submit a second UserOp against an already-deployed Safe
+   * (slice 5B · AC8).
+   */
+  isDeployed(input: SafeDeploymentDeployedQuery): Effect.Effect<boolean, SafeDeploymentError, never>;
+}
+declare const SafeDeploymentPortTag_base: Context.TagClass<SafeDeploymentPortTag, "@capxul/sdk/ports/SafeDeploymentPort", SafeDeploymentPort>;
+declare class SafeDeploymentPortTag extends SafeDeploymentPortTag_base {}
+//#endregion
+export { SafeDeploymentEvidence as a, SafeDeploymentPortTag as c, SafeDeploymentError as i, safeDeploymentErrorFromCapxul as l, SafeDeploymentConfig as n, SafeDeploymentInput as o, SafeDeploymentDeployedQuery as r, SafeDeploymentPort as s, PreparedSafeAccount as t };
+//# sourceMappingURL=safe-deployment-Vni46k3t.d.mts.map

package/dist/safe-deployment-Vni46k3t.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-deployment-Vni46k3t.d.mts","names":[],"sources":["../src/ports/safe-deployment.ts"],"mappings":";;;;;;;;AAaA;;;;;KAAY,oBAAA;EAAA,SACD,OAAA,EAAS,OAAA;EAAA,SACT,MAAA;EAAA,SACA,WAAA;EAAA,SACA,gBAAA,GAAmB,UAAU;AAAA;AAAA;AAOxC;;;AAPwC,KAO5B,mBAAA;EAAA,SACD,OAAA,EAAS,OAAA;EAAA,SACT,aAAA,EAAe,OAAA;EAAA,SACf,WAAA,EAAa,OAAA;AAAA;;;;;;;;AAAO;AAwB/B;;;;;;;;;;;;;KAAY,sBAAA;EAAA,SACD,OAAA,EAAS,OAAA;EAAA,SACT,aAAA,EAAe,OAAA;EAAA,SACf,WAAA,EAAa,OAAA;EAAA,SACb,MAAA,GAAS,MAAA;EAAA,SACT,UAAA,GAAa,MAAA;EAAA,SACb,WAAA,GAAc,WAAA;AAAA;AAAA,KAGb,mBAAA;EAAA,SACD,MAAA,EAAQ,SAAA;EAAA,SACR,KAAA,EAAO,KAAA;EAAA,SACP,MAAA,EAAQ,oBAAA;AAAA;AAAA,KAGP,2BAAA;EAAA,SACD,WAAA,EAAa,OAAA;EAAA,SACb,MAAA,EAAQ,oBAAoB;AAAA;AAAA,cACrC,wBAAA;;;;;;;;cAOW,mBAAA,SAA4B,wBAAA;EAAA,SAC9B,SAAA;EAAA,SACA,UAAA,EAAY,eAAA;EAAA,SACZ,WAAA,EAAa,WAAA;EAAA,SACb,KAAA;EAAA,SACA,OAAA,GAAU,kBAAA;AAAA;;;;;AAbkB;AACrC;;;;;;;;;;;iBA+Bc,6BAAA,CACd,SAAA,UACA,KAAA,EAAO,WAAA,EACP,KAAA,aACC,mBAAmB;;;;;;;;;;;;;;UAuBL,kBAAA;;;;AAnDjB;EAwDE,OAAA,CACE,KAAA,EAAO,mBAAA,GACN,MAAA,CAAO,MAAA,CAAO,mBAAA,EAAqB,mBAAA;;;;;;EAOtC,MAAA,CACE,KAAA,EAAO,mBAAA,GACN,MAAA,CAAO,MAAA,CAAO,sBAAA,EAAwB,mBAAA;EAnEF;;;;;;;EA4EvC,UAAA,CACE,KAAA,EAAO,2BAAA,GACN,MAAA,CAAO,MAAA,UAAgB,mBAAA;AAAA;AAAA,cAC3B,0BAAA;cAEY,qBAAA,SAA8B,0BAGxC"}

package/dist/signer-oaYGfjDe.d.mts

@@ -0,0 +1,142 @@
+import { Context, Effect } from "effect";
+import { Address, AuthSession, EpochSeconds, JwtToken, Profile, SmartAccount } from "@capxul/types";
+import { Account as Account$1, Hex } from "viem";
+
+//#region src/ports/auth-cache.d.ts
+/**
+ * AuthCachePort (TA4) — replaces `SessionStoragePort` in the rebuild slice's
+ * consumer-facing wiring. Stores the user-snapshot Session AND the cached
+ * Convex JWT (W7 bridge endpoint). The two slots are independent so a session
+ * refresh doesn't invalidate the JWT and vice versa.
+ *
+ * Three adapters (TA7):
+ *   - `BrowserAuthCacheAdapter`        — backed by `localStorage`
+ *   - `FileSystemAuthCacheAdapter`     — mode-0600 JSON file in `~/.config/capxul/`
+ *   - `InMemoryAuthCacheAdapter`       — for tests
+ *
+ * `SessionStoragePort` was retired by the Stage 4 rebuild; session and JWT
+ * persistence now share this cache boundary.
+ */
+interface AuthCachePort {
+  readonly getSession: Effect.Effect<AuthSession | null, AuthCacheError>;
+  readonly setSession: (session: AuthSession) => Effect.Effect<void, AuthCacheError>;
+  readonly clearSession: Effect.Effect<void, AuthCacheError>;
+  /**
+   * JWT cache for the `/api/auth/convex/token` bridge endpoint (W7).
+   * Stored separately from the session so a session refresh doesn't
+   * invalidate cached JWT.
+   */
+  readonly getJwt: Effect.Effect<CachedJwt | null, AuthCacheError>;
+  readonly setJwt: (jwt: CachedJwt) => Effect.Effect<void, AuthCacheError>;
+  readonly clearJwt: Effect.Effect<void, AuthCacheError>;
+}
+/**
+ * Cached Convex JWT shape (TA4). `expEpochSeconds` is decoded from the JWT's
+ * `exp` claim at fetch time so the `tokenProvider` cache eviction logic can
+ * proactively refresh at `exp - 30s` per TA3.
+ */
+interface CachedJwt {
+  readonly token: JwtToken;
+  readonly expEpochSeconds: EpochSeconds;
+}
+declare const AuthCacheError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "AuthCacheError";
+} & Readonly<A>;
+declare class AuthCacheError extends AuthCacheError_base<{
+  readonly operation: string;
+  readonly cause: unknown;
+}> {}
+declare const AuthCachePortTag_base: Context.TagClass<AuthCachePortTag, "@capxul/sdk/ports/AuthCachePort", AuthCachePort>;
+declare class AuthCachePortTag extends AuthCachePortTag_base {}
+//#endregion
+//#region src/client/types.d.ts
+type Session = AuthSession;
+type Profile$1 = Profile;
+type SmartAccount$1 = SmartAccount;
+/**
+ * Result-shape returned by every method on `CapxulClient`. Mirrors the
+ * existing per-port `Result` aliases; centralized here so consumers have
+ * a single import for the consumer-facing surface.
+ */
+type CapxulResult<T> = {
+  readonly ok: true;
+  readonly value: T;
+} | {
+  readonly ok: false;
+  readonly error: import("@capxul/config").CapxulError;
+};
+//#endregion
+//#region src/client/account-providers.d.ts
+type AccountProviderSource = "local-private-key" | "openfort-embedded" | "injected-eip1193";
+type AccountRequirement = "none" | "counterfactual" | "deployed";
+interface AccountProvider {
+  readonly source: AccountProviderSource;
+  /**
+   * Resolve the signer's EVM address.
+   *
+   * @determinism MUST return the same `Address` across calls for the
+   * lifetime of a single provider instance — the SDK-level deploy mutex
+   * keys on `(authUserId, safeAddress)` where `safeAddress` is computed
+   * from `getAddress()`'s result before the port's `prepare()` round-trip.
+   * If two successive calls returned different addresses, concurrent
+   * `deploySafe` invocations would compute different mutex keys and
+   * bypass dedup, defeating the mutex.
+   *
+   * The three sanctioned providers all satisfy this invariant:
+   *   - `localPrivateKeyAccountProvider` — derives once from the key
+   *   - `eip1193AccountProvider` — reads `eth_accounts` (idempotent once
+   *     the wallet is connected; consumer is responsible for connection)
+   *   - `openfortEmbeddedAccountProvider` — fetches once, caches
+   *
+   * Custom providers MUST honor this contract.
+   */
+  getAddress(): Promise<CapxulResult<Address>>;
+  getDeployAccount(): Promise<CapxulResult<Account$1>>;
+}
+interface Eip1193Provider {
+  request(args: {
+    readonly method: string;
+    readonly params?: readonly unknown[];
+  }): Promise<unknown>;
+}
+declare function localPrivateKeyAccountProvider(input: {
+  readonly privateKey: Hex;
+}): AccountProvider;
+declare function eip1193AccountProvider(input: {
+  readonly provider: Eip1193Provider;
+}): AccountProvider;
+declare function openfortEmbeddedAccountProvider(): AccountProvider;
+//#endregion
+//#region src/signer.d.ts
+interface CapxulSigner {
+  /**
+   * Signer kind — surfaced on the `accountProviderReady` status so the
+   * readiness ladder reports which signer the consumer wired.
+   */
+  readonly source: AccountProviderSource;
+  /** Owner EOA address — the Safe's single owner. */
+  getAddress(): Promise<Address>;
+  /**
+   * Sign the EIP-712 `SafeOp` digest the backend returns for the prepared
+   * deployment UserOperation. Returns the raw 65-byte ECDSA signature; the
+   * backend packs `validAfter|validUntil|signature`.
+   */
+  signUserOpHash(hash: Hex): Promise<Hex>;
+}
+/** Minimal EIP-1193 surface an injected browser wallet exposes. */
+interface Eip1193RequestProvider {
+  request(args: {
+    readonly method: string;
+    readonly params?: readonly unknown[];
+  }): Promise<unknown>;
+}
+/**
+ * Browser `CapxulSigner` backed by an injected EIP-1193 wallet (MetaMask, etc.).
+ * Signs the SafeOp digest via `eth_sign` (raw-hash signing). The node key signer
+ * lives in `@capxul/sdk/node` (`localPrivateKeySigner`). Wallets that disable
+ * `eth_sign` must enable raw-hash signing before deployed-account flows run.
+ */
+declare function injectedWalletSigner(provider: Eip1193RequestProvider): CapxulSigner;
+//#endregion
+export { AuthCachePortTag as _, AccountProviderSource as a, eip1193AccountProvider as c, CapxulResult as d, Profile$1 as f, AuthCachePort as g, AuthCacheError as h, AccountProvider as i, localPrivateKeyAccountProvider as l, SmartAccount$1 as m, Eip1193RequestProvider as n, AccountRequirement as o, Session as p, injectedWalletSigner as r, Eip1193Provider as s, CapxulSigner as t, openfortEmbeddedAccountProvider as u, CachedJwt as v };
+//# sourceMappingURL=signer-oaYGfjDe.d.mts.map

package/dist/signer-oaYGfjDe.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer-oaYGfjDe.d.mts","names":[],"sources":["../src/ports/auth-cache.ts","../src/client/types.ts","../src/client/account-providers.ts","../src/signer.ts"],"mappings":";;;;;;;;AAiBA;;;;;;;;;;;UAAiB,aAAA;EAAA,SACN,UAAA,EAAY,MAAA,CAAO,MAAA,CAAO,WAAA,SAAoB,cAAA;EAAA,SAC9C,UAAA,GAAa,OAAA,EAAS,WAAA,KAAgB,MAAA,CAAO,MAAA,OAAa,cAAA;EAAA,SAC1D,YAAA,EAAc,MAAA,CAAO,MAAA,OAAa,cAAA;EAQc;;;;;EAAA,SADhD,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,SAAkB,cAAA;EAAA,SACxC,MAAA,GAAS,GAAA,EAAK,SAAA,KAAc,MAAA,CAAO,MAAA,OAAa,cAAA;EAAA,SAChD,QAAA,EAAU,MAAA,CAAO,MAAA,OAAa,cAAA;AAAA;;;;;;UAQxB,SAAA;EAAA,SACN,KAAA,EAAO,QAAA;EAAA,SACP,eAAA,EAAiB,YAAY;AAAA;AAAA,cACvC,mBAAA;;;cAEY,cAAA,SAAuB,mBAAA;EAAA,SACzB,SAAA;EAAA,SACA,KAAA;AAAA;AAAA,cACN,qBAAA;cAEQ,gBAAA,SAAyB,qBAGnC;;;KClCS,OAAA,GAAU,WAAW;AAAA,KACrB,SAAA,GAAU,OAAY;AAAA,KACtB,cAAA,GAAe,YAAiB;;ADD5C;;;;KCQY,YAAA;EAAA,SACG,EAAA;EAAA,SAAmB,KAAA,EAAO,CAAC;AAAA;EAAA,SAC3B,EAAA;EAAA,SAAoB,KAAA,2BAAgC,WAAA;AAAA;;;KCpBvD,qBAAA;AAAA,KAEA,kBAAA;AAAA,UAEK,eAAA;EAAA,SACN,MAAA,EAAQ,qBAAA;;;;;;;;;;;;;;;;;;;;EAoBjB,UAAA,IAAc,OAAA,CAAQ,YAAA,CAAa,OAAA;EACnC,gBAAA,IAAoB,OAAA,CAAQ,YAAA,CAAa,SAAA;AAAA;AAAA,UAG1B,eAAA;EACf,OAAA,CAAQ,IAAA;IAAA,SACG,MAAA;IAAA,SACA,MAAA;EAAA,IACP,OAAO;AAAA;AAAA,iBAGG,8BAAA,CAA+B,KAAA;EAAA,SACpC,UAAA,EAAY,GAAA;AAAA,IACnB,eAAe;AAAA,iBAcH,sBAAA,CAAuB,KAAA;EAAA,SAC5B,QAAA,EAAU,eAAA;AAAA,IACjB,eAAe;AAAA,iBA0DH,+BAAA,CAAA,GAAmC,eAAe;;;UCrGjD,YAAA;;AHDjB;;;WGMW,MAAA,EAAQ,qBAAA;EHLsC;EGOvD,UAAA,IAAc,OAAA,CAAQ,OAAA;EHNS;;;;;EGY/B,cAAA,CAAe,IAAA,EAAM,GAAA,GAAM,OAAA,CAAQ,GAAA;AAAA;;UAIpB,sBAAA;EACf,OAAA,CAAQ,IAAA;IAAA,SACG,MAAA;IAAA,SACA,MAAA;EAAA,IACP,OAAO;AAAA;;;;;;;iBASG,oBAAA,CAAqB,QAAA,EAAU,sBAAA,GAAyB,YAAY"}