domainkit 0.2.1 → 0.3.0

package/dist/cloudflare-FDl5q7Dm.d.mts

@@ -1,32 +0,0 @@
-import { X as AsyncOAuthSubjectResolver, ct as AsyncInterface, it as TokenValidation, ot as Value } from "./zone-discovery-BA5I24vu.mjs";
-import { _ as Zone, a as SubjectResolverOptions, d as tokenMethod$1, f as Account, g as Options, h as ListZonesInput, i as OAuthMethodOptions, l as manifest$1, n as CredentialTarget, o as TokenConnectionOptions, p as Fetch, r as OAuthFlowOptions, s as TokenValidatorOptions, u as oauthMethod$1 } from "./index-B1opsgls.mjs";
-import { a as Source, n as Method, t as InteractiveFlow } from "./connection-CEqadXSm.mjs";
-declare namespace cloudflare_auth_d_exports {
-  export { CredentialTarget, OAuthFlowOptions, OAuthMethodOptions, SubjectResolverOptions, TokenValidatorOptions, manifest, oauthFlow, oauthMethod, subjectResolver, tokenConnectionMethod, tokenMethod, tokenValidator };
-}
-declare const manifest: typeof manifest$1;
-declare const oauthMethod: typeof oauthMethod$1;
-declare const tokenMethod: typeof tokenMethod$1;
-declare function subjectResolver(options: SubjectResolverOptions): AsyncOAuthSubjectResolver;
-/** Creates Cloudflare's OAuth implementation for the Promise connection facade. */
-declare function oauthFlow(options: OAuthFlowOptions): InteractiveFlow;
-/** Creates a Cloudflare token method for the Promise connection facade. */
-declare function tokenConnectionMethod(options: TokenConnectionOptions): Extract<Method, {
-  readonly _tag: "Token";
-}>;
-declare function tokenValidator(options: TokenValidatorOptions): (token: Value) => Promise<TokenValidation>;
-declare namespace cloudflare_d_exports {
-  export { Account, cloudflare_auth_d_exports as Auth, Fetch, Interface, ListZonesInput, Options, Zone, discovery, make };
-}
-interface Interface extends AsyncInterface {
-  readonly listAccounts: () => Promise<ReadonlyArray<Account>>;
-  readonly listZones: (input?: ListZonesInput) => Promise<ReadonlyArray<Zone>>;
-  readonly validateToken: () => Promise<TokenValidation>;
-}
-/** Creates a Promise-compatible facade over the Effect-native Cloudflare client. */
-declare function make(options: Options): Interface;
-/** Creates the optional Cloudflare discovery source for Promise consumers. */
-declare function discovery(options: Options): Source;
-//#endregion
-export { cloudflare_auth_d_exports as a, make as i, cloudflare_d_exports as n, discovery as r, Interface as t };
-//# sourceMappingURL=cloudflare-FDl5q7Dm.d.mts.map

package/dist/cloudflare.d.mts

@@ -1,3 +0,0 @@
-import { _ as Zone, f as Account, g as Options, h as ListZonesInput, p as Fetch } from "./index-B1opsgls.mjs";
-import { a as cloudflare_auth_d_exports, i as make, r as discovery, t as Interface } from "./cloudflare-FDl5q7Dm.mjs";
-export { type Account, cloudflare_auth_d_exports as Auth, type Fetch, Interface, type ListZonesInput, type Options, type Zone, discovery, make };

package/dist/cloudflare.mjs

@@ -1,2 +0,0 @@
-import { i as cloudflare_auth_exports, n as discovery, r as make } from "./cloudflare-Bg_p-M2c.mjs";
-export { cloudflare_auth_exports as Auth, discovery, make };

package/dist/connection-BXoSrhZs.mjs

@@ -1,58 +0,0 @@
-import { O as parse, T as Schema$2, k as Error$1 } from "./dns-record-BLeqo56C.mjs";
-import { l as evidenceFor } from "./authorization-CQSKKMrW.mjs";
-import { Effect, Schema } from "effect";
-//#region src/auth/connection.ts
-const Grant = Schema.TaggedUnion({
-	account: {},
-	domains: { domains: Schema.Array(Schema$2) }
-});
-/** An owner-scoped grant bound to one provider authorization. */
-const Schema$1 = Schema.Struct({
-	authorizationId: Schema.String,
-	createdAt: Schema.DateFromString,
-	grant: Grant,
-	id: Schema.String,
-	ownerId: Schema.String
-});
-const decode = Effect.fn("Connection.decode")((input) => Schema.decodeUnknownEffect(Schema$1)(input).pipe(Effect.mapError((cause) => new Error$1({ message: cause.message }))));
-const validate = Effect.fn("Connection.validate")((input) => Schema.decodeUnknownEffect(Schema.toType(Schema$1))(input).pipe(Effect.mapError((cause) => new Error$1({ message: cause.message }))));
-const encode = Schema.encodeSync(Schema$1);
-var AuthorizationError = class extends Schema.TaggedError()("AuthorizationError", {
-	category: Schema.Literal("authorization"),
-	message: Schema.String,
-	operation: Schema.String,
-	retry: Schema.Literals([
-		"never",
-		"after-user-action",
-		"safe",
-		"unknown"
-	])
-}) {};
-const authorizationError = (message, operation) => new AuthorizationError({
-	category: "authorization",
-	message,
-	operation,
-	retry: "after-user-action"
-});
-function assertGrant(connection, authorization, request) {
-	if (connection.authorizationId !== authorization.id || authorization.providerId !== request.providerId || authorization.revocation._tag !== "Active") throw authorizationError("Connection does not grant this provider account", "Connection.assertGrant");
-	if (authorization.expiresAt !== null) {
-		if (Number.isNaN(authorization.expiresAt.getTime())) throw authorizationError("Connection expiration is invalid", "Connection.assertGrant");
-		if (authorization.expiresAt <= (request.now ?? /* @__PURE__ */ new Date())) throw authorizationError("Connection has expired", "Connection.assertGrant");
-	}
-	if (!authorization.requiredCapabilities.includes(request.capability)) throw authorizationError(`Connection lacks the ${request.capability} capability`, "Connection.assertGrant");
-	if (evidenceFor(authorization, request.capability) === void 0) throw authorizationError(`Connection has no evidence for the ${request.capability} capability`, "Connection.assertGrant");
-	let domain;
-	try {
-		domain = parse(request.domain);
-	} catch (cause) {
-		if (cause instanceof Error$1) throw cause;
-		throw new Error$1({ message: cause instanceof Error ? cause.message : String(cause) });
-	}
-	if (connection.grant._tag === "domains" && !connection.grant.domains.includes(domain)) throw authorizationError("Connection does not grant this domain", "Connection.assertGrant");
-	return domain;
-}
-//#endregion
-export { authorizationError as a, validate as c, assertGrant as i, Grant as n, decode as o, Schema$1 as r, encode as s, AuthorizationError as t };
-
-//# sourceMappingURL=connection-BXoSrhZs.mjs.map

