@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/akter.cli.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { t as runAkter } from "./akter-program.config-C4cXx4Fr.mjs";
+// src/akter.cli.ts
+runAkter();
+export {};

package/dist/app-cli.config.mjs

@@ -0,0 +1,49 @@
+import { B as flatMap, Gt as scoped } from "./Effect-CKFpqbmw.mjs";
+import { r as withDescription, t as String } from "./Argument-D81dqizB.mjs";
+import { c as Int, f as optional, i as withDescription$2, l as String$1, m as withDescription$1, o as Boolean, p as withDefault, t as make } from "./Command-Dzq9KM-h.mjs";
+import { exportArchive, importApp, importInto } from "./archive/archive-cli.config.mjs";
+import { Bench } from "./bench/bench.service.mjs";
+import { Credentials } from "./credentials/credentials.service.mjs";
+import { Deployment } from "./deploy/deploy.service.mjs";
+import { ActorExport } from "./export/actor-export.service.mjs";
+// src/app-cli.config.ts
+const entry = String$1("entry").pipe(withDefault("src/app.layer.ts"), withDescription$1("The module that exports app = { actors, layer }"));
+const workers = 8;
+const organization = String$1("organization").pipe(optional, withDescription$1("The organization; defaults to AKTER_ORGANIZATION, then the one saved by akter login"));
+const url = String$1("url").pipe(optional, withDescription$1("The Cloud API's URL; defaults to AKTER_CLOUD_URL, then the one saved by akter login, then https://api.akter.dev"));
+const deploy = make("deploy", {
+	app: String$1("app"),
+	domain: String$1("domain").pipe(optional, withDescription$1("Claim this customer hostname and print the CNAME to add")),
+	entry,
+	environment: String$1("environment").pipe(withDefault("prod")),
+	json: Boolean("json").pipe(withDefault(false), withDescription$1("Print the live deploy as one line of JSON in the API's Deploy schema; progress goes to stderr")),
+	organization,
+	url
+}, (options) => flatMap(Credentials.use((credentials) => credentials.target(options)), (target) => Deployment.use((service) => service.run({
+	...options,
+	...target
+})).pipe(scoped))).pipe(withDescription$2("Build the app, upload it and follow the deploy until it serves or fails"));
+const exportApp = make("export", {
+	app: String$1("app").pipe(withDescription$1("The app whose actors to export")),
+	organization,
+	out: String$1("out").pipe(withDescription$1("The .akter archive to write; run again with the same path to resume")),
+	url
+}, (options) => flatMap(Credentials.use((credentials) => credentials.target(options)), (target) => exportArchive({
+	out: options.out,
+	write: (staging) => ActorExport.use((service) => service.run({
+		...options,
+		...target,
+		out: staging
+	})).pipe(scoped)
+}))).pipe(withDescription$2("Download every actor of an app into one .akter archive, resuming where a run stopped"));
+const bench = make("bench", {
+	concurrency: Int("concurrency").pipe(withDefault(workers), withDescription$1("How many steps run at once, each waiting for its last to finish")),
+	duration: String$1("duration").pipe(withDefault("30s"), withDescription$1("How long to start new steps, like 30s or 5m; steps in flight then finish")),
+	entry,
+	json: Boolean("json").pipe(withDefault(false), withDescription$1("Print the report as one JSON object")),
+	stepTimeout: String$1("step-timeout").pipe(withDefault("30s"), withDescription$1("How long the workload's open and each step may take before it counts as failed, so one stuck step can't hold the run open")),
+	system: String$1("system").pipe(optional, withDescription$1("Another system to run the workload against for comparison, such as \"Cloudflare Durable Object\"; it needs --url, and akter bench signs in to nothing")),
+	url: String$1("url").pipe(optional, withDescription$1("The app to run against: a loopback akter dev, or an Akter Cloud app signed in to with AKTER_API_KEY or akter login. Without it, akter bench starts akter dev on an empty folder")),
+	workload: String("workload").pipe(withDescription("The module that exports workload = ({ id }) => ({ name, open, step })"))
+}, (options) => Bench.use((service) => service.run(options)).pipe(scoped)).pipe(withDescription$2("Run a workload against akter dev or an Akter Cloud app and report throughput and latency"));
+export { bench, deploy, entry, exportApp, importApp, importInto };

