@yielded/crypto 0.0.0-stage → 0.1.0-beta.20

package/dist/Kdf.d.mts

@@ -0,0 +1,54 @@
+import { KdfBusy, OperationError } from "./Errors.mjs";
+import { Context, Effect, Redacted, Schema } from "effect";
+//#region src/Kdf.d.ts
+export declare const Argon2idInput: Schema.Struct<{
+  readonly password: Schema.Redacted<Schema.Uint8Array>;
+  readonly salt: Schema.Uint8Array;
+  readonly memoryKiB: Schema.Int;
+  readonly passes: Schema.Int;
+  readonly parallelism: Schema.Int;
+  readonly length: Schema.Int;
+  readonly secret: Schema.optionalKey<Schema.Redacted<Schema.Uint8Array>>;
+  readonly associatedData: Schema.optionalKey<Schema.Uint8Array>;
+}>;
+export type Argon2idInput = typeof Argon2idInput.Type;
+export declare const Pbkdf2Input: Schema.Struct<{
+  readonly password: Schema.Redacted<Schema.Uint8Array>;
+  readonly salt: Schema.Uint8Array;
+  readonly iterations: Schema.Int;
+  readonly length: Schema.Int;
+}>;
+export type Pbkdf2Input = typeof Pbkdf2Input.Type;
+export declare const HkdfInput: Schema.Struct<{
+  readonly key: Schema.Redacted<Schema.Uint8Array>;
+  readonly salt: Schema.Uint8Array;
+  readonly info: Schema.Uint8Array;
+  readonly length: Schema.Int;
+}>;
+export type HkdfInput = typeof HkdfInput.Type;
+/** Resource ceilings, not a password-strength policy. Limits apply per permit. */
+export declare const Limits: Schema.Struct<{
+  readonly maximumMemoryKiB: Schema.Int;
+  readonly maximumPasses: Schema.Int;
+  readonly maximumParallelism: Schema.Int;
+  readonly maximumMemoryPasses: Schema.Int;
+  readonly maximumIterations: Schema.Int;
+  readonly maximumInputBytes: Schema.Int;
+  readonly maximumOutputBytes: Schema.Int;
+}>;
+export type Limits = typeof Limits.Type;
+export declare const defaultLimits: Limits;
+declare const Kdf_base: Context.ServiceClass<Kdf, "@yielded/crypto/Kdf", {
+  readonly argon2id: (input: Argon2idInput) => Effect.Effect<Redacted.Redacted<Uint8Array>, OperationError | KdfBusy>;
+  readonly pbkdf2: (input: Pbkdf2Input) => Effect.Effect<Redacted.Redacted<Uint8Array>, OperationError | KdfBusy>;
+  readonly hkdf: (input: HkdfInput) => Effect.Effect<Redacted.Redacted<Uint8Array>, OperationError | KdfBusy>;
+}>;
+/**
+ * Byte-preserving derivation; no text normalization, PHC parsing or password policy.
+ * Argon2id uses version 19; PBKDF2 and HKDF use SHA-256. A backend captures shared
+ * KdfAdmission when its Layer is built and retains admission until work and cleanup
+ * finish, including when a native operation cannot be cancelled.
+ */
+export declare class Kdf extends Kdf_base {}
+//#endregion
+//# sourceMappingURL=Kdf.d.mts.map

package/dist/Kdf.mjs

@@ -0,0 +1,78 @@
+import { Context, Schema } from "effect";
+//#region src/Kdf.ts
+const positive = Schema.Int.check(Schema.isGreaterThan(0));
+const uint32 = Schema.Int.check(Schema.isBetween({
+	minimum: 1,
+	maximum: 4294967295
+}));
+const bytes = Schema.Uint8Array;
+const secret = Schema.Redacted(bytes, { disallowJsonEncode: true });
+const argon2Bytes = bytes.check(Schema.isMaxLength(4294967295));
+const argon2Secret = Schema.Redacted(argon2Bytes, { disallowJsonEncode: true });
+const Argon2idInput = Schema.Struct({
+	password: argon2Secret,
+	salt: argon2Bytes.check(Schema.isMinLength(8)),
+	memoryKiB: uint32,
+	passes: uint32,
+	parallelism: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 16777215
+	})),
+	length: Schema.Int.check(Schema.isBetween({
+		minimum: 4,
+		maximum: 4294967295
+	})),
+	secret: Schema.optionalKey(argon2Secret),
+	associatedData: Schema.optionalKey(argon2Bytes)
+});
+const Pbkdf2Input = Schema.Struct({
+	password: secret,
+	salt: bytes,
+	iterations: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 2147483647
+	})),
+	length: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 536870911
+	}))
+});
+const HkdfInput = Schema.Struct({
+	key: secret,
+	salt: bytes,
+	info: bytes.check(Schema.isMaxLength(1024)),
+	length: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 8160
+	}))
+});
+/** Resource ceilings, not a password-strength policy. Limits apply per permit. */
+const Limits = Schema.Struct({
+	maximumMemoryKiB: positive,
+	maximumPasses: positive,
+	maximumParallelism: positive,
+	maximumMemoryPasses: positive,
+	maximumIterations: positive,
+	maximumInputBytes: positive,
+	maximumOutputBytes: positive
+});
+const defaultLimits = Object.freeze({
+	maximumMemoryKiB: 65536,
+	maximumPasses: 6,
+	maximumParallelism: 4,
+	maximumMemoryPasses: 131072,
+	maximumIterations: 1e6,
+	maximumInputBytes: 65536,
+	maximumOutputBytes: 1024
+});
+/**
+* Byte-preserving derivation; no text normalization, PHC parsing or password policy.
+* Argon2id uses version 19; PBKDF2 and HKDF use SHA-256. A backend captures shared
+* KdfAdmission when its Layer is built and retains admission until work and cleanup
+* finish, including when a native operation cannot be cancelled.
+*/
+var Kdf = class extends Context.Service()("@yielded/crypto/Kdf") {};
+//#endregion
+export { Argon2idInput, HkdfInput, Kdf, Limits, Pbkdf2Input, defaultLimits };
+
+//# sourceMappingURL=Kdf.mjs.map

