@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/SecureRandom-B_U4ysO3.mjs

@@ -0,0 +1,279 @@
+import { Vn as effect, Xt as succeed, aa as Service, en as sync, w as clockWith } from "./Effect-CKFpqbmw.mjs";
+import { t as WebCrypto } from "./WebCrypto-ZI_GNVlw.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/ulid.js
+const maxTimestamp = 2 ** 48 - 1;
+const base32Chars = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+/** @internal */
+const ulidString = (timestampMillis, bytes) => {
+	if (bytes.length !== 10) throw new Error(`ULID randomness must be exactly 10 bytes, received ${bytes.length}`);
+	const timestamp = Math.min(Math.max(0, Math.trunc(timestampMillis)), maxTimestamp);
+	let out = "";
+	for (let shift = 45; shift >= 0; shift -= 5) out += base32Chars[Math.floor(timestamp / 2 ** shift) & 31];
+	let accumulator = 0;
+	let bits = 0;
+	for (const byte of bytes) {
+		accumulator = accumulator << 8 | byte;
+		bits += 8;
+		while (bits >= 5) {
+			bits -= 5;
+			out += base32Chars[accumulator >>> bits & 31];
+		}
+		accumulator &= (1 << bits) - 1;
+	}
+	return out;
+};
+/**
+* Makes a ULID generator in the ULID spec's monotonic mode: within a
+* millisecond, or when the clock moves back, the 80-bit random part of the last
+* ULID is incremented. The ordering ends at the maximum timestamp, 2^48 − 1 ms,
+* which overflow cannot advance. `randomBytes` is only called for fresh
+* randomness.
+*
+* @internal
+*/
+const makeMonotonic = () => {
+	let lastTimestamp = -1;
+	const random = /* @__PURE__ */ new Uint8Array(10);
+	return (timestampMillis, randomBytes) => {
+		const timestamp = timestampMillis >= 0 ? Math.min(Math.trunc(timestampMillis), maxTimestamp) : 0;
+		if (timestamp > lastTimestamp) {
+			lastTimestamp = timestamp;
+			random.set(randomBytes());
+		} else if (!increment(random)) {
+			lastTimestamp = Math.min(lastTimestamp + 1, maxTimestamp);
+			random.set(randomBytes());
+		}
+		return ulidString(lastTimestamp, random);
+	};
+};
+const increment = (bytes) => {
+	for (let i = bytes.length - 1; i >= 0; i--) {
+		if (bytes[i] !== 255) {
+			bytes[i]++;
+			return true;
+		}
+		bytes[i] = 0;
+	}
+	return false;
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/internal/uuid.js
+const hex = /*#__PURE__*/ Array.from({ length: 256 }, (_, byte) => byte.toString(16).padStart(2, "0"));
+/** @internal */
+const stringify = (bytes) => {
+	if (bytes.length < 16) return [
+		bytes.subarray(0, 4),
+		bytes.subarray(4, 6),
+		bytes.subarray(6, 8),
+		bytes.subarray(8, 10),
+		bytes.subarray(10, 16)
+	].map((segment) => Array.from(segment, (byte) => hex[byte]).join("")).join("-");
+	return hex[bytes[0]] + hex[bytes[1]] + hex[bytes[2]] + hex[bytes[3]] + "-" + hex[bytes[4]] + hex[bytes[5]] + "-" + hex[bytes[6]] + hex[bytes[7]] + "-" + hex[bytes[8]] + hex[bytes[9]] + "-" + hex[bytes[10]] + hex[bytes[11]] + hex[bytes[12]] + hex[bytes[13]] + hex[bytes[14]] + hex[bytes[15]];
+};
+/** @internal */
+const v4Bytes = (bytes) => {
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	return bytes;
+};
+const maxV7Timestamp = 2 ** 48 - 1;
+/** @internal */
+const v7Bytes = (timestampMillis, bytes) => {
+	const timestamp = Math.min(Math.max(0, Math.trunc(timestampMillis)), maxV7Timestamp);
+	bytes[0] = Math.floor(timestamp / 2 ** 40);
+	bytes[1] = Math.floor(timestamp / 2 ** 32) & 255;
+	bytes[2] = Math.floor(timestamp / 2 ** 24) & 255;
+	bytes[3] = Math.floor(timestamp / 2 ** 16) & 255;
+	bytes[4] = Math.floor(timestamp / 256) & 255;
+	bytes[5] = timestamp & 255;
+	bytes[6] = bytes[6] & 15 | 112;
+	bytes[8] = bytes[8] & 63 | 128;
+	return bytes;
+};
+const clampV7Timestamp = (timestampMillis) => timestampMillis >= 0 ? Math.min(Math.trunc(timestampMillis), maxV7Timestamp) : 0;
+const maxV7Counter = 2 ** 42 - 1;
+/**
+* Makes a UUIDv7 generator that orders the UUIDs it returns, following RFC
+* 9562 §6.2 Method 1. A 42-bit counter fills the 12 bits of `rand_a` and the
+* top 30 bits of `rand_b`; the last 32 bits stay random. The ordering ends at
+* the maximum timestamp, 2^48 − 1 ms, which counter overflow cannot advance.
+*
+* @internal
+*/
+const makeV7Monotonic = () => {
+	let lastTimestamp = -1;
+	let counter = 0;
+	return (timestampMillis, bytes) => {
+		const timestamp = clampV7Timestamp(timestampMillis);
+		if (timestamp > lastTimestamp) {
+			lastTimestamp = timestamp;
+			counter = seedV7Counter(bytes);
+		} else if (counter < maxV7Counter) counter++;
+		else {
+			lastTimestamp = Math.min(lastTimestamp + 1, maxV7Timestamp);
+			counter = seedV7Counter(bytes);
+		}
+		v7Bytes(lastTimestamp, bytes);
+		const high = Math.floor(counter / 2 ** 30);
+		const low = counter - high * 2 ** 30;
+		bytes[6] = 112 | high >>> 8;
+		bytes[7] = high & 255;
+		bytes[8] = 128 | low >>> 24;
+		bytes[9] = low >>> 16 & 255;
+		bytes[10] = low >>> 8 & 255;
+		bytes[11] = low & 255;
+		return bytes;
+	};
+};
+const seedV7Counter = (bytes) => ((bytes[6] & 7) << 8 | bytes[7]) * 2 ** 30 + ((bytes[8] & 63) << 24 | bytes[9] << 16 | bytes[10] << 8 | bytes[11]);
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/crypto/SecureRandom.js
+/**
+* Cryptographically secure randomness: random bytes, uniform integers,
+* shuffles, UUIDv4, UUIDv7, and ULIDs.
+*
+* The {@link SecureRandom} service is built from one `randomBytes` primitive
+* with {@link make}. {@link layerWebCrypto} draws from `getRandomValues` on
+* the `WebCrypto` reference. The `*Unsafe` functions draw synchronously from
+* `globalThis.crypto` for code that cannot use a service, such as constructors
+* and model defaults.
+*
+* Every operation has a `never` error channel. A bad size or an empty range is
+* a defect.
+*
+* **Gotchas**
+*
+* There are no float, boolean, or full-range integer helpers. Insecure random
+* numbers belong to `effect/Random`, and a secure bit is `randomBytes(1)`.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+/**
+* Service that generates cryptographically secure random values.
+*
+* **Details**
+*
+* Every operation is derived from `randomBytes`. See {@link make}.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+var SecureRandom = class extends (/*#__PURE__*/ Service()("effect/crypto/SecureRandom")) {};
+const checkSize = (size) => {
+	if (!Number.isSafeInteger(size) || size < 0) throw new RangeError("size must be a non-negative safe integer");
+};
+const readUint53 = (bytes) => (bytes[0] & 31) * 2 ** 48 + bytes[1] * 2 ** 40 + bytes[2] * 2 ** 32 + bytes[3] * 2 ** 24 + bytes[4] * 2 ** 16 + bytes[5] * 256 + bytes[6];
+const intBetweenUnsafe = (min, max, halfOpen, draw) => {
+	const minInt = Math.ceil(min);
+	const maxInt = Math.floor(max);
+	if (!Number.isSafeInteger(minInt) || !Number.isSafeInteger(maxInt)) throw new RangeError("bounds must round to safe integers");
+	if (maxInt - minInt < Number.MAX_SAFE_INTEGER) {
+		const count = maxInt - minInt + (halfOpen ? 0 : 1);
+		if (count <= 0) throw new RangeError("range must contain at least one integer");
+		if (count === 1) return minInt + 0;
+		const bucketSize = (2 ** 53 - 2 ** 53 % count) / count;
+		const limit = bucketSize * count;
+		while (true) {
+			const value = readUint53(draw());
+			if (value < limit) return minInt + (value - value % bucketSize) / bucketSize;
+		}
+	}
+	const lower = BigInt(minInt);
+	const count = BigInt(maxInt) - lower + (halfOpen ? BigInt(0) : BigInt(1));
+	const wide = count > BigInt(1) << BigInt(53);
+	const bucketSize = (wide ? BigInt(1) << BigInt(54) : BigInt(1) << BigInt(53)) / count;
+	const limit = bucketSize * count;
+	while (true) {
+		const bytes = draw();
+		const value = BigInt(readUint53(bytes)) + (wide && (bytes[0] & 32) !== 0 ? BigInt(1) << BigInt(53) : BigInt(0));
+		if (value < limit) return Number(lower + value / bucketSize);
+	}
+};
+const makeUuid = (bytes, randomBytes, format) => {
+	const uuid = bytes(randomBytes(16));
+	return format === "bytes" ? uuid : stringify(uuid);
+};
+/**
+* Creates a `SecureRandom` service from a secure byte source.
+*
+* **When to use**
+*
+* Use to build the service for a platform integration, a custom runtime, or a
+* seeded test double.
+*
+* **Details**
+*
+* Every operation is derived from `randomBytes`. Sizes are checked before it
+* is called, and an exception it throws is a defect. Each service orders its
+* own UUIDv7s and ULIDs, independently of other services and of the
+* `*Unsafe` functions.
+*
+* **Gotchas**
+*
+* `randomBytes` must return a fresh array of exactly `size` secure random
+* bytes. UUID formatting mutates the returned array.
+*
+* **Example** (Creating a SecureRandom service)
+*
+* ```ts import.meta.vitest
+* import { Effect } from "effect"
+* import { SecureRandom } from "effect/crypto"
+*
+* const random = SecureRandom.make((size) => globalThis.crypto.getRandomValues(new Uint8Array(size)))
+*
+* const bytes = await Effect.runPromise(random.randomBytes(4))
+* bytes.length // => 4
+* ```
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make = (randomBytes) => {
+	const randomBytesChecked = (size) => {
+		checkSize(size);
+		return randomBytes(size);
+	};
+	const draw = () => randomBytes(7);
+	const uuidV7 = makeV7Monotonic();
+	const ulid = makeMonotonic();
+	const ulidRandomBytes = () => randomBytes(10);
+	return {
+		randomBytes: (size) => sync(() => randomBytesChecked(size)),
+		intBetween: (min, max, options) => sync(() => intBetweenUnsafe(min, max, options?.halfOpen ?? false, draw)),
+		shuffle: (elements) => sync(() => {
+			const buffer = Array.from(elements);
+			for (let i = buffer.length - 1; i >= 1; i--) {
+				const index = intBetweenUnsafe(0, i, false, draw);
+				const value = buffer[i];
+				buffer[i] = buffer[index];
+				buffer[index] = value;
+			}
+			return buffer;
+		}),
+		uuidV4: (options) => sync(() => makeUuid(v4Bytes, randomBytes, options?.format)),
+		uuidV7: (options) => clockWith((clock) => sync(() => makeUuid((bytes) => uuidV7(clock.currentTimeMillisUnsafe(), bytes), randomBytes, options?.format))),
+		ulid: clockWith((clock) => sync(() => ulid(clock.currentTimeMillisUnsafe(), ulidRandomBytes)))
+	};
+};
+const fillRandom = (crypto, size) => {
+	const bytes = new Uint8Array(size);
+	for (let offset = 0; offset < size; offset += 65536) crypto.getRandomValues(bytes.subarray(offset, offset + 65536));
+	return bytes;
+};
+/**
+* Layer that provides `SecureRandom` from `getRandomValues` on the `WebCrypto`
+* reference.
+*
+* **Details**
+*
+* Requests above the 65,536-byte `getRandomValues` limit are filled in chunks.
+* Only `getRandomValues` is needed, so the layer also works in insecure browser
+* contexts, which have no `crypto.subtle`.
+*
+* @stability unstable
+* @category layers
+* @since 4.0.0
+*/
+const layerWebCrypto = /*#__PURE__*/ effect(SecureRandom, /*#__PURE__*/ WebCrypto.use((crypto) => succeed(make((size) => fillRandom(crypto, size)))));
+export { layerWebCrypto as n, SecureRandom as t };