package/dist/app-entry.pure.mjs

@@ -0,0 +1,31 @@
+// src/app-entry.pure.ts
+const typeScriptImports = [
+	"import * as nodeModule from \"node:module\";",
+	"",
+	"if (process.versions.bun === undefined) {",
+	"  nodeModule.registerHooks({",
+	"    resolve: (specifier, context, nextResolve) => {",
+	"      try {",
+	"        return nextResolve(specifier, context);",
+	"      } catch (error) {",
+	"        const typeScriptImport = /^[.#]/u.test(specifier) && specifier.endsWith(\".js\") && context.parentURL?.endsWith(\".ts\");",
+	"        if (error?.code !== \"ERR_MODULE_NOT_FOUND\" || !typeScriptImport) throw error;",
+	"        return nextResolve(specifier.slice(0, -\".js\".length) + \".ts\", context);",
+	"      }",
+	"    },",
+	"  });",
+	"}"
+];
+const appEntry = ({ command, entry }) => [
+	...typeScriptImports,
+	"",
+	`const entry = await import(${entry});`,
+	"",
+	"if (!(\"app\" in entry)) {",
+	`  console.error("akter ${command}: " + ${entry} + " has no app export. Export the app as: export const app = { actors, layer };");`,
+	"  process.exit(1);",
+	"}",
+	"",
+	"const { app } = entry;"
+];
+export { appEntry, typeScriptImports };

package/dist/archive/akter-archive.schema.mjs

@@ -0,0 +1,65 @@
+import { Dt as isGreaterThanOrEqualTo, F as String, I as Struct, an as optionalKey, g as Finite, n as ArraySchema, pt as fromJsonString, qt as isPattern, v as Int, x as Literal } from "../Schema-MiKt5K1v.mjs";
+// src/archive/akter-archive.schema.ts
+/** The format version this akter writes. Every version it ever wrote stays readable (ADR 0019). */
+const archiveFormat = 1;
+const noBytes = 0;
+const sha256Pattern = /^[0-9a-f]{64}$/u;
+const manifestPath = "manifest.json";
+/** Where an export leaves the app's computers in its staging folder; packing moves them into the manifest. */
+const computersPath = "computers.json";
+const Sha256 = String.check(isPattern(sha256Pattern));
+/** One archive entry after the manifest, with the size and SHA-256 its bytes must have. */
+const ArchiveEntry = Struct({
+	bytes: Int.check(isGreaterThanOrEqualTo(noBytes)),
+	path: String,
+	sha256: Sha256
+});
+/** An actor as export paths name it: its type and its encoded key. */
+const ArchivedActor = Struct({
+	key: String,
+	type: String
+});
+/**
+* A forked actor and the actor it was forked from: `fork` is the fork's id and `forkedAt` the parent's commit version
+* at the cut. Every archive written before forks had an empty lineage, so adding `fork` kept format 1 (ADR 0019).
+*/
+const ArchivedLineage = Struct({
+	actor: ArchivedActor,
+	fork: String,
+	forkedAt: Int,
+	parent: ArchivedActor
+});
+/** An Archil checkpoint: it can't leave the account, so it is never portable. */
+const ArchivedCheckpoint = Struct({
+	id: String,
+	portable: Literal(false)
+});
+/**
+* A computer an actor owns, as Akter Cloud records it. Its disk stays in the Cloud: the newest checkpoint, when it
+* has one, is an Archil checkpoint, which can't leave the account, so it is recorded but never portable. `egress`
+* names allowed destinations, never credentials.
+*/
+const ArchivedComputer = Struct({
+	actor: ArchivedActor,
+	checkpoint: optionalKey(ArchivedCheckpoint),
+	egress: ArraySchema(String),
+	image: String,
+	name: String,
+	size: Struct({
+		memoryMib: Int,
+		vcpu: Finite
+	})
+});
+/** Only the version, read first, so an archive from a newer akter is refused by name instead of by shape. */
+const ArchiveVersion = fromJsonString(Struct({ format: Int }));
+/** `manifest.json`, the first entry of every `.akter` archive. */
+const ArchiveManifest = Struct({
+	computers: ArraySchema(ArchivedComputer),
+	createdAt: Int,
+	entries: ArraySchema(ArchiveEntry),
+	format: Literal(1),
+	lineage: ArraySchema(ArchivedLineage)
+});
+const ArchiveManifestJson = fromJsonString(ArchiveManifest);
+const ArchivedComputersJson = fromJsonString(ArraySchema(ArchivedComputer));
+export { ArchiveEntry, ArchiveManifest, ArchiveManifestJson, ArchiveVersion, ArchivedComputer, ArchivedComputersJson, ArchivedLineage, archiveFormat, computersPath, manifestPath };