package/dist/Kdf.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Kdf.mjs","names":[],"sources":["../src/Kdf.ts"],"sourcesContent":["import { Context, type Effect, type Redacted, Schema } from \"effect\";\n\nimport type { KdfBusy, OperationError } from \"./Errors\";\n\nconst positive = Schema.Int.check(Schema.isGreaterThan(0));\nconst uint32 = Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 0xffffffff }));\nconst bytes = Schema.Uint8Array;\nconst secret = Schema.Redacted(bytes, { disallowJsonEncode: true });\nconst argon2Bytes = bytes.check(Schema.isMaxLength(0xffffffff));\nconst argon2Secret = Schema.Redacted(argon2Bytes, { disallowJsonEncode: true });\n\nexport const Argon2idInput = Schema.Struct({\n  password: argon2Secret,\n  salt: argon2Bytes.check(Schema.isMinLength(8)),\n  memoryKiB: uint32,\n  passes: uint32,\n  parallelism: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 0xffffff })),\n  length: Schema.Int.check(Schema.isBetween({ minimum: 4, maximum: 0xffffffff })),\n  secret: Schema.optionalKey(argon2Secret),\n  associatedData: Schema.optionalKey(argon2Bytes),\n});\n\nexport type Argon2idInput = typeof Argon2idInput.Type;\n\nexport const Pbkdf2Input = Schema.Struct({\n  password: secret,\n  salt: bytes,\n  // Native Node/Bun PBKDF2 accepts a positive signed 32-bit iteration count.\n  iterations: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 0x7fffffff })),\n  // WebCrypto takes an unsigned 32-bit bit count; this API takes whole bytes.\n  length: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 0x1fffffff })),\n});\n\nexport type Pbkdf2Input = typeof Pbkdf2Input.Type;\n\nexport const HkdfInput = Schema.Struct({\n  key: secret,\n  salt: bytes,\n  info: bytes.check(Schema.isMaxLength(1024)),\n  length: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 255 * 32 })),\n});\n\nexport type HkdfInput = typeof HkdfInput.Type;\n\n/** Resource ceilings, not a password-strength policy. Limits apply per permit. */\nexport const Limits = Schema.Struct({\n  maximumMemoryKiB: positive,\n  maximumPasses: positive,\n  maximumParallelism: positive,\n  maximumMemoryPasses: positive,\n  maximumIterations: positive,\n  maximumInputBytes: positive,\n  maximumOutputBytes: positive,\n});\n\nexport type Limits = typeof Limits.Type;\n\nexport const defaultLimits: Limits = Object.freeze({\n  maximumMemoryKiB: 65536,\n  maximumPasses: 6,\n  maximumParallelism: 4,\n  maximumMemoryPasses: 131072,\n  maximumIterations: 1000000,\n  maximumInputBytes: 65536,\n  maximumOutputBytes: 1024,\n});\n\n/**\n * Byte-preserving derivation; no text normalization, PHC parsing or password policy.\n * Argon2id uses version 19; PBKDF2 and HKDF use SHA-256. A backend captures shared\n * KdfAdmission when its Layer is built and retains admission until work and cleanup\n * finish, including when a native operation cannot be cancelled.\n */\nexport class Kdf extends Context.Service<\n  Kdf,\n  {\n    readonly argon2id: (\n      input: Argon2idInput,\n    ) => Effect.Effect<Redacted.Redacted<Uint8Array>, OperationError | KdfBusy>;\n    readonly pbkdf2: (\n      input: Pbkdf2Input,\n    ) => Effect.Effect<Redacted.Redacted<Uint8Array>, OperationError | KdfBusy>;\n    readonly hkdf: (\n      input: HkdfInput,\n    ) => Effect.Effect<Redacted.Redacted<Uint8Array>, OperationError | KdfBusy>;\n  }\n>()(\"@yielded/crypto/Kdf\") {}\n"],"mappings":";;AAIA,MAAM,WAAW,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC;AACzD,MAAM,SAAS,OAAO,IAAI,MAAM,OAAO,UAAU;CAAE,SAAS;CAAG,SAAS;AAAW,CAAC,CAAC;AACrF,MAAM,QAAQ,OAAO;AACrB,MAAM,SAAS,OAAO,SAAS,OAAO,EAAE,oBAAoB,KAAK,CAAC;AAClE,MAAM,cAAc,MAAM,MAAM,OAAO,YAAY,UAAU,CAAC;AAC9D,MAAM,eAAe,OAAO,SAAS,aAAa,EAAE,oBAAoB,KAAK,CAAC;AAE9E,MAAa,gBAAgB,OAAO,OAAO;CACzC,UAAU;CACV,MAAM,YAAY,MAAM,OAAO,YAAY,CAAC,CAAC;CAC7C,WAAW;CACX,QAAQ;CACR,aAAa,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAS,CAAC,CAAC;CACjF,QAAQ,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAW,CAAC,CAAC;CAC9E,QAAQ,OAAO,YAAY,YAAY;CACvC,gBAAgB,OAAO,YAAY,WAAW;AAChD,CAAC;AAID,MAAa,cAAc,OAAO,OAAO;CACvC,UAAU;CACV,MAAM;CAEN,YAAY,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAW,CAAC,CAAC;CAElF,QAAQ,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAW,CAAC,CAAC;AAChF,CAAC;AAID,MAAa,YAAY,OAAO,OAAO;CACrC,KAAK;CACL,MAAM;CACN,MAAM,MAAM,MAAM,OAAO,YAAY,IAAI,CAAC;CAC1C,QAAQ,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAS,CAAC,CAAC;AAC9E,CAAC;;AAKD,MAAa,SAAS,OAAO,OAAO;CAClC,kBAAkB;CAClB,eAAe;CACf,oBAAoB;CACpB,qBAAqB;CACrB,mBAAmB;CACnB,mBAAmB;CACnB,oBAAoB;AACtB,CAAC;AAID,MAAa,gBAAwB,OAAO,OAAO;CACjD,kBAAkB;CAClB,eAAe;CACf,oBAAoB;CACpB,qBAAqB;CACrB,mBAAmB;CACnB,mBAAmB;CACnB,oBAAoB;AACtB,CAAC;;;;;;;AAQD,IAAa,MAAb,cAAyB,QAAQ,QAa/B,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC"}

package/dist/KdfAdmission.d.mts

@@ -0,0 +1,24 @@
+import { InvalidInput, KdfBusy } from "./Errors.mjs";
+import { Context, Effect, Layer } from "effect";
+//#region src/KdfAdmission.d.ts
+export interface Options {
+  readonly concurrency?: number;
+  readonly maxQueued?: number;
+  readonly maxWaitMilliseconds?: number;
+}
+declare const KdfAdmission_base: Context.ServiceClass<KdfAdmission, "@yielded/crypto/KdfAdmission", {
+  readonly run: <A, E, R>(work: Effect.Effect<A, E, R>) => Effect.Effect<A, E | KdfBusy, R>;
+}>;
+/** Share one Layer across all backend instances to bound actual KDF work. */
+export declare class KdfAdmission extends KdfAdmission_base {}
+/**
+ * Waiting is interruptible and bounded. The permit covers work and its cleanup;
+ * backends protect nonabortable native calls until actual completion. Owned
+ * interruptible work can stop and release its resources without finishing a KDF.
+ * Nested work in the same fiber shares its permit through scoped cleanup; forked
+ * fibers must acquire their own. This covers preparation and cleanup around a KDF.
+ * Defaults: one running derivation, sixteen waiting, five-second acquisition wait.
+ */
+export declare const layer: (options?: Options) => Layer.Layer<KdfAdmission, InvalidInput>;
+//#endregion
+//# sourceMappingURL=KdfAdmission.d.mts.map

package/dist/KdfAdmission.mjs