package/dist/connection-BXoSrhZs.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"connection-BXoSrhZs.mjs","names":["S","DomainName.Schema","Schema","InvalidInputError","ProviderAuthorization.evidenceFor","DomainName.parse"],"sources":["../src/auth/connection.ts"],"sourcesContent":["import { Effect, Schema as S } from \"effect\";\n\nimport * as DomainName from \"../domain/domain-name.ts\";\nimport { Error as InvalidInputError } from \"../invalid-input.ts\";\nimport type { Value as Secret } from \"./secret.ts\";\nimport type { OAuthMethod } from \"./manifest.ts\";\nimport * as ProviderAuthorization from \"./authorization.ts\";\n\nexport const Grant = S.TaggedUnion({\n  account: {},\n  domains: { domains: S.Array(DomainName.Schema) },\n});\nexport type Grant = typeof Grant.Type;\n\n/** An owner-scoped grant bound to one provider authorization. */\nexport const Schema = S.Struct({\n  authorizationId: S.String,\n  createdAt: S.DateFromString,\n  grant: Grant,\n  id: S.String,\n  ownerId: S.String,\n});\nexport interface Connection extends S.Schema.Type<typeof Schema> {}\n\nexport const decode = Effect.fn(\"Connection.decode\")((input: unknown) =>\n  S.decodeUnknownEffect(Schema)(input).pipe(\n    Effect.mapError((cause) => new InvalidInputError({ message: cause.message })),\n  ),\n);\n\nexport const validate = Effect.fn(\"Connection.validate\")((input: unknown) =>\n  S.decodeUnknownEffect(S.toType(Schema))(input).pipe(\n    Effect.mapError((cause) => new InvalidInputError({ message: cause.message })),\n  ),\n);\n\nexport const encode = S.encodeSync(Schema);\n\nexport interface OAuthContinuation {\n  readonly clientId: string;\n  readonly codeVerifier: Secret;\n  readonly expiresAt: Date;\n  readonly grant: Grant;\n  readonly method: OAuthMethod;\n  readonly ownerId: string;\n  readonly redirectUri: string;\n  readonly stateHash: string;\n  readonly authorizedById: string;\n}\n\nexport interface StoredCredential {\n  readonly accessToken: Secret;\n  readonly refreshToken: Secret | null;\n  readonly tokenType: string;\n}\n\nexport class AuthorizationError extends S.TaggedError<AuthorizationError>()(\"AuthorizationError\", {\n  category: S.Literal(\"authorization\"),\n  message: S.String,\n  operation: S.String,\n  retry: S.Literals([\"never\", \"after-user-action\", \"safe\", \"unknown\"]),\n}) {}\n\nexport const authorizationError = (message: string, operation: string): AuthorizationError =>\n  new AuthorizationError({\n    category: \"authorization\",\n    message,\n    operation,\n    retry: \"after-user-action\",\n  });\n\nexport function assertGrant(\n  connection: Connection,\n  authorization: ProviderAuthorization.ProviderAuthorization,\n  request: {\n    readonly capability: ProviderAuthorization.Capability;\n    readonly domain: string;\n    readonly now?: Date;\n    readonly providerId: string;\n  },\n): DomainName.DomainName {\n  if (\n    connection.authorizationId !== authorization.id ||\n    authorization.providerId !== request.providerId ||\n    authorization.revocation._tag !== \"Active\"\n  ) {\n    throw authorizationError(\n      \"Connection does not grant this provider account\",\n      \"Connection.assertGrant\",\n    );\n  }\n  if (authorization.expiresAt !== null) {\n    if (Number.isNaN(authorization.expiresAt.getTime())) {\n      throw authorizationError(\"Connection expiration is invalid\", \"Connection.assertGrant\");\n    }\n    if (authorization.expiresAt <= (request.now ?? new Date())) {\n      throw authorizationError(\"Connection has expired\", \"Connection.assertGrant\");\n    }\n  }\n  if (!authorization.requiredCapabilities.includes(request.capability)) {\n    throw authorizationError(\n      `Connection lacks the ${request.capability} capability`,\n      \"Connection.assertGrant\",\n    );\n  }\n  if (ProviderAuthorization.evidenceFor(authorization, request.capability) === undefined) {\n    throw authorizationError(\n      `Connection has no evidence for the ${request.capability} capability`,\n      \"Connection.assertGrant\",\n    );\n  }\n  let domain: DomainName.DomainName;\n  try {\n    domain = DomainName.parse(request.domain);\n  } catch (cause) {\n    if (cause instanceof InvalidInputError) throw cause;\n    throw new InvalidInputError({\n      message: cause instanceof Error ? cause.message : String(cause),\n    });\n  }\n  if (connection.grant._tag === \"domains\" && !connection.grant.domains.includes(domain)) {\n    throw authorizationError(\"Connection does not grant this domain\", \"Connection.assertGrant\");\n  }\n  return domain;\n}\n"],"mappings":";;;;AAQA,MAAa,QAAQA,OAAE,YAAY;CACjC,SAAS,CAAC;CACV,SAAS,EAAE,SAASA,OAAE,MAAMC,QAAiB,EAAE;AACjD,CAAC;;AAID,MAAaC,WAASF,OAAE,OAAO;CAC7B,iBAAiBA,OAAE;CACnB,WAAWA,OAAE;CACb,OAAO;CACP,IAAIA,OAAE;CACN,SAASA,OAAE;AACb,CAAC;AAGD,MAAa,SAAS,OAAO,GAAG,mBAAmB,CAAC,EAAE,UACpDA,OAAE,oBAAoBE,QAAM,CAAC,CAAC,KAAK,CAAC,CAAC,KACnC,OAAO,UAAU,UAAU,IAAIC,QAAkB,EAAE,SAAS,MAAM,QAAQ,CAAC,CAAC,CAC9E,CACF;AAEA,MAAa,WAAW,OAAO,GAAG,qBAAqB,CAAC,EAAE,UACxDH,OAAE,oBAAoBA,OAAE,OAAOE,QAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAC7C,OAAO,UAAU,UAAU,IAAIC,QAAkB,EAAE,SAAS,MAAM,QAAQ,CAAC,CAAC,CAC9E,CACF;AAEA,MAAa,SAASH,OAAE,WAAWE,QAAM;AAoBzC,IAAa,qBAAb,cAAwCF,OAAE,YAAgC,CAAC,CAAC,sBAAsB;CAChG,UAAUA,OAAE,QAAQ,eAAe;CACnC,SAASA,OAAE;CACX,WAAWA,OAAE;CACb,OAAOA,OAAE,SAAS;EAAC;EAAS;EAAqB;EAAQ;CAAS,CAAC;AACrE,CAAC,CAAC,CAAC,CAAC;AAEJ,MAAa,sBAAsB,SAAiB,cAClD,IAAI,mBAAmB;CACrB,UAAU;CACV;CACA;CACA,OAAO;AACT,CAAC;AAEH,SAAgB,YACd,YACA,eACA,SAMuB;CACvB,IACE,WAAW,oBAAoB,cAAc,MAC7C,cAAc,eAAe,QAAQ,cACrC,cAAc,WAAW,SAAS,UAElC,MAAM,mBACJ,mDACA,wBACF;CAEF,IAAI,cAAc,cAAc,MAAM;EACpC,IAAI,OAAO,MAAM,cAAc,UAAU,QAAQ,CAAC,GAChD,MAAM,mBAAmB,oCAAoC,wBAAwB;EAEvF,IAAI,cAAc,cAAc,QAAQ,uBAAO,IAAI,KAAK,IACtD,MAAM,mBAAmB,0BAA0B,wBAAwB;CAE/E;CACA,IAAI,CAAC,cAAc,qBAAqB,SAAS,QAAQ,UAAU,GACjE,MAAM,mBACJ,wBAAwB,QAAQ,WAAW,cAC3C,wBACF;CAEF,IAAII,YAAkC,eAAe,QAAQ,UAAU,MAAM,KAAA,GAC3E,MAAM,mBACJ,sCAAsC,QAAQ,WAAW,cACzD,wBACF;CAEF,IAAI;CACJ,IAAI;EACF,SAASC,MAAiB,QAAQ,MAAM;CAC1C,SAAS,OAAO;EACd,IAAI,iBAAiBF,SAAmB,MAAM;EAC9C,MAAM,IAAIA,QAAkB,EAC1B,SAAS,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,EAChE,CAAC;CACH;CACA,IAAI,WAAW,MAAM,SAAS,aAAa,CAAC,WAAW,MAAM,QAAQ,SAAS,MAAM,GAClF,MAAM,mBAAmB,yCAAyC,wBAAwB;CAE5F,OAAO;AACT"}