package/dist/archive/akter-archive.service.mjs

@@ -0,0 +1,309 @@
+import { T as join, c as every, j as map, z as sort } from "../Array-B4kuTQeW.mjs";
+import { P as currentTimeMillis } from "../HttpClientResponse-D5ZKICVV.mjs";
+import { At as provideContext, B as flatMap, Gn as mergeAll, Gt as scoped, I as filter, K as forEach, Kn as provide$1, M as fail, Mr as void_, Q as fromOption, Qn as close, T as context, Vn as effect, W as fnUntraced, Wt as scope, Xt as succeed, aa as Service, dt as map$1, er as fork, et as gen, ft as mapBoth, gn as void_$1, ht as mapError, ir as provide, l as as, lt as logWarning, nn as tapCause, o as andThen, tn as tap, tt as ignore, xt as onError } from "../Effect-CKFpqbmw.mjs";
+import { t as FileSystem } from "../FileSystem-4pPcEb_i.mjs";
+import { a as BlobHashing, d as get, f as isEmpty, l as empty, n as ArchivedActors, p as remove, r as blobHashing, t as ArchivedStore, u as fromIterable } from "../hosted-runtime.layer-Cx3IPsEd.mjs";
+import { S as none, _ as isSome, h as isNone, w as some, x as match } from "../Option-DkxSnBhp.mjs";
+import { a as String$1 } from "../Order-C1JC991I.mjs";
+import { t as Path } from "../Path-Djdv_eF5.mjs";
+import { mt as is, st as encodeEffect, tt as decodeEffect } from "../Schema-MiKt5K1v.mjs";
+import { D as mapAccum, O as mapEffect, T as make, U as runFoldEffect, W as runForEach, k as mapError$1, m as flatMap$1, nt as unwrap, r as concat$1, y as fromIterable$1, z as run } from "../Stream-bK9QIETN.mjs";
+import { h as startsWith, i as includes, m as split, r as endsWith } from "../String-q5dcsVe4.mjs";
+import { ArchiveInvalidError } from "./archive-invalid.errors.mjs";
+import { ArchiveManifestJson, ArchiveVersion, ArchivedComputersJson, computersPath, manifestPath } from "./akter-archive.schema.mjs";
+import { parentOf } from "./archived-lineage.pure.mjs";
+import { tarEnd, tarEntry, untar } from "./tar.pure.mjs";
+import { Zstd } from "./zstd.adapter.mjs";
+// src/archive/akter-archive.service.ts
+/** The manifest of an archive holding thousands of actors stays far below this; a larger one is not ours. */
+const largestManifest = 67108864;
+const readBytes = 65536;
+const noBytes = 0;
+const ownerOnlyFile = 384;
+const ownerOnlyFolder = 448;
+const encoder = new globalThis.TextEncoder();
+const invalid = (message) => ArchiveInvalidError.make({ message });
+const failed = (doing) => (cause) => invalid(`${doing}: ${cause.message}`);
+/** Partial downloads of the staging folder and its computers, which the manifest holds, are never archived as entries. */
+const isStaging = (name) => name === "computers.json" || endsWith(".export")(name) || endsWith(".export.json")(name);
+/** A safe relative path inside the folder: no absolute path, no `..`, no backslash, no empty segment. */
+const isSafe = (path) => !startsWith("/")(path) && !includes("\\")(path) && every(split("/")(path), (part) => part !== "" && part !== "..");
+const hashed = fnUntraced(function* hashed(folder, name) {
+	const fileSystem = yield* FileSystem;
+	const path = yield* Path;
+	const hash = yield* BlobHashing.use((hashing) => hashing.sha256);
+	const file = path.join(folder, name);
+	const stats = yield* fileSystem.stat(file);
+	yield* runForEach(fileSystem.stream(file, { chunkSize: readBytes }), hash.update);
+	const sha256 = yield* hash.digest;
+	return {
+		bytes: Number(stats.size),
+		path: join(split(path.sep)(name), "/"),
+		sha256
+	};
+});
+const filesIn = fnUntraced(function* filesIn(folder) {
+	const fileSystem = yield* FileSystem;
+	const path = yield* Path;
+	const names = yield* fileSystem.readDirectory(folder, { recursive: true });
+	const kept = (name) => !isStaging(name) && !ArchivedStore.isEnvironmentEntry(join(split(path.sep)(name), "/"));
+	const files = yield* filter(names, (name) => map$1(fileSystem.stat(path.join(folder, name)), (stats) => stats.type === "File" && kept(name)));
+	return sort(files, String$1);
+});
+/** An entry's content, refused if the file changed size after it was hashed, so a header never lies about a size. */
+const exactly = (entry, content) => content.pipe(mapAccum(() => noBytes, (total, chunk) => [total + chunk.length, [{
+	chunk,
+	final: false,
+	total: total + chunk.length
+}]], { onHalt: (total) => [{
+	chunk: /* @__PURE__ */ new Uint8Array(),
+	final: true,
+	total
+}] }), mapEffect(({ chunk, final, total }) => {
+	if (total > entry.bytes || final && total !== entry.bytes) return fail(invalid(`${entry.path} changed size while it was archived; archive again`));
+	return succeed(chunk);
+}));
+const contentOf = fnUntraced(function* contentOf(folder, entry) {
+	const fileSystem = yield* FileSystem;
+	const path = yield* Path;
+	const read = fileSystem.stream(path.join(folder, entry.path), { chunkSize: readBytes });
+	const content = exactly(entry, mapError$1(read, failed(entry.path)));
+	return tarEntry({
+		content,
+		path: entry.path,
+		size: entry.bytes
+	});
+});
+/** The computers the export left in the staging folder, or none when the app has none or the export recorded none. */
+const computersIn = fnUntraced(function* computersIn(folder) {
+	const fileSystem = yield* FileSystem;
+	const file = (yield* Path).join(folder, computersPath);
+	if (!(yield* fileSystem.exists(file))) return [];
+	const text = yield* fileSystem.readFileString(file);
+	return yield* mapError(decodeEffect(ArchivedComputersJson)(text), failed(`${computersPath} is invalid`));
+});
+const lineageEntry = ({ actor, fork, forkedAt, origin }) => match(parentOf(origin), {
+	onNone: () => fail(invalid(`${actor.type}/${actor.key} names the actor it was forked from as ${origin}, not as <Actor>/<key>`)),
+	onSome: (parent) => succeed({
+		actor,
+		fork,
+		forkedAt,
+		parent
+	})
+});
+/** Each forked actor's parent, the fork's id and the version at the cut, as the actors' databases record them. */
+const lineageIn = fnUntraced(function* lineageIn(folder) {
+	const forks = yield* ArchivedActors.lineage(folder).pipe(tapCause(logWarning), mapError(() => invalid("its actors' fork lineage could not be read")));
+	return yield* forEach(forks, lineageEntry);
+});
+const storeOf = (folder) => mapError(ArchivedStore.served(folder), failed("its environments record could not be read"));
+const manifestFor = fnUntraced(function* manifestFor(folder) {
+	const store = yield* storeOf(folder);
+	const names = yield* filesIn(store);
+	const entries = yield* forEach(names, (name) => hashed(store, name));
+	const computers = yield* computersIn(store);
+	const lineage = yield* lineageIn(store);
+	const manifest = {
+		computers,
+		createdAt: yield* currentTimeMillis,
+		entries,
+		format: 1,
+		lineage
+	};
+	const manifestText = yield* encodeEffect(ArchiveManifestJson)(manifest);
+	return {
+		header: encoder.encode(manifestText),
+		manifest,
+		store
+	};
+});
+const packed = fnUntraced(function* packed({ archive, folder }) {
+	const fileSystem = yield* FileSystem;
+	const zstd = yield* Zstd;
+	const { header, manifest, store } = yield* manifestFor(folder);
+	const first = tarEntry({
+		content: make(header),
+		path: manifestPath,
+		size: header.length
+	});
+	const rest = flatMap$1(fromIterable$1(manifest.entries), (entry) => unwrap(contentOf(store, entry)));
+	const tar = concat$1(concat$1(first, rest), tarEnd);
+	yield* run(zstd.compress(tar), fileSystem.sink(`${archive}.partial`, { mode: ownerOnlyFile }));
+	yield* fileSystem.rename(`${archive}.partial`, archive);
+	return manifest;
+});
+/**
+* Writes `folder` (the staging layout: `shards/<shard>/<Actor>/<key>/actor.db` and each actor's files) as one `.akter`
+* archive. A local data directory is packed as the one environment it serves: the folder itself for `dev`, or a
+* promoted branch's store, and never its record, its snapshots or another environment. It is a zstd-compressed tar
+* whose first entry is `manifest.json` with every entry's size and SHA-256. The archive is written beside its final
+* name and renamed only when complete, so a cut run never leaves a file that looks done.
+*/
+const pack = ({ archive, folder }) => mapError(packed({
+	archive,
+	folder
+}), (cause) => {
+	if (is(ArchiveInvalidError)(cause)) return cause;
+	return invalid(`could not write ${archive}: ${cause.message}`);
+});
+const concat = (left, right) => {
+	const joined = new Uint8Array(left.length + right.length);
+	joined.set(left);
+	joined.set(right, left.length);
+	return joined;
+};
+const finishWriting = (writing) => flatMap(tap(writing.hash.digest, close(writing.scope, void_)), (sha256) => {
+	if (writing.written !== writing.entry.bytes || sha256 !== writing.entry.sha256) return fail(invalid(`${writing.entry.path} does not match its checksum in the manifest`));
+	return void_$1;
+});
+const finishEntry = (state) => match(state.writing, {
+	onNone: () => succeed(state),
+	onSome: (writing) => as(finishWriting(writing), {
+		...state,
+		writing: none()
+	})
+});
+const manifestOf = fnUntraced(function* manifestOf(bytes) {
+	const text = new globalThis.TextDecoder().decode(bytes);
+	const { format } = yield* mapError(decodeEffect(ArchiveVersion)(text), () => invalid("its manifest.json is not JSON"));
+	if (format > 1) return yield* invalid(`it is format ${String(format)}, written by a newer akter; upgrade akter to read it`);
+	return yield* mapError(decodeEffect(ArchiveManifestJson)(text), failed("its manifest.json is invalid"));
+});
+const settleManifest = (state) => match(state.collected, {
+	onNone: () => succeed(state),
+	onSome: (bytes) => map$1(manifestOf(bytes), (manifest) => ({
+		...state,
+		collected: none(),
+		expected: fromIterable(map(manifest.entries, (entry) => [entry.path, entry])),
+		manifest: some(manifest)
+	}))
+});
+const startWriting = fnUntraced(function* startWriting(folder, entry) {
+	const fileSystem = yield* FileSystem;
+	const path = yield* Path;
+	const target = path.join(folder, entry.path);
+	const scope$1 = yield* flatMap(scope, (parent) => fork(parent, "sequential"));
+	yield* fileSystem.makeDirectory(path.dirname(target), {
+		mode: ownerOnlyFolder,
+		recursive: true
+	});
+	return {
+		entry,
+		file: yield* provide(fileSystem.open(target, {
+			flag: "wx",
+			mode: ownerOnlyFile
+		}), scope$1),
+		hash: yield* BlobHashing.use((hashing) => hashing.sha256),
+		scope: scope$1,
+		written: noBytes
+	};
+});
+const onEntry = (state, { folder, path, size }) => {
+	if (isNone(state.manifest)) {
+		if (path !== "manifest.json" || size > largestManifest) return fail(invalid("its first entry is not manifest.json"));
+		return succeed({
+			...state,
+			collected: some(/* @__PURE__ */ new Uint8Array())
+		});
+	}
+	const expected = get(state.expected, path);
+	if (isNone(expected) || !isSafe(path) || expected.value.bytes !== size) return fail(invalid(`${path} is not an entry its manifest lists`));
+	return mapBoth(startWriting(folder, expected.value), {
+		onFailure: failed(path),
+		onSuccess: (writing) => ({
+			...state,
+			expected: remove(state.expected, path),
+			writing: some(writing)
+		})
+	});
+};
+const onData = (state, bytes) => {
+	if (isSome(state.collected)) return succeed({
+		...state,
+		collected: some(concat(state.collected.value, bytes))
+	});
+	return match(state.writing, {
+		onNone: () => fail(invalid("it holds bytes outside any entry")),
+		onSome: (writing) => {
+			const written = andThen(mapError(writing.file.writeAll(bytes), failed(writing.entry.path)), writing.hash.update(bytes));
+			return as(written, {
+				...state,
+				writing: some({
+					...writing,
+					written: writing.written + bytes.length
+				})
+			});
+		}
+	});
+};
+const onEnd = (state) => {
+	if (isNone(state.manifest) || !isEmpty(state.expected)) return fail(invalid("it ends before every entry its manifest lists"));
+	return succeed(state);
+};
+const step = (folder) => (state, event) => {
+	if (event.kind === "data") return onData(state, event.bytes);
+	if (event.kind === "truncated") return fail(invalid("it is cut short"));
+	if (event.kind === "invalid") return fail(invalid(event.reason));
+	const settled = flatMap(finishEntry(state), settleManifest);
+	if (event.kind === "end") return flatMap(settled, onEnd);
+	return flatMap(settled, (next) => onEntry(next, {
+		folder,
+		path: event.path,
+		size: event.size
+	}));
+};
+const emptyState = {
+	collected: none(),
+	expected: empty(),
+	manifest: none(),
+	writing: none()
+};
+/** Reads every entry of `archive` into `folder`, checking each against the manifest. */
+const entriesInto = fnUntraced(function* entriesInto({ archive, folder }) {
+	const fileSystem = yield* FileSystem;
+	const zstd = yield* Zstd;
+	const read = mapError$1(fileSystem.stream(archive, { chunkSize: readBytes }), failed(archive));
+	return yield* runFoldEffect(untar(zstd.decompress(read)), () => emptyState, step(folder));
+});
+const unpacked = fnUntraced(function* unpacked({ archive, folder }) {
+	const fileSystem = yield* FileSystem;
+	const staging = `${folder}.importing`;
+	if (yield* fileSystem.exists(folder)) return yield* invalid(`${folder} already exists; import into a new folder`);
+	const removeStaging = ignore(fileSystem.remove(staging, {
+		force: true,
+		recursive: true
+	}));
+	yield* removeStaging;
+	const adopted = gen(function* adoptedEntries() {
+		const done = yield* entriesInto({
+			archive,
+			folder: staging
+		});
+		const manifest = yield* mapError(fromOption(done.manifest), () => invalid("it holds no manifest.json"));
+		yield* ArchivedActors.adopt(staging).pipe(tapCause(logWarning), mapError(() => invalid("its actors' files could not be taken into the folder's file home")));
+		return manifest;
+	});
+	const manifest = yield* onError(adopted, () => removeStaging);
+	return yield* as(fileSystem.rename(staging, folder), manifest);
+});
+/**
+* Reads an `.akter` archive into a new folder in the staging layout, which `akter dev` serves. Every entry is checked
+* against the size and SHA-256 its manifest records, and an entry the manifest doesn't list is refused. Each actor's
+* `files/<sha256>` is then adopted into the folder's file home under the actor's local identity. The folder appears
+* only once every entry has passed and every file is adopted, so a cut or altered archive never leaves a folder that
+* looks imported.
+*/
+const unpack = ({ archive, folder }) => mapError(unpacked({
+	archive,
+	folder
+}), (cause) => {
+	if (is(ArchiveInvalidError)(cause)) return ArchiveInvalidError.make({ message: `${archive} can't be imported: ${cause.message}` });
+	return invalid(`${archive} can't be imported: ${cause.message}`);
+});
+var AkterArchive = class extends Service()("@akterjs/cli/archive/akter-archive.service/AkterArchive", { make: map$1(context(), (context) => ({
+	pack: (packing) => provideContext(scoped(pack(packing)), context),
+	unpack: (packing) => provideContext(scoped(unpack(packing)), context)
+})) }) {
+	static layer = effect(this, this.make).pipe(provide$1(mergeAll(Zstd.layer, blobHashing)));
+};
+export { AkterArchive };