@@ -0,0 +1,48 @@
+import { InvalidInput, KdfBusy } from "./Errors.mjs";
+import { Context, Effect, Layer, Option, Schema, Semaphore } from "effect";
+//#region src/KdfAdmission.ts
+/** Share one Layer across all backend instances to bound actual KDF work. */
+var KdfAdmission = class extends Context.Service()("@yielded/crypto/KdfAdmission") {};
+const Configuration = Schema.Struct({
+	concurrency: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 32
+	})),
+	maxQueued: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+	maxWaitMilliseconds: Schema.Int.check(Schema.isGreaterThan(0))
+});
+/**
+* Waiting is interruptible and bounded. The permit covers work and its cleanup;
+* backends protect nonabortable native calls until actual completion. Owned
+* interruptible work can stop and release its resources without finishing a KDF.
+* Nested work in the same fiber shares its permit through scoped cleanup; forked
+* fibers must acquire their own. This covers preparation and cleanup around a KDF.
+* Defaults: one running derivation, sixteen waiting, five-second acquisition wait.
+*/
+const layer = (options = {}) => {
+	const snapshot = {
+		concurrency: options.concurrency ?? 1,
+		maxQueued: options.maxQueued ?? 16,
+		maxWaitMilliseconds: options.maxWaitMilliseconds ?? 5e3
+	};
+	return Layer.effect(KdfAdmission, Effect.gen(function* () {
+		const config = yield* Schema.decodeEffect(Configuration)(snapshot).pipe(Effect.mapError(() => InvalidInput.make({ reason: "parameters" })));
+		const capacity = yield* Schema.decodeEffect(Schema.Int)(config.concurrency + config.maxQueued).pipe(Effect.mapError(() => InvalidInput.make({ reason: "parameters" })));
+		const active = yield* Semaphore.make(config.concurrency);
+		const admitted = yield* Semaphore.make(capacity);
+		const owners = /* @__PURE__ */ new Set();
+		const acquire = Effect.acquireRelease(active.take(1), () => active.release(1), { interruptible: true }).pipe(Effect.timeoutOrElse({
+			duration: config.maxWaitMilliseconds,
+			orElse: () => Effect.fail(KdfBusy.make({}))
+		}));
+		return KdfAdmission.of({ run: (work) => Effect.withFiber((fiber) => {
+			if (owners.has(fiber.id)) return work;
+			const owned = Effect.acquireRelease(Effect.sync(() => owners.add(fiber.id)), () => Effect.sync(() => owners.delete(fiber.id))).pipe(Effect.andThen(work));
+			return admitted.withPermitsIfAvailable(1)(Effect.scoped(Effect.andThen(acquire, owned))).pipe(Effect.flatMap((result) => Option.isSome(result) ? Effect.succeed(result.value) : Effect.fail(KdfBusy.make({}))));
+		}) });
+	}));
+};
+//#endregion
+export { KdfAdmission, layer };
+
+//# sourceMappingURL=KdfAdmission.mjs.map

package/dist/KdfAdmission.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"KdfAdmission.mjs","names":[],"sources":["../src/KdfAdmission.ts"],"sourcesContent":["import { Context, Effect, Layer, Option, Schema, Semaphore } from \"effect\";\n\nimport { InvalidInput, KdfBusy } from \"./Errors\";\n\nexport interface Options {\n  readonly concurrency?: number;\n  readonly maxQueued?: number;\n  readonly maxWaitMilliseconds?: number;\n}\n\n/** Share one Layer across all backend instances to bound actual KDF work. */\nexport class KdfAdmission extends Context.Service<\n  KdfAdmission,\n  {\n    readonly run: <A, E, R>(work: Effect.Effect<A, E, R>) => Effect.Effect<A, E | KdfBusy, R>;\n  }\n>()(\"@yielded/crypto/KdfAdmission\") {}\n\nconst Configuration = Schema.Struct({\n  concurrency: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 32 })),\n  maxQueued: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),\n  maxWaitMilliseconds: Schema.Int.check(Schema.isGreaterThan(0)),\n});\n\n/**\n * Waiting is interruptible and bounded. The permit covers work and its cleanup;\n * backends protect nonabortable native calls until actual completion. Owned\n * interruptible work can stop and release its resources without finishing a KDF.\n * Nested work in the same fiber shares its permit through scoped cleanup; forked\n * fibers must acquire their own. This covers preparation and cleanup around a KDF.\n * Defaults: one running derivation, sixteen waiting, five-second acquisition wait.\n */\nexport const layer = (options: Options = {}): Layer.Layer<KdfAdmission, InvalidInput> => {\n  const snapshot = {\n    concurrency: options.concurrency ?? 1,\n    maxQueued: options.maxQueued ?? 16,\n    maxWaitMilliseconds: options.maxWaitMilliseconds ?? 5000,\n  };\n\n  return Layer.effect(\n    KdfAdmission,\n    Effect.gen(function* () {\n      const config = yield* Schema.decodeEffect(Configuration)(snapshot).pipe(\n        Effect.mapError(() => InvalidInput.make({ reason: \"parameters\" })),\n      );\n\n      const capacity = yield* Schema.decodeEffect(Schema.Int)(\n        config.concurrency + config.maxQueued,\n      ).pipe(Effect.mapError(() => InvalidInput.make({ reason: \"parameters\" })));\n\n      const active = yield* Semaphore.make(config.concurrency);\n      const admitted = yield* Semaphore.make(capacity);\n      const owners = new Set<number>();\n\n      const acquire = Effect.acquireRelease(active.take(1), () => active.release(1), {\n        interruptible: true,\n      }).pipe(\n        Effect.timeoutOrElse({\n          duration: config.maxWaitMilliseconds,\n          orElse: () => Effect.fail(KdfBusy.make({})),\n        }),\n      );\n\n      return KdfAdmission.of({\n        run: <A, E, R>(work: Effect.Effect<A, E, R>) =>\n          Effect.withFiber((fiber) => {\n            if (owners.has(fiber.id)) return work;\n\n            const owned = Effect.acquireRelease(\n              Effect.sync(() => owners.add(fiber.id)),\n              () => Effect.sync(() => owners.delete(fiber.id)),\n            ).pipe(Effect.andThen(work));\n\n            return admitted\n              .withPermitsIfAvailable(1)(Effect.scoped(Effect.andThen(acquire, owned)))\n              .pipe(\n                Effect.flatMap((result) =>\n                  Option.isSome(result)\n                    ? Effect.succeed(result.value)\n                    : Effect.fail(KdfBusy.make({})),\n                ),\n              );\n          }),\n      });\n    }),\n  );\n};\n"],"mappings":";;;;AAWA,IAAa,eAAb,cAAkC,QAAQ,QAKxC,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC;AAErC,MAAM,gBAAgB,OAAO,OAAO;CAClC,aAAa,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAG,CAAC,CAAC;CAC3E,WAAW,OAAO,IAAI,MAAM,OAAO,uBAAuB,CAAC,CAAC;CAC5D,qBAAqB,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC;AAC/D,CAAC;;;;;;;;;AAUD,MAAa,SAAS,UAAmB,CAAC,MAA+C;CACvF,MAAM,WAAW;EACf,aAAa,QAAQ,eAAe;EACpC,WAAW,QAAQ,aAAa;EAChC,qBAAqB,QAAQ,uBAAuB;CACtD;CAEA,OAAO,MAAM,OACX,cACA,OAAO,IAAI,aAAa;EACtB,MAAM,SAAS,OAAO,OAAO,aAAa,aAAa,CAAC,CAAC,QAAQ,CAAC,CAAC,KACjE,OAAO,eAAe,aAAa,KAAK,EAAE,QAAQ,aAAa,CAAC,CAAC,CACnE;EAEA,MAAM,WAAW,OAAO,OAAO,aAAa,OAAO,GAAG,CAAC,CACrD,OAAO,cAAc,OAAO,SAC9B,CAAC,CAAC,KAAK,OAAO,eAAe,aAAa,KAAK,EAAE,QAAQ,aAAa,CAAC,CAAC,CAAC;EAEzE,MAAM,SAAS,OAAO,UAAU,KAAK,OAAO,WAAW;EACvD,MAAM,WAAW,OAAO,UAAU,KAAK,QAAQ;EAC/C,MAAM,yBAAS,IAAI,IAAY;EAE/B,MAAM,UAAU,OAAO,eAAe,OAAO,KAAK,CAAC,SAAS,OAAO,QAAQ,CAAC,GAAG,EAC7E,eAAe,KACjB,CAAC,CAAC,CAAC,KACD,OAAO,cAAc;GACnB,UAAU,OAAO;GACjB,cAAc,OAAO,KAAK,QAAQ,KAAK,CAAC,CAAC,CAAC;EAC5C,CAAC,CACH;EAEA,OAAO,aAAa,GAAG,EACrB,MAAe,SACb,OAAO,WAAW,UAAU;GAC1B,IAAI,OAAO,IAAI,MAAM,EAAE,GAAG,OAAO;GAEjC,MAAM,QAAQ,OAAO,eACnB,OAAO,WAAW,OAAO,IAAI,MAAM,EAAE,CAAC,SAChC,OAAO,WAAW,OAAO,OAAO,MAAM,EAAE,CAAC,CACjD,CAAC,CAAC,KAAK,OAAO,QAAQ,IAAI,CAAC;GAE3B,OAAO,SACJ,uBAAuB,CAAC,CAAC,CAAC,OAAO,OAAO,OAAO,QAAQ,SAAS,KAAK,CAAC,CAAC,CAAC,CACxE,KACC,OAAO,SAAS,WACd,OAAO,OAAO,MAAM,IAChB,OAAO,QAAQ,OAAO,KAAK,IAC3B,OAAO,KAAK,QAAQ,KAAK,CAAC,CAAC,CAAC,CAClC,CACF;EACJ,CAAC,EACL,CAAC;CACH,CAAC,CACH;AACF"}