package/dist/connection-CEqadXSm.d.mts

@@ -1,182 +0,0 @@
-import { A as Connection, B as Capability, C as Aggregate, D as Service, E as Interface, F as assertGrant, M as OAuthContinuation, N as Schema$1, Nt as DomainName, P as StoredCredential, R as encode, T as Error, V as CapabilityEvidence, _ as StartResult, a as Authentication, ct as AsyncInterface, d as Error$1, h as Method$1, j as Grant, k as AuthorizationError, l as Continuation, m as InteractiveStart, ot as Value, p as InteractiveFlow$1, r as Source$1, s as BaseInput, t as Candidate, u as ContinuationStore$1, w as DetachResult } from "./zone-discovery-BA5I24vu.mjs";
-import "./connection-api-DftK7eHo.mjs";
-import { Data, Layer } from "effect";
-declare namespace zone_discovery_d_exports {
-  export { Candidate, Outcome, Source, discover, toEffectSource };
-}
-interface Source {
-  readonly listZones: (name: DomainName) => Promise<ReadonlyArray<Omit<Candidate, "providerId">>>;
-  readonly provider: AsyncInterface;
-}
-type Outcome = {
-  readonly _tag: "NotFound";
-  readonly domain: DomainName;
-} | {
-  readonly _tag: "Resolved";
-  readonly candidate: Candidate;
-} | {
-  readonly _tag: "SelectionRequired";
-  readonly candidates: ReadonlyArray<Candidate>;
-};
-declare function discover(input: {
-  readonly domain: DomainName;
-  readonly sources: ReadonlyArray<Source>;
-}): Promise<Outcome>;
-declare function toEffectSource(source: Source): Source$1;
-declare namespace authorization_lifecycle_d_exports {
-  export { Aggregate, DetachResult, Error, Repository, from, layerFrom, toAsync };
-}
-interface Repository {
-  readonly bind: (authorizationId: string, binding: Connection) => Promise<Aggregate>;
-  readonly connect: (aggregate: Aggregate) => Promise<Aggregate>;
-  readonly detach: (input: {
-    readonly connectionId: string;
-    readonly revoke: (aggregate: Aggregate) => Promise<void>;
-  }) => Promise<DetachResult>;
-  readonly findByProviderAccount: (providerId: string, providerAccountId: string) => Promise<Aggregate | null>;
-  readonly get: (authorizationId: string) => Promise<Aggregate | null>;
-  readonly getByConnectionId: (connectionId: string) => Promise<Aggregate | null>;
-  readonly promoteEvidence: (authorizationId: string, evidence: ReadonlyArray<CapabilityEvidence>) => Promise<Aggregate>;
-  readonly recover: (input: {
-    readonly authorizationId: string;
-    readonly revoke: (aggregate: Aggregate) => Promise<void>;
-  }) => Promise<DetachResult>;
-  readonly rotate: (authorizationId: string, credential: StoredCredential, expiresAt: Date | null) => Promise<Aggregate>;
-}
-declare const layerFrom: (repository: Repository) => Layer.Layer<Service>;
-declare const toAsync: (repository: Interface) => Repository;
-declare const from: (repository: Repository) => Repository;
-declare namespace connection_d_exports {
-  export { Authentication, AuthorizationError, Connection, StartResult as ConnectionStartResult, ContinuationStore, Error$1 as Error, Grant, InteractiveFlow, Method, OAuthContinuation, Schema$1 as Schema, StartResult, StoredCredential, assertGrant, complete, decode, encode, fromEffectFlow, fromEffectTokenMethod, start, toAsyncContinuations };
-}
-declare function decode(input: unknown): Promise<Connection>;
-type Method = Data.TaggedEnum<{
-  Interactive: {
-    readonly continuations: ContinuationStore;
-    readonly flow: InteractiveFlow;
-    readonly ttlMs?: number;
-  };
-  Token: {
-    readonly authenticate: (token: Value) => Promise<Authentication>;
-    readonly providerId: string;
-    readonly requiredCapabilities: ReadonlyArray<Capability>;
-    readonly token: Value;
-  };
-}>;
-declare const Method: {
-  readonly $is: <Tag extends "Interactive" | "Token">(tag: Tag) => (u: unknown) => u is Extract<{
-    readonly _tag: "Interactive";
-    readonly continuations: ContinuationStore;
-    readonly flow: InteractiveFlow;
-    readonly ttlMs?: number;
-  }, {
-    readonly _tag: Tag;
-  }> | Extract<{
-    readonly _tag: "Token";
-    readonly authenticate: (token: Value) => Promise<Authentication>;
-    readonly providerId: string;
-    readonly requiredCapabilities: ReadonlyArray<Capability>;
-    readonly token: Value;
-  }, {
-    readonly _tag: Tag;
-  }>;
-  readonly $match: {
-    <Cases extends { readonly [Tag in "Interactive" | "Token"]: (args: Extract<{
-      readonly _tag: "Interactive";
-      readonly continuations: ContinuationStore;
-      readonly flow: InteractiveFlow;
-      readonly ttlMs?: number;
-    } | {
-      readonly _tag: "Token";
-      readonly authenticate: (token: Value) => Promise<Authentication>;
-      readonly providerId: string;
-      readonly requiredCapabilities: ReadonlyArray<Capability>;
-      readonly token: Value;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(cases: Cases): (value: {
-      readonly _tag: "Interactive";
-      readonly continuations: ContinuationStore;
-      readonly flow: InteractiveFlow;
-      readonly ttlMs?: number;
-    } | {
-      readonly _tag: "Token";
-      readonly authenticate: (token: Value) => Promise<Authentication>;
-      readonly providerId: string;
-      readonly requiredCapabilities: ReadonlyArray<Capability>;
-      readonly token: Value;
-    }) => import("effect/Unify").Unify<ReturnType<Cases["Interactive" | "Token"]>>;
-    <Cases extends { readonly [Tag in "Interactive" | "Token"]: (args: Extract<{
-      readonly _tag: "Interactive";
-      readonly continuations: ContinuationStore;
-      readonly flow: InteractiveFlow;
-      readonly ttlMs?: number;
-    } | {
-      readonly _tag: "Token";
-      readonly authenticate: (token: Value) => Promise<Authentication>;
-      readonly providerId: string;
-      readonly requiredCapabilities: ReadonlyArray<Capability>;
-      readonly token: Value;
-    }, {
-      readonly _tag: Tag;
-    }>) => any; }>(value: {
-      readonly _tag: "Interactive";
-      readonly continuations: ContinuationStore;
-      readonly flow: InteractiveFlow;
-      readonly ttlMs?: number;
-    } | {
-      readonly _tag: "Token";
-      readonly authenticate: (token: Value) => Promise<Authentication>;
-      readonly providerId: string;
-      readonly requiredCapabilities: ReadonlyArray<Capability>;
-      readonly token: Value;
-    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Interactive" | "Token"]>>;
-  };
-  readonly Interactive: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Interactive";
-    readonly continuations: ContinuationStore;
-    readonly flow: InteractiveFlow;
-    readonly ttlMs?: number;
-  }, "_tag">;
-  readonly Token: Data.TaggedEnum.ConstructorFrom<{
-    readonly _tag: "Token";
-    readonly authenticate: (token: Value) => Promise<Authentication>;
-    readonly providerId: string;
-    readonly requiredCapabilities: ReadonlyArray<Capability>;
-    readonly token: Value;
-  }, "_tag">;
-};
-interface ContinuationStore {
-  readonly consume: (id: string, now: Date) => Promise<Continuation | null>;
-  readonly put: (continuation: Continuation) => Promise<void>;
-}
-interface InteractiveFlow {
-  readonly complete: (payload: Value, callbackUrl: URL) => Promise<Authentication>;
-  readonly method: "integration" | "oauth2";
-  readonly providerId: string;
-  readonly requiredCapabilities: ReadonlyArray<Capability>;
-  readonly start: (continuationId: string) => Promise<InteractiveStart>;
-}
-declare const toAsyncContinuations: (store: ContinuationStore$1) => ContinuationStore;
-/** Adapts an Effect-native provider flow to the Promise facade. */
-declare const fromEffectFlow: (flow: InteractiveFlow$1) => InteractiveFlow;
-/** Adapts an Effect-native token method to the Promise facade. */
-declare function fromEffectTokenMethod(method: Extract<Method$1, {
-  readonly _tag: "Token";
-}>): Extract<Method, {
-  readonly _tag: "Token";
-}>;
-declare function start(input: BaseInput & {
-  readonly method: Method;
-  readonly repository: Repository;
-}): Promise<StartResult>;
-declare function complete(input: {
-  readonly callbackUrl: URL;
-  readonly continuationId: string;
-  readonly continuations: ContinuationStore;
-  readonly flow: InteractiveFlow;
-  readonly repository: Repository;
-}): Promise<Aggregate>;
-//#endregion
-export { Source as a, authorization_lifecycle_d_exports as i, Method as n, zone_discovery_d_exports as o, connection_d_exports as r, InteractiveFlow as t };
-//# sourceMappingURL=connection-CEqadXSm.d.mts.map

package/dist/connection-X3rZhrBZ.mjs

@@ -1,186 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { M as Service, j as Error } from "./dns-record-BLeqo56C.mjs";
-import { _ as StartResult, g as Method$1, h as Error$1, v as complete$1, y as start$1 } from "./authorization-CQSKKMrW.mjs";
-import { i as assertGrant, n as Grant, o as decode$1, r as Schema$1, s as encode, t as AuthorizationError } from "./connection-BXoSrhZs.mjs";
-import { i as webCryptoLayer } from "./canonical-json-CpvqGMcr.mjs";
-import { Data, Effect, Layer } from "effect";
-//#region src/promise/authorization-lifecycle.ts
-var authorization_lifecycle_exports = /* @__PURE__ */ __exportAll({
-	Error: () => Error,
-	from: () => from,
-	layerFrom: () => layerFrom,
-	toAsync: () => toAsync
-});
-const failure = (operation, cause) => cause instanceof Error ? cause : new Error({
-	category: "storage",
-	message: cause instanceof globalThis.Error ? cause.message : String(cause),
-	operation,
-	retry: "safe"
-});
-const layerFrom = (repository) => Layer.succeed(Service, {
-	bind: Effect.fn("AuthorizationLifecycleRepository.bind")((authorizationId, binding) => Effect.tryPromise({
-		try: () => repository.bind(authorizationId, binding),
-		catch: (cause) => failure("AuthorizationLifecycleRepository.bind", cause)
-	})),
-	connect: Effect.fn("AuthorizationLifecycleRepository.connect")((aggregate) => Effect.tryPromise({
-		try: () => repository.connect(aggregate),
-		catch: (cause) => failure("AuthorizationLifecycleRepository.connect", cause)
-	})),
-	detach: ({ connectionId, revoke }) => Effect.tryPromise({
-		try: () => repository.detach({
-			connectionId,
-			revoke: (aggregate) => Effect.runPromise(revoke(aggregate))
-		}),
-		catch: (cause) => failure("AuthorizationLifecycleRepository.detach", cause)
-	}),
-	findByProviderAccount: Effect.fn("AuthorizationLifecycleRepository.findByProviderAccount")((providerId, providerAccountId) => Effect.tryPromise({
-		try: () => repository.findByProviderAccount(providerId, providerAccountId),
-		catch: (cause) => failure("AuthorizationLifecycleRepository.findByProviderAccount", cause)
-	})),
-	get: Effect.fn("AuthorizationLifecycleRepository.get")((authorizationId) => Effect.tryPromise({
-		try: () => repository.get(authorizationId),
-		catch: (cause) => failure("AuthorizationLifecycleRepository.get", cause)
-	})),
-	getByConnectionId: Effect.fn("AuthorizationLifecycleRepository.getByConnectionId")((connectionId) => Effect.tryPromise({
-		try: () => repository.getByConnectionId(connectionId),
-		catch: (cause) => failure("AuthorizationLifecycleRepository.getByConnectionId", cause)
-	})),
-	promoteEvidence: Effect.fn("AuthorizationLifecycleRepository.promoteEvidence")((authorizationId, evidence) => Effect.tryPromise({
-		try: () => repository.promoteEvidence(authorizationId, evidence),
-		catch: (cause) => failure("AuthorizationLifecycleRepository.promoteEvidence", cause)
-	})),
-	recover: ({ authorizationId, revoke }) => Effect.tryPromise({
-		try: () => repository.recover({
-			authorizationId,
-			revoke: (aggregate) => Effect.runPromise(revoke(aggregate))
-		}),
-		catch: (cause) => failure("AuthorizationLifecycleRepository.recover", cause)
-	}),
-	rotate: Effect.fn("AuthorizationLifecycleRepository.rotate")((authorizationId, credential, expiresAt) => Effect.tryPromise({
-		try: () => repository.rotate(authorizationId, credential, expiresAt),
-		catch: (cause) => failure("AuthorizationLifecycleRepository.rotate", cause)
-	}))
-});
-const toAsync = (repository) => ({
-	bind: (authorizationId, binding) => Effect.runPromise(repository.bind(authorizationId, binding)),
-	connect: (aggregate) => Effect.runPromise(repository.connect(aggregate)),
-	detach: ({ connectionId, revoke }) => Effect.runPromise(repository.detach({
-		connectionId,
-		revoke: (aggregate) => Effect.tryPromise(() => revoke(aggregate))
-	})),
-	findByProviderAccount: (providerId, providerAccountId) => Effect.runPromise(repository.findByProviderAccount(providerId, providerAccountId)),
-	get: (authorizationId) => Effect.runPromise(repository.get(authorizationId)),
-	getByConnectionId: (connectionId) => Effect.runPromise(repository.getByConnectionId(connectionId)),
-	promoteEvidence: (authorizationId, evidence) => Effect.runPromise(repository.promoteEvidence(authorizationId, evidence)),
-	recover: ({ authorizationId, revoke }) => Effect.runPromise(repository.recover({
-		authorizationId,
-		revoke: (aggregate) => Effect.tryPromise(() => revoke(aggregate))
-	})),
-	rotate: (authorizationId, credential, expiresAt) => Effect.runPromise(repository.rotate(authorizationId, credential, expiresAt))
-});
-const from = (repository) => repository;
-//#endregion
-//#region src/promise/connection.ts
-var connection_exports = /* @__PURE__ */ __exportAll({
-	AuthorizationError: () => AuthorizationError,
-	Error: () => Error$1,
-	Grant: () => Grant,
-	Method: () => Method,
-	Schema: () => Schema$1,
-	StartResult: () => StartResult,
-	assertGrant: () => assertGrant,
-	complete: () => complete,
-	decode: () => decode,
-	encode: () => encode,
-	fromEffectFlow: () => fromEffectFlow,
-	fromEffectTokenMethod: () => fromEffectTokenMethod,
-	start: () => start,
-	toAsyncContinuations: () => toAsyncContinuations
-});
-function decode(input) {
-	return Effect.runPromise(decode$1(input));
-}
-const Method = Data.taggedEnum();
-const connectionFailure = (operation, cause) => cause instanceof Error$1 ? cause : new Error$1({
-	category: "provider",
-	message: cause instanceof globalThis.Error ? cause.message : String(cause),
-	operation,
-	retry: "unknown"
-});
-const effectMethod = (method) => method._tag === "Interactive" ? Method$1.Interactive({
-	continuations: effectContinuations(method.continuations),
-	flow: effectFlow(method.flow),
-	...method.ttlMs === void 0 ? {} : { ttlMs: method.ttlMs }
-}) : Method$1.Token({
-	authenticate: (token) => Effect.tryPromise({
-		try: () => method.authenticate(token),
-		catch: (cause) => connectionFailure("Connection.start", cause)
-	}),
-	providerId: method.providerId,
-	requiredCapabilities: method.requiredCapabilities,
-	token: method.token
-});
-const effectContinuations = (store) => ({
-	consume: (id, now) => Effect.tryPromise({
-		try: () => store.consume(id, now),
-		catch: (cause) => connectionFailure("ConnectionContinuations.consume", cause)
-	}),
-	put: (continuation) => Effect.tryPromise({
-		try: () => store.put(continuation),
-		catch: (cause) => connectionFailure("ConnectionContinuations.put", cause)
-	})
-});
-const toAsyncContinuations = (store) => ({
-	consume: (id, now) => Effect.runPromise(store.consume(id, now)),
-	put: (continuation) => Effect.runPromise(store.put(continuation))
-});
-const effectFlow = (flow) => ({
-	complete: (payload, callbackUrl) => Effect.tryPromise({
-		try: () => flow.complete(payload, callbackUrl),
-		catch: (cause) => connectionFailure("Connection.complete", cause)
-	}),
-	method: flow.method,
-	providerId: flow.providerId,
-	requiredCapabilities: flow.requiredCapabilities,
-	start: (continuationId) => Effect.tryPromise({
-		try: () => flow.start(continuationId),
-		catch: (cause) => connectionFailure("Connection.start", cause)
-	})
-});
-/** Adapts an Effect-native provider flow to the Promise facade. */
-const fromEffectFlow = (flow) => ({
-	complete: (payload, callbackUrl) => Effect.runPromise(flow.complete(payload, callbackUrl)),
-	method: flow.method,
-	providerId: flow.providerId,
-	requiredCapabilities: flow.requiredCapabilities,
-	start: (continuationId) => Effect.runPromise(flow.start(continuationId).pipe(Effect.provide(webCryptoLayer)))
-});
-/** Adapts an Effect-native token method to the Promise facade. */
-function fromEffectTokenMethod(method) {
-	return Method.Token({
-		authenticate: (token) => Effect.runPromise(method.authenticate(token)),
-		providerId: method.providerId,
-		requiredCapabilities: method.requiredCapabilities,
-		token: method.token
-	});
-}
-async function start(input) {
-	return Effect.runPromise(start$1({
-		authorizedById: input.authorizedById,
-		grant: input.grant,
-		method: effectMethod(input.method),
-		ownerId: input.ownerId
-	}).pipe(Effect.provide(Layer.merge(layerFrom(input.repository), webCryptoLayer))));
-}
-async function complete(input) {
-	return Effect.runPromise(complete$1({
-		callbackUrl: input.callbackUrl,
-		continuationId: input.continuationId,
-		continuations: effectContinuations(input.continuations),
-		flow: effectFlow(input.flow)
-	}).pipe(Effect.provide(Layer.merge(layerFrom(input.repository), webCryptoLayer))));
-}
-//#endregion
-export { authorization_lifecycle_exports as i, fromEffectFlow as n, fromEffectTokenMethod as r, connection_exports as t };
-
-//# sourceMappingURL=connection-X3rZhrBZ.mjs.map

package/dist/connection-X3rZhrBZ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"connection-X3rZhrBZ.mjs","names":["Lifecycle.Error","Lifecycle.Service","Connection.decode","Connect.Error","Connect.start","LifecycleRepository.layerFrom","Connect.complete"],"sources":["../src/promise/authorization-lifecycle.ts","../src/promise/connection.ts"],"sourcesContent":["import { Effect, Layer } from \"effect\";\n\nimport type * as ProviderAuthorization from \"../auth/authorization.ts\";\nimport type * as Connection from \"../auth/connection.ts\";\nimport * as Lifecycle from \"../auth/lifecycle-repository.ts\";\n\nexport interface Repository {\n  readonly bind: (\n    authorizationId: string,\n    binding: Connection.Connection,\n  ) => Promise<Lifecycle.Aggregate>;\n  readonly connect: (aggregate: Lifecycle.Aggregate) => Promise<Lifecycle.Aggregate>;\n  readonly detach: (input: {\n    readonly connectionId: string;\n    readonly revoke: (aggregate: Lifecycle.Aggregate) => Promise<void>;\n  }) => Promise<Lifecycle.DetachResult>;\n  readonly findByProviderAccount: (\n    providerId: string,\n    providerAccountId: string,\n  ) => Promise<Lifecycle.Aggregate | null>;\n  readonly get: (authorizationId: string) => Promise<Lifecycle.Aggregate | null>;\n  readonly getByConnectionId: (connectionId: string) => Promise<Lifecycle.Aggregate | null>;\n  readonly promoteEvidence: (\n    authorizationId: string,\n    evidence: ReadonlyArray<ProviderAuthorization.CapabilityEvidence>,\n  ) => Promise<Lifecycle.Aggregate>;\n  readonly recover: (input: {\n    readonly authorizationId: string;\n    readonly revoke: (aggregate: Lifecycle.Aggregate) => Promise<void>;\n  }) => Promise<Lifecycle.DetachResult>;\n  readonly rotate: (\n    authorizationId: string,\n    credential: Connection.StoredCredential,\n    expiresAt: Date | null,\n  ) => Promise<Lifecycle.Aggregate>;\n}\n\nconst failure = (operation: string, cause: unknown): Lifecycle.Error =>\n  cause instanceof Lifecycle.Error\n    ? cause\n    : new Lifecycle.Error({\n        category: \"storage\",\n        message: cause instanceof globalThis.Error ? cause.message : String(cause),\n        operation,\n        retry: \"safe\",\n      });\n\nexport const layerFrom = (repository: Repository): Layer.Layer<Lifecycle.Service> =>\n  Layer.succeed(Lifecycle.Service, {\n    bind: Effect.fn(\"AuthorizationLifecycleRepository.bind\")((authorizationId, binding) =>\n      Effect.tryPromise({\n        try: () => repository.bind(authorizationId, binding),\n        catch: (cause) => failure(\"AuthorizationLifecycleRepository.bind\", cause),\n      }),\n    ),\n    connect: Effect.fn(\"AuthorizationLifecycleRepository.connect\")((aggregate) =>\n      Effect.tryPromise({\n        try: () => repository.connect(aggregate),\n        catch: (cause) => failure(\"AuthorizationLifecycleRepository.connect\", cause),\n      }),\n    ),\n    detach: ({ connectionId, revoke }) =>\n      Effect.tryPromise({\n        try: () =>\n          repository.detach({\n            connectionId,\n            revoke: (aggregate) => Effect.runPromise(revoke(aggregate)),\n          }),\n        catch: (cause) => failure(\"AuthorizationLifecycleRepository.detach\", cause),\n      }),\n    findByProviderAccount: Effect.fn(\"AuthorizationLifecycleRepository.findByProviderAccount\")(\n      (providerId, providerAccountId) =>\n        Effect.tryPromise({\n          try: () => repository.findByProviderAccount(providerId, providerAccountId),\n          catch: (cause) =>\n            failure(\"AuthorizationLifecycleRepository.findByProviderAccount\", cause),\n        }),\n    ),\n    get: Effect.fn(\"AuthorizationLifecycleRepository.get\")((authorizationId) =>\n      Effect.tryPromise({\n        try: () => repository.get(authorizationId),\n        catch: (cause) => failure(\"AuthorizationLifecycleRepository.get\", cause),\n      }),\n    ),\n    getByConnectionId: Effect.fn(\"AuthorizationLifecycleRepository.getByConnectionId\")(\n      (connectionId) =>\n        Effect.tryPromise({\n          try: () => repository.getByConnectionId(connectionId),\n          catch: (cause) => failure(\"AuthorizationLifecycleRepository.getByConnectionId\", cause),\n        }),\n    ),\n    promoteEvidence: Effect.fn(\"AuthorizationLifecycleRepository.promoteEvidence\")(\n      (authorizationId, evidence) =>\n        Effect.tryPromise({\n          try: () => repository.promoteEvidence(authorizationId, evidence),\n          catch: (cause) => failure(\"AuthorizationLifecycleRepository.promoteEvidence\", cause),\n        }),\n    ),\n    recover: ({ authorizationId, revoke }) =>\n      Effect.tryPromise({\n        try: () =>\n          repository.recover({\n            authorizationId,\n            revoke: (aggregate) => Effect.runPromise(revoke(aggregate)),\n          }),\n        catch: (cause) => failure(\"AuthorizationLifecycleRepository.recover\", cause),\n      }),\n    rotate: Effect.fn(\"AuthorizationLifecycleRepository.rotate\")(\n      (authorizationId, credential, expiresAt) =>\n        Effect.tryPromise({\n          try: () => repository.rotate(authorizationId, credential, expiresAt),\n          catch: (cause) => failure(\"AuthorizationLifecycleRepository.rotate\", cause),\n        }),\n    ),\n  });\n\nexport const toAsync = (repository: Lifecycle.Interface): Repository => ({\n  bind: (authorizationId, binding) => Effect.runPromise(repository.bind(authorizationId, binding)),\n  connect: (aggregate) => Effect.runPromise(repository.connect(aggregate)),\n  detach: ({ connectionId, revoke }) =>\n    Effect.runPromise(\n      repository.detach({\n        connectionId,\n        revoke: (aggregate) => Effect.tryPromise(() => revoke(aggregate)),\n      }),\n    ),\n  findByProviderAccount: (providerId, providerAccountId) =>\n    Effect.runPromise(repository.findByProviderAccount(providerId, providerAccountId)),\n  get: (authorizationId) => Effect.runPromise(repository.get(authorizationId)),\n  getByConnectionId: (connectionId) =>\n    Effect.runPromise(repository.getByConnectionId(connectionId)),\n  promoteEvidence: (authorizationId, evidence) =>\n    Effect.runPromise(repository.promoteEvidence(authorizationId, evidence)),\n  recover: ({ authorizationId, revoke }) =>\n    Effect.runPromise(\n      repository.recover({\n        authorizationId,\n        revoke: (aggregate) => Effect.tryPromise(() => revoke(aggregate)),\n      }),\n    ),\n  rotate: (authorizationId, credential, expiresAt) =>\n    Effect.runPromise(repository.rotate(authorizationId, credential, expiresAt)),\n});\n\nexport const from = (repository: Repository): Repository => repository;\n\nexport { Error } from \"../auth/lifecycle-repository.ts\";\nexport type { Aggregate, DetachResult } from \"../auth/lifecycle-repository.ts\";\n","import { Data, Effect, Layer } from \"effect\";\n\nimport * as Connection from \"../auth/connection.ts\";\nimport * as Connect from \"../auth/connect.ts\";\nimport type * as Repository from \"./authorization-lifecycle.ts\";\nimport type * as ProviderAuthorization from \"../auth/authorization.ts\";\nimport { webCryptoLayer } from \"../plan/canonical-json.ts\";\nimport * as LifecycleRepository from \"./authorization-lifecycle.ts\";\nimport type * as Secret from \"../auth/secret.ts\";\n\nexport { assertGrant, AuthorizationError, encode, Grant, Schema } from \"../auth/connection.ts\";\nexport type { Connection, OAuthContinuation, StoredCredential } from \"../auth/connection.ts\";\n\nexport function decode(input: unknown): Promise<Connection.Connection> {\n  return Effect.runPromise(Connection.decode(input));\n}\n\nexport type Method = Data.TaggedEnum<{\n  Interactive: {\n    readonly continuations: ContinuationStore;\n    readonly flow: InteractiveFlow;\n    readonly ttlMs?: number;\n  };\n  Token: {\n    readonly authenticate: (token: Secret.Value) => Promise<Connect.Authentication>;\n    readonly providerId: string;\n    readonly requiredCapabilities: ReadonlyArray<ProviderAuthorization.Capability>;\n    readonly token: Secret.Value;\n  };\n}>;\nexport const Method = Data.taggedEnum<Method>();\n\nexport interface ContinuationStore {\n  readonly consume: (id: string, now: Date) => Promise<Connect.Continuation | null>;\n  readonly put: (continuation: Connect.Continuation) => Promise<void>;\n}\n\nexport interface InteractiveFlow {\n  readonly complete: (payload: Secret.Value, callbackUrl: URL) => Promise<Connect.Authentication>;\n  readonly method: \"integration\" | \"oauth2\";\n  readonly providerId: string;\n  readonly requiredCapabilities: ReadonlyArray<ProviderAuthorization.Capability>;\n  readonly start: (continuationId: string) => Promise<Connect.InteractiveStart>;\n}\n\nconst connectionFailure = (operation: string, cause: unknown): Connect.Error =>\n  cause instanceof Connect.Error\n    ? cause\n    : new Connect.Error({\n        category: \"provider\",\n        message: cause instanceof globalThis.Error ? cause.message : String(cause),\n        operation,\n        retry: \"unknown\",\n      });\n\nconst effectMethod = (method: Method): Connect.Method =>\n  method._tag === \"Interactive\"\n    ? Connect.Method.Interactive({\n        continuations: effectContinuations(method.continuations),\n        flow: effectFlow(method.flow),\n        ...(method.ttlMs === undefined ? {} : { ttlMs: method.ttlMs }),\n      })\n    : Connect.Method.Token({\n        authenticate: (token) =>\n          Effect.tryPromise({\n            try: () => method.authenticate(token),\n            catch: (cause) => connectionFailure(\"Connection.start\", cause),\n          }),\n        providerId: method.providerId,\n        requiredCapabilities: method.requiredCapabilities,\n        token: method.token,\n      });\n\nconst effectContinuations = (store: ContinuationStore): Connect.ContinuationStore => ({\n  consume: (id, now) =>\n    Effect.tryPromise({\n      try: () => store.consume(id, now),\n      catch: (cause) => connectionFailure(\"ConnectionContinuations.consume\", cause),\n    }),\n  put: (continuation) =>\n    Effect.tryPromise({\n      try: () => store.put(continuation),\n      catch: (cause) => connectionFailure(\"ConnectionContinuations.put\", cause),\n    }),\n});\n\nexport const toAsyncContinuations = (store: Connect.ContinuationStore): ContinuationStore => ({\n  consume: (id, now) => Effect.runPromise(store.consume(id, now)),\n  put: (continuation) => Effect.runPromise(store.put(continuation)),\n});\n\nconst effectFlow = (flow: InteractiveFlow): Connect.InteractiveFlow => ({\n  complete: (payload, callbackUrl) =>\n    Effect.tryPromise({\n      try: () => flow.complete(payload, callbackUrl),\n      catch: (cause) => connectionFailure(\"Connection.complete\", cause),\n    }),\n  method: flow.method,\n  providerId: flow.providerId,\n  requiredCapabilities: flow.requiredCapabilities,\n  start: (continuationId) =>\n    Effect.tryPromise({\n      try: () => flow.start(continuationId),\n      catch: (cause) => connectionFailure(\"Connection.start\", cause),\n    }),\n});\n\n/** Adapts an Effect-native provider flow to the Promise facade. */\nexport const fromEffectFlow = (flow: Connect.InteractiveFlow): InteractiveFlow => ({\n  complete: (payload, callbackUrl) => Effect.runPromise(flow.complete(payload, callbackUrl)),\n  method: flow.method,\n  providerId: flow.providerId,\n  requiredCapabilities: flow.requiredCapabilities,\n  start: (continuationId) =>\n    Effect.runPromise(flow.start(continuationId).pipe(Effect.provide(webCryptoLayer))),\n});\n\n/** Adapts an Effect-native token method to the Promise facade. */\nexport function fromEffectTokenMethod(\n  method: Extract<Connect.Method, { readonly _tag: \"Token\" }>,\n): Extract<Method, { readonly _tag: \"Token\" }> {\n  return Method.Token({\n    authenticate: (token) => Effect.runPromise(method.authenticate(token)),\n    providerId: method.providerId,\n    requiredCapabilities: method.requiredCapabilities,\n    token: method.token,\n  });\n}\n\nexport async function start(\n  input: Connect.BaseInput & {\n    readonly method: Method;\n    readonly repository: Repository.Repository;\n  },\n): Promise<Connect.StartResult> {\n  return Effect.runPromise(\n    Connect.start({\n      authorizedById: input.authorizedById,\n      grant: input.grant,\n      method: effectMethod(input.method),\n      ownerId: input.ownerId,\n    }).pipe(\n      Effect.provide(Layer.merge(LifecycleRepository.layerFrom(input.repository), webCryptoLayer)),\n    ),\n  );\n}\n\nexport async function complete(input: {\n  readonly callbackUrl: URL;\n  readonly continuationId: string;\n  readonly continuations: ContinuationStore;\n  readonly flow: InteractiveFlow;\n  readonly repository: Repository.Repository;\n}): Promise<Repository.Aggregate> {\n  return Effect.runPromise(\n    Connect.complete({\n      callbackUrl: input.callbackUrl,\n      continuationId: input.continuationId,\n      continuations: effectContinuations(input.continuations),\n      flow: effectFlow(input.flow),\n    }).pipe(\n      Effect.provide(Layer.merge(LifecycleRepository.layerFrom(input.repository), webCryptoLayer)),\n    ),\n  );\n}\n\nexport { Error, StartResult } from \"../auth/connect.ts\";\nexport type { Authentication, ConnectionStartResult } from \"../auth/connection-api.ts\";\n"],"mappings":"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"}

package/dist/connection-api-DftK7eHo.d.mts

@@ -1,7 +0,0 @@
-import { A as Connection, F as assertGrant, I as authorizationError, L as decode, N as Schema, P as StoredCredential, R as encode, _ as StartResult, a as Authentication, c as CompleteInput, d as Error, f as Failure, g as Requirements, h as Method, j as Grant, k as AuthorizationError, l as Continuation, m as InteractiveStart, o as AuthenticationFailure, p as InteractiveFlow, s as BaseInput, u as ContinuationStore, v as complete, y as start, z as validate } from "./zone-discovery-BA5I24vu.mjs";
-declare namespace connection_api_d_exports {
-  export { Authentication, AuthenticationFailure, AuthorizationError, BaseInput, CompleteInput, Connection, Method as ConnectionMethod, StartResult as ConnectionStartResult, Continuation, ContinuationStore, Error, Failure, Grant, InteractiveFlow, InteractiveStart, Method, Requirements, Schema, StartResult, StoredCredential, assertGrant, authorizationError, complete, decode, encode, start, validate };
-}
-//#endregion
-export { connection_api_d_exports as t };
-//# sourceMappingURL=connection-api-DftK7eHo.d.mts.map