package/dist/Semaphore-DOVJ4ZGS.mjs

@@ -0,0 +1,177 @@
+import { Sn as identity, mt as withFiber } from "./Option-DkxSnBhp.mjs";
+import { Ai as getCurrentFiber, Bi as scope, Gi as sync, Hi as succeed, Ii as onExitPrimitive, Ki as uninterruptibleMask, Li as onExitUnsafe, Oi as flatMap, Ui as succeedNone, Vi as scopeAddFinalizer, Wi as suspend, mi as callback, pi as asSome, qi as void_ } from "./Effect-CKFpqbmw.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Semaphore.js
+/**
+* Creates a `Semaphore` synchronously with the specified total
+* number of permits.
+*
+* **When to use**
+*
+* Use to construct a semaphore synchronously when an immediate value is
+* required outside an Effect workflow.
+*
+* **Example** (Creating an unsafe semaphore)
+*
+* ```ts import.meta.vitest
+* import { Effect, Semaphore } from "effect"
+*
+* const semaphore = Semaphore.makeUnsafe(3)
+*
+* const task = (id: number) =>
+*   semaphore.withPermits(1)(
+*     Effect.gen(function*() {
+*       yield* Effect.yieldNow
+*       return id
+*     })
+*   )
+*
+* // Only 3 tasks can run concurrently
+* const program = Effect.all([
+*   task(1),
+*   task(2),
+*   task(3),
+*   task(4),
+*   task(5)
+* ], { concurrency: "unbounded" })
+*
+* await Effect.runPromise(program) // => [1, 2, 3, 4, 5]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const makeUnsafe = (permits) => new SemaphoreImpl(permits);
+const firstAvailableWaiter = (self) => {
+	for (const waiter of self.waiters) if (waiter.permits <= self.free) return waiter;
+};
+const takePermits = (self, n, onAcquire, restore = identity) => withFiber((fiber) => {
+	if (self.free >= n && firstAvailableWaiter(self) === void 0) {
+		self.taken += n;
+		return onAcquire();
+	}
+	const waiter = {
+		permits: n,
+		resume: void 0
+	};
+	const remove = () => {
+		if (self.waiters.delete(waiter)) self.releaseUnsafe(fiber, 0);
+	};
+	self.waiters.add(waiter);
+	onExitUnsafe(fiber, remove);
+	const wait = restore(callback((resume) => {
+		if (firstAvailableWaiter(self) === waiter) resume(void_);
+		else waiter.resume = resume;
+	}));
+	const loop = flatMap(wait, () => {
+		if (firstAvailableWaiter(self) !== waiter) return loop;
+		self.taken += n;
+		remove();
+		return onAcquire();
+	});
+	return loop;
+});
+var SemaphoreImpl = class {
+	waiters = /*#__PURE__*/ new Set();
+	taken = 0;
+	permits;
+	constructor(permits) {
+		this.permits = permits;
+	}
+	get free() {
+		return this.permits - this.taken;
+	}
+	take(n) {
+		return takePermits(this, n, () => succeed(n));
+	}
+	takeScoped(n) {
+		return uninterruptibleMask((restore) => flatMap(scope, (scope) => takePermits(this, n, () => scopeAddFinalizer(scope, this.release(n)), restore)));
+	}
+	takeIfAvailable(n) {
+		return suspend(() => {
+			if (this.free < n) return succeed(false);
+			this.taken += n;
+			return succeed(true);
+		});
+	}
+	releaseUnsafe(fiber, n) {
+		this.taken -= n;
+		if (this.waiters.size > 0) fiber.currentDispatcher.scheduleTask(() => {
+			let remaining = this.free;
+			for (const waiter of Array.from(this.waiters)) {
+				if (!this.waiters.has(waiter) || waiter.permits > remaining) continue;
+				remaining -= waiter.permits;
+				const resume = waiter.resume;
+				waiter.resume = void 0;
+				resume?.(void_);
+			}
+		}, 0);
+		return this.free;
+	}
+	resize(permits) {
+		return withFiber((fiber) => {
+			this.permits = permits;
+			if (this.free < 0) return void_;
+			this.releaseUnsafe(fiber, 0);
+			return void_;
+		});
+	}
+	release(n) {
+		return withFiber((fiber) => succeed(this.releaseUnsafe(fiber, n)));
+	}
+	get releaseAll() {
+		return withFiber((fiber) => succeed(this.releaseUnsafe(fiber, this.taken)));
+	}
+	withPermits(n) {
+		return (self) => uninterruptibleMask((restore) => takePermits(this, n, () => onExitPrimitive(restore(self), () => {
+			this.releaseUnsafe(getCurrentFiber(), n);
+		}, true), restore));
+	}
+	withPermit = /*#__PURE__*/ this.withPermits(1);
+	withPermitsIfAvailable(n) {
+		return (self) => uninterruptibleMask((restore) => {
+			if (this.free < n) return succeedNone;
+			this.taken += n;
+			return onExitPrimitive(restore(asSome(self)), () => {
+				this.releaseUnsafe(getCurrentFiber(), n);
+			}, true);
+		});
+	}
+};
+/**
+* Creates a `Semaphore` initialized with the specified total number of permits.
+*
+* **When to use**
+*
+* Use to create a semaphore inside Effect code for bounding concurrency with
+* automatic or manual permit management.
+*
+* **Example** (Creating a semaphore)
+*
+* ```ts import.meta.vitest
+* import { Effect, Semaphore } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const semaphore = yield* Semaphore.make(2)
+*
+*   const task = (id: number) =>
+*     semaphore.withPermits(1)(
+*       Effect.gen(function*() {
+*         yield* Effect.yieldNow
+*         return id
+*       })
+*     )
+*
+*   // Run 4 tasks, but only 2 can run concurrently
+*   return yield* Effect.all([task(1), task(2), task(3), task(4)])
+* })
+*
+* await Effect.runPromise(program) // => [1, 2, 3, 4]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const make = (permits) => sync(() => new SemaphoreImpl(permits));
+export { makeUnsafe as n, make as t };

package/dist/Stdio-KylmOBX_.mjs

@@ -0,0 +1,74 @@
+import { Xt as succeed, aa as Service } from "./Effect-CKFpqbmw.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Stdio.js
+/**
+* Service contract for command-line arguments and standard input, output, and
+* error output. It lets programs depend on standard I/O through the Effect
+* environment instead of reading from or writing to global process handles
+* directly.
+*
+* The service exposes arguments as an `Effect`, stdout and stderr as `Sink`s
+* that accept strings or bytes, and stdin as a byte `Stream`. This module also
+* provides a constructor for service values and a small test layer with
+* overridable defaults.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+/**
+* Runtime identifier stored on `Stdio` service implementations.
+*
+* **Details**
+*
+* This marker is part of the runtime representation of `Stdio` service
+* implementations.
+*
+* @stability unstable
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId = "~effect/Stdio";
+/**
+* Service tag for process standard I/O.
+*
+* **When to use**
+*
+* Use when you need command-line arguments or standard I/O streams supplied by
+* an effect's environment.
+*
+* @see {@link make} for constructing a `Stdio` service directly
+* @see {@link layerTest} for a test layer with defaults and overrides
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+const Stdio = /*#__PURE__*/ Service(TypeId);
+/**
+* Creates a `Stdio` service implementation from the provided fields and
+* attaches the `Stdio` type identifier.
+*
+* **When to use**
+*
+* Use when you need to assemble a concrete `Stdio` service from command-line
+* arguments and standard I/O implementations.
+*
+* **Details**
+*
+* The returned service reuses the supplied fields unchanged and adds the
+* `Stdio` type identifier. Omitted terminal-detection fields default to
+* effects that succeed with `false`.
+*
+* @see {@link layerTest} for a test layer with default fields that can be overridden
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make = (options) => ({
+	[TypeId]: TypeId,
+	stdinIsTerminal: succeed(false),
+	stdoutIsTerminal: succeed(false),
+	stderrIsTerminal: succeed(false),
+	...options
+});
+export { make as n, Stdio as t };