package/dist/Portable.d.mts

@@ -0,0 +1,11 @@
+import { InvalidInput } from "./Errors.mjs";
+import { Aead } from "./Aead.mjs";
+import { Hmac } from "./Hmac.mjs";
+import { Kdf, Limits } from "./Kdf.mjs";
+import { KdfAdmission } from "./KdfAdmission.mjs";
+import { Signature } from "./Signature.mjs";
+//#region src/Portable.d.ts
+/** WebCrypto with owned, portable Argon2id and XChaCha20-Poly1305 implementations. */
+export declare const layer: (subtle: SubtleCrypto, limits?: Partial<Limits>) => import("effect/Layer").Layer<Aead | Hmac | Kdf | Signature, InvalidInput, KdfAdmission>;
+//#endregion
+//# sourceMappingURL=Portable.d.mts.map

package/dist/Portable.mjs

@@ -0,0 +1,13 @@
+import { makeLayer } from "./internal/layer.mjs";
+import { xchacha } from "./internal/xchacha.mjs";
+import { argon2 } from "./internal/argon2.mjs";
+//#region src/Portable.ts
+/** WebCrypto with owned, portable Argon2id and XChaCha20-Poly1305 implementations. */
+const layer = (subtle, limits = {}) => makeLayer(subtle, limits, {
+	argon2,
+	xchacha
+});
+//#endregion
+export { layer };
+
+//# sourceMappingURL=Portable.mjs.map

package/dist/Portable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Portable.mjs","names":[],"sources":["../src/Portable.ts"],"sourcesContent":["import { argon2 } from \"./internal/argon2\";\nimport { makeLayer } from \"./internal/layer\";\nimport { xchacha } from \"./internal/xchacha\";\nimport type { Limits } from \"./Kdf\";\n\n/** WebCrypto with owned, portable Argon2id and XChaCha20-Poly1305 implementations. */\nexport const layer = (subtle: SubtleCrypto, limits: Partial<Limits> = {}) =>\n  makeLayer(subtle, limits, { argon2, xchacha });\n"],"mappings":";;;;;AAMA,MAAa,SAAS,QAAsB,SAA0B,CAAC,MACrE,UAAU,QAAQ,QAAQ;CAAE;CAAQ;AAAQ,CAAC"}

package/dist/Signature.d.mts

@@ -0,0 +1,70 @@
+import { OperationError } from "./Errors.mjs";
+import { Context, Effect, Redacted, Schema } from "effect";
+//#region src/Signature.d.ts
+export declare const Algorithm: Schema.Literals<readonly ["ECDSA-P256-SHA256", "RSASSA-PKCS1-v1_5-SHA256", "RSA-PSS-SHA256", "Ed25519"]>;
+export type Algorithm = typeof Algorithm.Type;
+/**
+ * Unsigned big-endian components: 32-byte curve values and RSA components up to
+ * 1024 bytes. Native import validates the actual key, including RSA's minimum.
+ */
+export declare const PublicKeyParameters: Schema.Union<readonly [Schema.Struct<{
+  algorithm: Schema.Literal<"ECDSA-P256-SHA256">;
+  x: Schema.Uint8Array;
+  y: Schema.Uint8Array;
+}>, Schema.Struct<{
+  algorithm: Schema.Literal<"Ed25519">;
+  x: Schema.Uint8Array;
+}>, Schema.Struct<{
+  algorithm: Schema.Literals<readonly ["RSASSA-PKCS1-v1_5-SHA256", "RSA-PSS-SHA256"]>;
+  n: Schema.Uint8Array;
+  e: Schema.Uint8Array;
+}>]>;
+export type PublicKeyParameters = typeof PublicKeyParameters.Type;
+export declare const PrivateKeyParameters: Schema.Union<readonly [Schema.Struct<{
+  readonly algorithm: Schema.Literal<"ECDSA-P256-SHA256">;
+  readonly x: Schema.Uint8Array;
+  readonly y: Schema.Uint8Array;
+  readonly d: Schema.Uint8Array;
+}>, Schema.Struct<{
+  readonly algorithm: Schema.Literal<"Ed25519">;
+  readonly x: Schema.Uint8Array;
+  readonly d: Schema.Uint8Array;
+}>, Schema.Struct<{
+  readonly algorithm: Schema.Literals<readonly ["RSASSA-PKCS1-v1_5-SHA256", "RSA-PSS-SHA256"]>;
+  readonly n: Schema.Uint8Array;
+  readonly e: Schema.Uint8Array;
+  readonly d: Schema.Uint8Array;
+  readonly p: Schema.Uint8Array;
+  readonly q: Schema.Uint8Array;
+  readonly dp: Schema.Uint8Array;
+  readonly dq: Schema.Uint8Array;
+  readonly qi: Schema.Uint8Array;
+}>]>;
+export type PrivateKeyParameters = typeof PrivateKeyParameters.Type;
+export declare const SignInput: Schema.Struct<{
+  readonly algorithm: Schema.Literals<readonly ["ECDSA-P256-SHA256", "RSASSA-PKCS1-v1_5-SHA256", "RSA-PSS-SHA256", "Ed25519"]>;
+  readonly privateKey: Schema.Redacted<Schema.Uint8Array>;
+  readonly data: Schema.Uint8Array;
+}>;
+export type SignInput = typeof SignInput.Type;
+export declare const VerifyInput: Schema.Struct<{
+  readonly algorithm: Schema.Literals<readonly ["ECDSA-P256-SHA256", "RSASSA-PKCS1-v1_5-SHA256", "RSA-PSS-SHA256", "Ed25519"]>;
+  readonly publicKey: Schema.Uint8Array;
+  readonly data: Schema.Uint8Array;
+  readonly signature: Schema.Uint8Array;
+}>;
+export type VerifyInput = typeof VerifyInput.Type;
+declare const Signature_base: Context.ServiceClass<Signature, "@yielded/crypto/Signature", {
+  readonly encodePublicKey: (input: PublicKeyParameters) => Effect.Effect<Uint8Array, OperationError>;
+  readonly encodePrivateKey: (input: Redacted.Redacted<PrivateKeyParameters>) => Effect.Effect<Redacted.Redacted<Uint8Array>, OperationError>;
+  readonly sign: (input: SignInput) => Effect.Effect<Uint8Array, OperationError>;
+  readonly verify: (input: VerifyInput) => Effect.Effect<boolean, OperationError>;
+}>;
+/**
+ * Private keys are PKCS8 DER; public keys are SPKI DER. ECDSA signatures are
+ * 64-byte IEEE P1363 (r || s), not ASN.1 DER. RSA requires at least 2048 bits;
+ * PSS uses a 32-byte salt. Key serialization/selection and JOSE policy stay outside.
+ */
+export declare class Signature extends Signature_base {}
+//#endregion
+//# sourceMappingURL=Signature.d.mts.map