package/dist/archive/archive-cli.config.mjs

@@ -0,0 +1,45 @@
+import { l as filter } from "../Array-B4kuTQeW.mjs";
+import { n as log } from "../Console-BKHUkH6a.mjs";
+import { R as filterOrFail, U as fn, W as fnUntraced, Xt as succeed } from "../Effect-CKFpqbmw.mjs";
+import { t as FileSystem } from "../FileSystem-4pPcEb_i.mjs";
+import { t as Path } from "../Path-Djdv_eF5.mjs";
+import { r as withDescription, t as String$1 } from "../Argument-D81dqizB.mjs";
+import { i as withDescription$2, l as String$2, m as withDescription$1, p as withDefault, t as make } from "../Command-Dzq9KM-h.mjs";
+import { AkterArchive } from "./akter-archive.service.mjs";
+import { ArchiveInvalidError } from "./archive-invalid.errors.mjs";
+// src/archive/archive-cli.config.ts
+const actorDatabase = /^shards\/\d{3}\/[^/]+\/[^/]+\/actor\.db$/u;
+/** Reads an `.akter` archive into a new folder that `akter dev`, `akter history` and `akter migrate` read. */
+const importInto = fn("importInto")(function* importInto({ archive, dir }) {
+	const path = yield* Path;
+	const folder = path.resolve(dir);
+	const manifest = yield* AkterArchive.use((archives) => archives.unpack({
+		archive: path.resolve(archive),
+		folder
+	}));
+	const actors = filter(manifest.entries, (entry) => actorDatabase.test(entry.path)).length;
+	yield* log(`Imported ${String(actors)} actors (${String(manifest.entries.length)} entries) into ${folder}`);
+	return manifest;
+});
+/**
+* Writes an app's actors into `<out>.staging` with `write`, the folder layout a rerun resumes, then packs that folder
+* into the archive at `out` and removes it. The archive appears only once it is complete.
+*/
+const exportArchive = fnUntraced(function* exportArchive({ out, write }) {
+	const fileSystem = yield* FileSystem;
+	const archive = yield* Path.use((path) => succeed(path.resolve(out)));
+	const staging = `${archive}.staging`;
+	yield* filterOrFail(fileSystem.exists(archive), (exists) => !exists, () => ArchiveInvalidError.make({ message: `${archive} already exists; export to a new file` }));
+	yield* write(staging);
+	const manifest = yield* AkterArchive.use((archives) => archives.pack({
+		archive,
+		folder: staging
+	}));
+	yield* fileSystem.remove(staging, { recursive: true });
+	yield* log(`Wrote ${archive} with ${String(manifest.entries.length)} entries`);
+});
+const importApp = make("import", {
+	archive: String$1("archive").pipe(withDescription("The .akter archive akter export wrote")),
+	dir: String$2("dir").pipe(withDefault(".akter"), withDescription$1("A new folder to read the actors into; it must not exist yet"))
+}, importInto).pipe(withDescription$2("Read an .akter archive into a folder, checking every entry against its manifest"));
+export { exportArchive, importApp, importInto };