package/dist/Signature.mjs

@@ -0,0 +1,73 @@
+import { Context, Schema } from "effect";
+//#region src/Signature.ts
+const Algorithm = Schema.Literals([
+	"ECDSA-P256-SHA256",
+	"RSASSA-PKCS1-v1_5-SHA256",
+	"RSA-PSS-SHA256",
+	"Ed25519"
+]);
+const coordinate = Schema.Uint8Array.check(Schema.isMinLength(32), Schema.isMaxLength(32));
+const integer = Schema.Uint8Array.check(Schema.isMinLength(1), Schema.isMaxLength(1024));
+const ec = {
+	algorithm: Schema.Literal("ECDSA-P256-SHA256"),
+	x: coordinate,
+	y: coordinate
+};
+const ed = {
+	algorithm: Schema.Literal("Ed25519"),
+	x: coordinate
+};
+const rsa = {
+	algorithm: Schema.Literals(["RSASSA-PKCS1-v1_5-SHA256", "RSA-PSS-SHA256"]),
+	n: integer,
+	e: integer
+};
+/**
+* Unsigned big-endian components: 32-byte curve values and RSA components up to
+* 1024 bytes. Native import validates the actual key, including RSA's minimum.
+*/
+const PublicKeyParameters = Schema.Union([
+	Schema.Struct(ec),
+	Schema.Struct(ed),
+	Schema.Struct(rsa)
+]);
+const PrivateKeyParameters = Schema.Union([
+	Schema.Struct({
+		...ec,
+		d: coordinate
+	}),
+	Schema.Struct({
+		...ed,
+		d: coordinate
+	}),
+	Schema.Struct({
+		...rsa,
+		d: integer,
+		p: integer,
+		q: integer,
+		dp: integer,
+		dq: integer,
+		qi: integer
+	})
+]);
+const SignInput = Schema.Struct({
+	algorithm: Algorithm,
+	privateKey: Schema.Redacted(Schema.Uint8Array, { disallowJsonEncode: true }),
+	data: Schema.Uint8Array
+});
+const VerifyInput = Schema.Struct({
+	algorithm: Algorithm,
+	publicKey: Schema.Uint8Array,
+	data: Schema.Uint8Array,
+	signature: Schema.Uint8Array
+});
+/**
+* Private keys are PKCS8 DER; public keys are SPKI DER. ECDSA signatures are
+* 64-byte IEEE P1363 (r || s), not ASN.1 DER. RSA requires at least 2048 bits;
+* PSS uses a 32-byte salt. Key serialization/selection and JOSE policy stay outside.
+*/
+var Signature = class extends Context.Service()("@yielded/crypto/Signature") {};
+//#endregion
+export { Algorithm, PrivateKeyParameters, PublicKeyParameters, SignInput, Signature, VerifyInput };
+
+//# sourceMappingURL=Signature.mjs.map

package/dist/Signature.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Signature.mjs","names":[],"sources":["../src/Signature.ts"],"sourcesContent":["import { Context, type Effect, type Redacted, Schema } from \"effect\";\n\nimport type { OperationError } from \"./Errors\";\n\nexport const Algorithm = Schema.Literals([\n  \"ECDSA-P256-SHA256\",\n  \"RSASSA-PKCS1-v1_5-SHA256\",\n  \"RSA-PSS-SHA256\",\n  \"Ed25519\",\n]);\n\nexport type Algorithm = typeof Algorithm.Type;\n\nconst coordinate = Schema.Uint8Array.check(Schema.isMinLength(32), Schema.isMaxLength(32));\nconst integer = Schema.Uint8Array.check(Schema.isMinLength(1), Schema.isMaxLength(1024));\nconst ec = { algorithm: Schema.Literal(\"ECDSA-P256-SHA256\"), x: coordinate, y: coordinate };\nconst ed = { algorithm: Schema.Literal(\"Ed25519\"), x: coordinate };\n\nconst rsa = {\n  algorithm: Schema.Literals([\"RSASSA-PKCS1-v1_5-SHA256\", \"RSA-PSS-SHA256\"]),\n  n: integer,\n  e: integer,\n};\n\n/**\n * Unsigned big-endian components: 32-byte curve values and RSA components up to\n * 1024 bytes. Native import validates the actual key, including RSA's minimum.\n */\nexport const PublicKeyParameters = Schema.Union([\n  Schema.Struct(ec),\n  Schema.Struct(ed),\n  Schema.Struct(rsa),\n]);\n\nexport type PublicKeyParameters = typeof PublicKeyParameters.Type;\n\nexport const PrivateKeyParameters = Schema.Union([\n  Schema.Struct({ ...ec, d: coordinate }),\n  Schema.Struct({ ...ed, d: coordinate }),\n  Schema.Struct({\n    ...rsa,\n    d: integer,\n    p: integer,\n    q: integer,\n    dp: integer,\n    dq: integer,\n    qi: integer,\n  }),\n]);\n\nexport type PrivateKeyParameters = typeof PrivateKeyParameters.Type;\n\nexport const SignInput = Schema.Struct({\n  algorithm: Algorithm,\n  privateKey: Schema.Redacted(Schema.Uint8Array, { disallowJsonEncode: true }),\n  data: Schema.Uint8Array,\n});\n\nexport type SignInput = typeof SignInput.Type;\n\nexport const VerifyInput = Schema.Struct({\n  algorithm: Algorithm,\n  publicKey: Schema.Uint8Array,\n  data: Schema.Uint8Array,\n  signature: Schema.Uint8Array,\n});\n\nexport type VerifyInput = typeof VerifyInput.Type;\n\n/**\n * Private keys are PKCS8 DER; public keys are SPKI DER. ECDSA signatures are\n * 64-byte IEEE P1363 (r || s), not ASN.1 DER. RSA requires at least 2048 bits;\n * PSS uses a 32-byte salt. Key serialization/selection and JOSE policy stay outside.\n */\nexport class Signature extends Context.Service<\n  Signature,\n  {\n    readonly encodePublicKey: (\n      input: PublicKeyParameters,\n    ) => Effect.Effect<Uint8Array, OperationError>;\n    readonly encodePrivateKey: (\n      input: Redacted.Redacted<PrivateKeyParameters>,\n    ) => Effect.Effect<Redacted.Redacted<Uint8Array>, OperationError>;\n    readonly sign: (input: SignInput) => Effect.Effect<Uint8Array, OperationError>;\n    readonly verify: (input: VerifyInput) => Effect.Effect<boolean, OperationError>;\n  }\n>()(\"@yielded/crypto/Signature\") {}\n"],"mappings":";;AAIA,MAAa,YAAY,OAAO,SAAS;CACvC;CACA;CACA;CACA;AACF,CAAC;AAID,MAAM,aAAa,OAAO,WAAW,MAAM,OAAO,YAAY,EAAE,GAAG,OAAO,YAAY,EAAE,CAAC;AACzF,MAAM,UAAU,OAAO,WAAW,MAAM,OAAO,YAAY,CAAC,GAAG,OAAO,YAAY,IAAI,CAAC;AACvF,MAAM,KAAK;CAAE,WAAW,OAAO,QAAQ,mBAAmB;CAAG,GAAG;CAAY,GAAG;AAAW;AAC1F,MAAM,KAAK;CAAE,WAAW,OAAO,QAAQ,SAAS;CAAG,GAAG;AAAW;AAEjE,MAAM,MAAM;CACV,WAAW,OAAO,SAAS,CAAC,4BAA4B,gBAAgB,CAAC;CACzE,GAAG;CACH,GAAG;AACL;;;;;AAMA,MAAa,sBAAsB,OAAO,MAAM;CAC9C,OAAO,OAAO,EAAE;CAChB,OAAO,OAAO,EAAE;CAChB,OAAO,OAAO,GAAG;AACnB,CAAC;AAID,MAAa,uBAAuB,OAAO,MAAM;CAC/C,OAAO,OAAO;EAAE,GAAG;EAAI,GAAG;CAAW,CAAC;CACtC,OAAO,OAAO;EAAE,GAAG;EAAI,GAAG;CAAW,CAAC;CACtC,OAAO,OAAO;EACZ,GAAG;EACH,GAAG;EACH,GAAG;EACH,GAAG;EACH,IAAI;EACJ,IAAI;EACJ,IAAI;CACN,CAAC;AACH,CAAC;AAID,MAAa,YAAY,OAAO,OAAO;CACrC,WAAW;CACX,YAAY,OAAO,SAAS,OAAO,YAAY,EAAE,oBAAoB,KAAK,CAAC;CAC3E,MAAM,OAAO;AACf,CAAC;AAID,MAAa,cAAc,OAAO,OAAO;CACvC,WAAW;CACX,WAAW,OAAO;CAClB,MAAM,OAAO;CACb,WAAW,OAAO;AACpB,CAAC;;;;;;AASD,IAAa,YAAb,cAA+B,QAAQ,QAYrC,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAAC"}

package/dist/WebCrypto.d.mts

@@ -0,0 +1,20 @@
+import { InvalidInput } from "./Errors.mjs";
+import { Aead } from "./Aead.mjs";
+import { Hmac } from "./Hmac.mjs";
+import { Kdf, Limits } from "./Kdf.mjs";
+import { KdfAdmission } from "./KdfAdmission.mjs";
+import { Signature } from "./Signature.mjs";
+import { Crypto, Layer } from "effect";
+//#region src/WebCrypto.d.ts
+/** Supply the host capability explicitly; no implicit global backend selection. */
+export declare const layer: (subtle: SubtleCrypto, limits?: Partial<Limits>) => Layer.Layer<Aead | Hmac | Kdf | Signature, InvalidInput, KdfAdmission>;
+/** HMAC alone has no KDF admission requirement. */
+export declare const layerHmac: (subtle: SubtleCrypto) => Layer.Layer<Hmac>;
+/** Effect entropy and SHA digests from the host's global WebCrypto implementation. */
+export declare const layerCryptoWeb: Layer.Layer<Crypto.Crypto>;
+/** HMAC from global WebCrypto. Missing WebCrypto is a platform defect at Layer construction. */
+export declare const layerHmacWeb: Layer.Layer<Hmac>;
+/** Entropy, SHA digests and HMAC for sessions and proofs, without password derivation. */
+export declare const layerWebCrypto: Layer.Layer<Crypto.Crypto | Hmac, never, never>;
+//#endregion
+//# sourceMappingURL=WebCrypto.d.mts.map

package/dist/WebCrypto.mjs

@@ -0,0 +1,33 @@
+import { Hmac } from "./Hmac.mjs";
+import { makeHmac } from "./internal/hmac.mjs";
+import { makeLayer } from "./internal/layer.mjs";
+import { Crypto, Effect, Layer, PlatformError } from "effect";
+//#region src/WebCrypto.ts
+/** Supply the host capability explicitly; no implicit global backend selection. */
+const layer = (subtle, limits = {}) => makeLayer(subtle, limits);
+/** HMAC alone has no KDF admission requirement. */
+const layerHmac = (subtle) => Layer.sync(Hmac)(() => makeHmac(subtle));
+/** Effect entropy and SHA digests from the host's global WebCrypto implementation. */
+const layerCryptoWeb = Layer.sync(Crypto.Crypto)(() => Crypto.make({
+	randomBytes: (size) => globalThis.crypto.getRandomValues(new Uint8Array(size)),
+	digest: (algorithm, data) => Effect.tryPromise({
+		try: () => globalThis.crypto.subtle.digest(algorithm, new Uint8Array(data)),
+		catch: (cause) => PlatformError.systemError({
+			_tag: "Unknown",
+			module: "Crypto",
+			method: "digest",
+			cause
+		})
+	}).pipe(Effect.map((bytes) => new Uint8Array(bytes)))
+}));
+/** HMAC from global WebCrypto. Missing WebCrypto is a platform defect at Layer construction. */
+const layerHmacWeb = Layer.effect(Hmac)(Effect.suspend(() => {
+	const subtle = globalThis.crypto?.subtle;
+	return subtle === void 0 ? Effect.die(/* @__PURE__ */ new Error("WebCrypto is unavailable in this runtime")) : Effect.succeed(makeHmac(subtle));
+}));
+/** Entropy, SHA digests and HMAC for sessions and proofs, without password derivation. */
+const layerWebCrypto = Layer.merge(layerCryptoWeb, layerHmacWeb);
+//#endregion
+export { layer, layerCryptoWeb, layerHmac, layerHmacWeb, layerWebCrypto };
+
+//# sourceMappingURL=WebCrypto.mjs.map