package/dist/archive/archive-invalid.errors.mjs

@@ -0,0 +1,5 @@
+import { F as String, z as TaggedError } from "../Schema-MiKt5K1v.mjs";
+// src/archive/archive-invalid.errors.ts
+/** An `.akter` archive that can't be written or read as one: cut short, corrupt, mismatched or from a newer akter. */
+var ArchiveInvalidError = class extends TaggedError()("ArchiveInvalidError", { message: String }) {};
+export { ArchiveInvalidError };

package/dist/archive/archived-lineage.pure.mjs

@@ -0,0 +1,13 @@
+import { t as all, u as fromNullishOr } from "../Option-DkxSnBhp.mjs";
+// src/archive/archived-lineage.pure.ts
+/** Akter Cloud names a fork's parent `<Actor>/<keySegment>`, with the key encoded as its folder name. */
+const cloudIdentity = /^(?<type>[^/:]+)\/(?<key>[^/]+)$/u;
+/** The parent a Cloud actor's `fork.origin` names, or none when it is not in Cloud's `<Actor>/<keySegment>` form. */
+const parentOf = (origin) => {
+	const groups = cloudIdentity.exec(origin)?.groups;
+	return all({
+		key: fromNullishOr(groups?.key),
+		type: fromNullishOr(groups?.type)
+	});
+};
+export { parentOf };