package/dist/WebCrypto.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebCrypto.mjs","names":[],"sources":["../src/WebCrypto.ts"],"sourcesContent":["import { Crypto, Effect, Layer, PlatformError } from \"effect\";\n\nimport { Hmac } from \"./Hmac\";\nimport { makeHmac } from \"./internal/hmac\";\nimport { makeLayer } from \"./internal/layer\";\nimport type { Limits } from \"./Kdf\";\n\n/** Supply the host capability explicitly; no implicit global backend selection. */\nexport const layer = (subtle: SubtleCrypto, limits: Partial<Limits> = {}) =>\n  makeLayer(subtle, limits);\n\n/** HMAC alone has no KDF admission requirement. */\nexport const layerHmac = (subtle: SubtleCrypto): Layer.Layer<Hmac> =>\n  Layer.sync(Hmac)(() => makeHmac(subtle));\n\n/** Effect entropy and SHA digests from the host's global WebCrypto implementation. */\nexport const layerCryptoWeb: Layer.Layer<Crypto.Crypto> = Layer.sync(Crypto.Crypto)(() =>\n  Crypto.make({\n    randomBytes: (size) => globalThis.crypto.getRandomValues(new Uint8Array(size)),\n    digest: (algorithm, data) =>\n      Effect.tryPromise({\n        try: () => globalThis.crypto.subtle.digest(algorithm, new Uint8Array(data)),\n        catch: (cause) =>\n          PlatformError.systemError({\n            _tag: \"Unknown\",\n            module: \"Crypto\",\n            method: \"digest\",\n            cause,\n          }),\n      }).pipe(Effect.map((bytes) => new Uint8Array(bytes))),\n  }),\n);\n\n/** HMAC from global WebCrypto. Missing WebCrypto is a platform defect at Layer construction. */\nexport const layerHmacWeb: Layer.Layer<Hmac> = Layer.effect(Hmac)(\n  Effect.suspend(() => {\n    const subtle = globalThis.crypto?.subtle;\n\n    return subtle === undefined\n      ? Effect.die(new Error(\"WebCrypto is unavailable in this runtime\"))\n      : Effect.succeed(makeHmac(subtle));\n  }),\n);\n\n/** Entropy, SHA digests and HMAC for sessions and proofs, without password derivation. */\nexport const layerWebCrypto = Layer.merge(layerCryptoWeb, layerHmacWeb);\n"],"mappings":";;;;;;AAQA,MAAa,SAAS,QAAsB,SAA0B,CAAC,MACrE,UAAU,QAAQ,MAAM;;AAG1B,MAAa,aAAa,WACxB,MAAM,KAAK,IAAI,CAAC,OAAO,SAAS,MAAM,CAAC;;AAGzC,MAAa,iBAA6C,MAAM,KAAK,OAAO,MAAM,CAAC,OACjF,OAAO,KAAK;CACV,cAAc,SAAS,WAAW,OAAO,gBAAgB,IAAI,WAAW,IAAI,CAAC;CAC7E,SAAS,WAAW,SAClB,OAAO,WAAW;EAChB,WAAW,WAAW,OAAO,OAAO,OAAO,WAAW,IAAI,WAAW,IAAI,CAAC;EAC1E,QAAQ,UACN,cAAc,YAAY;GACxB,MAAM;GACN,QAAQ;GACR,QAAQ;GACR;EACF,CAAC;CACL,CAAC,CAAC,CAAC,KAAK,OAAO,KAAK,UAAU,IAAI,WAAW,KAAK,CAAC,CAAC;AACxD,CAAC,CACH;;AAGA,MAAa,eAAkC,MAAM,OAAO,IAAI,CAAC,CAC/D,OAAO,cAAc;CACnB,MAAM,SAAS,WAAW,QAAQ;CAElC,OAAO,WAAW,KAAA,IACd,OAAO,oBAAI,IAAI,MAAM,0CAA0C,CAAC,IAChE,OAAO,QAAQ,SAAS,MAAM,CAAC;AACrC,CAAC,CACH;;AAGA,MAAa,iBAAiB,MAAM,MAAM,gBAAgB,YAAY"}

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+import * as Aead from "./Aead.mjs";
+import * as Errors from "./Errors.mjs";
+import * as Hmac from "./Hmac.mjs";
+import * as Kdf from "./Kdf.mjs";
+import * as KdfAdmission from "./KdfAdmission.mjs";
+import * as Signature from "./Signature.mjs";
+export { Aead, Errors, Hmac, Kdf, KdfAdmission, Signature };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+import * as Aead from "./Aead.mjs";
+import * as Errors from "./Errors.mjs";
+import * as Hmac from "./Hmac.mjs";
+import * as Kdf from "./Kdf.mjs";
+import * as KdfAdmission from "./KdfAdmission.mjs";
+import * as Signature from "./Signature.mjs";
+export { Aead, Errors, Hmac, Kdf, KdfAdmission, Signature };

package/dist/internal/aead.mjs

@@ -0,0 +1,81 @@
+import { Aead, DecryptInput, EncryptInput } from "../Aead.mjs";
+import { AuthenticationFailed, UnsupportedAlgorithm } from "../Errors.mjs";
+import { copy, decode, importError, nativeError, nativeErrorName, withSecret } from "./common.mjs";
+import { Effect, Redacted, Schema } from "effect";
+//#region src/internal/aead.ts
+const keyBytes = Schema.Uint8Array.check(Schema.isBetweenLength(32, 32));
+const makeAead = (subtle, xchacha) => Aead.of({
+	encrypt: Effect.fnUntraced(function* (input) {
+		const value = yield* decode(EncryptInput, input, "data");
+		const nonceLength = value.algorithm === "AES-256-GCM" ? 12 : 24;
+		yield* decode(keyBytes, Redacted.value(value.key), "key");
+		yield* decode(Schema.Uint8Array.check(Schema.isBetweenLength(nonceLength, nonceLength)), value.nonce, "nonce");
+		if (value.algorithm === "XChaCha20-Poly1305" && xchacha === void 0) return yield* UnsupportedAlgorithm.make({});
+		const nonce = yield* copy(value.nonce);
+		const additionalData = yield* copy(value.additionalData ?? /* @__PURE__ */ new Uint8Array());
+		return yield* withSecret(value.key, (key) => withSecret(value.plaintext, (data) => {
+			if (value.algorithm === "XChaCha20-Poly1305") return xchacha === void 0 ? Effect.fail(UnsupportedAlgorithm.make({})) : xchacha.encrypt({
+				key,
+				nonce,
+				additionalData,
+				data
+			});
+			return Effect.gen(function* () {
+				const imported = yield* Effect.tryPromise({
+					try: () => subtle.importKey("raw", key, "AES-GCM", false, ["encrypt"]),
+					catch: importError
+				});
+				const encrypted = yield* Effect.tryPromise({
+					try: () => subtle.encrypt({
+						name: "AES-GCM",
+						iv: nonce,
+						additionalData,
+						tagLength: 128
+					}, imported, data),
+					catch: nativeError
+				});
+				return new Uint8Array(encrypted);
+			}).pipe(Effect.uninterruptible);
+		}));
+	}),
+	decrypt: Effect.fnUntraced(function* (input) {
+		const value = yield* decode(DecryptInput, input, "data");
+		const nonceLength = value.algorithm === "AES-256-GCM" ? 12 : 24;
+		yield* decode(keyBytes, Redacted.value(value.key), "key");
+		yield* decode(Schema.Uint8Array.check(Schema.isBetweenLength(nonceLength, nonceLength)), value.nonce, "nonce");
+		if (value.algorithm === "XChaCha20-Poly1305" && xchacha === void 0) return yield* UnsupportedAlgorithm.make({});
+		if (value.ciphertext.length < 16) return yield* AuthenticationFailed.make({});
+		const nonce = yield* copy(value.nonce);
+		const additionalData = yield* copy(value.additionalData ?? /* @__PURE__ */ new Uint8Array());
+		const data = yield* copy(value.ciphertext);
+		const plaintext = yield* withSecret(value.key, (key) => {
+			if (value.algorithm === "XChaCha20-Poly1305") return xchacha === void 0 ? Effect.fail(UnsupportedAlgorithm.make({})) : xchacha.decrypt({
+				key,
+				nonce,
+				additionalData,
+				data
+			});
+			return Effect.gen(function* () {
+				const imported = yield* Effect.tryPromise({
+					try: () => subtle.importKey("raw", key, "AES-GCM", false, ["decrypt"]),
+					catch: importError
+				});
+				const decrypted = yield* Effect.tryPromise({
+					try: () => subtle.decrypt({
+						name: "AES-GCM",
+						iv: nonce,
+						additionalData,
+						tagLength: 128
+					}, imported, data),
+					catch: (cause) => nativeErrorName(cause) === "OperationError" ? AuthenticationFailed.make({}) : nativeError(cause)
+				});
+				return new Uint8Array(decrypted);
+			}).pipe(Effect.uninterruptible);
+		});
+		return Redacted.make(plaintext);
+	})
+});
+//#endregion
+export { makeAead };
+
+//# sourceMappingURL=aead.mjs.map

package/dist/internal/aead.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"aead.mjs","names":[],"sources":["../../src/internal/aead.ts"],"sourcesContent":["import { Effect, Redacted, Schema } from \"effect\";\n\nimport { Aead, DecryptInput, EncryptInput } from \"../Aead\";\nimport { AuthenticationFailed, type OperationError, UnsupportedAlgorithm } from \"../Errors\";\nimport { copy, decode, importError, nativeError, nativeErrorName, withSecret } from \"./common\";\n\ninterface CipherInput {\n  readonly key: Uint8Array<ArrayBuffer>;\n  readonly nonce: Uint8Array<ArrayBuffer>;\n  readonly additionalData: Uint8Array<ArrayBuffer>;\n  readonly data: Uint8Array<ArrayBuffer>;\n}\n\nexport interface XChaCha {\n  readonly encrypt: (input: CipherInput) => Effect.Effect<Uint8Array, OperationError>;\n  readonly decrypt: (\n    input: CipherInput,\n  ) => Effect.Effect<Uint8Array, OperationError | AuthenticationFailed>;\n}\n\nconst keyBytes = Schema.Uint8Array.check(Schema.isBetweenLength(32, 32));\n\nexport const makeAead = (subtle: SubtleCrypto, xchacha?: XChaCha): Aead[\"Service\"] =>\n  Aead.of({\n    encrypt: Effect.fnUntraced(function* (input) {\n      const value = yield* decode(EncryptInput, input, \"data\");\n      const nonceLength = value.algorithm === \"AES-256-GCM\" ? 12 : 24;\n\n      yield* decode(keyBytes, Redacted.value(value.key), \"key\");\n      yield* decode(\n        Schema.Uint8Array.check(Schema.isBetweenLength(nonceLength, nonceLength)),\n        value.nonce,\n        \"nonce\",\n      );\n      if (value.algorithm === \"XChaCha20-Poly1305\" && xchacha === undefined)\n        return yield* UnsupportedAlgorithm.make({});\n      const nonce = yield* copy(value.nonce);\n      const additionalData = yield* copy(value.additionalData ?? new Uint8Array());\n\n      return yield* withSecret(value.key, (key) =>\n        withSecret(value.plaintext, (data) => {\n          if (value.algorithm === \"XChaCha20-Poly1305\") {\n            return xchacha === undefined\n              ? Effect.fail(UnsupportedAlgorithm.make({}))\n              : xchacha.encrypt({ key, nonce, additionalData, data });\n          }\n\n          return Effect.gen(function* () {\n            const imported = yield* Effect.tryPromise({\n              try: () => subtle.importKey(\"raw\", key, \"AES-GCM\", false, [\"encrypt\"]),\n              catch: importError,\n            });\n\n            const encrypted = yield* Effect.tryPromise({\n              try: () =>\n                subtle.encrypt(\n                  { name: \"AES-GCM\", iv: nonce, additionalData, tagLength: 128 },\n                  imported,\n                  data,\n                ),\n              catch: nativeError,\n            });\n\n            return new Uint8Array(encrypted);\n          }).pipe(Effect.uninterruptible);\n        }),\n      );\n    }),\n    decrypt: Effect.fnUntraced(function* (input) {\n      const value = yield* decode(DecryptInput, input, \"data\");\n      const nonceLength = value.algorithm === \"AES-256-GCM\" ? 12 : 24;\n\n      yield* decode(keyBytes, Redacted.value(value.key), \"key\");\n      yield* decode(\n        Schema.Uint8Array.check(Schema.isBetweenLength(nonceLength, nonceLength)),\n        value.nonce,\n        \"nonce\",\n      );\n      if (value.algorithm === \"XChaCha20-Poly1305\" && xchacha === undefined)\n        return yield* UnsupportedAlgorithm.make({});\n      if (value.ciphertext.length < 16) return yield* AuthenticationFailed.make({});\n      const nonce = yield* copy(value.nonce);\n      const additionalData = yield* copy(value.additionalData ?? new Uint8Array());\n      const data = yield* copy(value.ciphertext);\n\n      const plaintext = yield* withSecret(value.key, (key) => {\n        if (value.algorithm === \"XChaCha20-Poly1305\") {\n          return xchacha === undefined\n            ? Effect.fail(UnsupportedAlgorithm.make({}))\n            : xchacha.decrypt({ key, nonce, additionalData, data });\n        }\n\n        return Effect.gen(function* () {\n          const imported = yield* Effect.tryPromise({\n            try: () => subtle.importKey(\"raw\", key, \"AES-GCM\", false, [\"decrypt\"]),\n            catch: importError,\n          });\n\n          const decrypted = yield* Effect.tryPromise({\n            try: () =>\n              subtle.decrypt(\n                { name: \"AES-GCM\", iv: nonce, additionalData, tagLength: 128 },\n                imported,\n                data,\n              ),\n            // WebCrypto specifies OperationError for a rejected GCM tag.\n            catch: (cause) =>\n              nativeErrorName(cause) === \"OperationError\"\n                ? AuthenticationFailed.make({})\n                : nativeError(cause),\n          });\n\n          return new Uint8Array(decrypted);\n        }).pipe(Effect.uninterruptible);\n      });\n\n      return Redacted.make(plaintext);\n    }),\n  });\n"],"mappings":"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"}