@graftland/plugin-remote 0.3.3 → 0.4.0

package/dist/Packages-AgoCGotL.js

@@ -1,108 +0,0 @@
-import { c as PackageError } from "./Peer-DXeVrGBh.js";
-import { Array, Cause, Context, Duration, Effect, FileSystem, Order, Path, Schema, Stream, String } from "effect";
-import process from "node:process";
-import { fileURLToPath } from "node:url";
-import { ChildProcess, ChildProcessSpawner } from "effect/process";
-import { createHash } from "node:crypto";
-// packages/remote/src/internal/config.ts
-const PositiveDuration = Schema.DurationFromString.check(Schema.makeFilter((value) => Duration.isFinite(value) && Duration.toMillis(value) > 0, { expected: "a finite, positive duration" }));
-// packages/remote/src/internal/Supervisor.ts
-/** A listener hands an authenticated byte channel to the supervisor. */
-var Supervisor = class extends Context.Service()("@graftland/plugin-remote/internal/Supervisor") {};
-// packages/remote/src/internal/runner/Packages.ts
-const Manifest = Schema.Struct({
-	name: Schema.String,
-	version: Schema.String
-});
-const verify = (actual, expected = {}) => expected.version !== void 0 && actual.version !== expected.version ? Effect.fail(PackageError.make({ detail: `Package version mismatch: expected ${expected.version}, received ${actual.version}` })) : expected.digest !== void 0 && actual.digest !== expected.digest ? Effect.fail(PackageError.make({ detail: `Package digest mismatch: expected ${expected.digest}, received ${actual.digest}` })) : Effect.void;
-/** A path-sensitive SHA-256 of sorted entries and bytes, excluding every node_modules subtree. */
-const digest = Effect.fnUntraced(function* (directory) {
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const hash = yield* Effect.sync(() => createHash("sha256").update("graft-package-sha256-v1\0"));
-	const visit = Effect.fnUntraced(function* (relative) {
-		const filename = path.join(directory, relative);
-		const info = yield* fs.stat(filename);
-		if (info.type !== "File" && info.type !== "Directory") return yield* PackageError.make({ detail: `Unsupported package entry: ${relative}` });
-		const name = new TextEncoder().encode(relative);
-		yield* Effect.sync(() => {
-			hash.update(`${info.type}:${name.byteLength}:${info.type === "File" ? info.size : 0}:`);
-			hash.update(name);
-		});
-		if (info.type === "File") yield* fs.stream(filename).pipe(Stream.runForEach((bytes) => Effect.sync(() => {
-			hash.update(bytes);
-		})));
-		else {
-			const entries = yield* fs.readDirectory(filename);
-			for (const entry of Array.sort(entries, Order.String)) {
-				if (entry === "node_modules") continue;
-				yield* visit(relative === "" ? entry : `${relative}/${entry}`);
-			}
-		}
-	});
-	yield* visit("");
-	return yield* Effect.sync(() => hash.digest("hex"));
-});
-/**
-* Resolve using Node's import conditions without importing executable package code.
-* The helper's cwd is the installation root and it inherits no NODE_OPTIONS/loaders.
-* The installation directory and its package exports are trusted.
-*/
-const resolve = Effect.fnUntraced(function* (root, specifier, includeDigest = false) {
-	const segments = String.split(specifier, "/");
-	const scoped = String.startsWith("@")(specifier);
-	const name = Array.join(Array.take(segments, scoped ? 2 : 1), "/");
-	const fs = yield* FileSystem.FileSystem;
-	const path = yield* Path.Path;
-	const installation = yield* fs.realPath(root);
-	const directory = yield* fs.realPath(path.join(installation, "node_modules", name));
-	const manifest = yield* fs.readFileString(path.join(directory, "package.json")).pipe(Effect.flatMap(Schema.decodeEffect(Schema.fromJsonString(Manifest))));
-	const resolved = yield* resolveEntry(installation, specifier);
-	const filename = yield* Effect.try({
-		try: () => fileURLToPath(resolved),
-		catch: (error) => PackageError.make({
-			detail: "The package export is not a file URL",
-			cause: Cause.die(error)
-		})
-	});
-	return {
-		directory,
-		entry: yield* fs.realPath(filename),
-		identity: {
-			...manifest,
-			...includeDigest ? { digest: yield* digest(directory) } : {}
-		}
-	};
-}, Effect.catchTags({
-	PlatformError: (error) => Effect.fail(PackageError.make({
-		detail: "Reading the installed package failed",
-		cause: Cause.fail(error)
-	})),
-	SchemaError: (error) => Effect.fail(PackageError.make({
-		detail: "Reading the package manifest failed",
-		cause: Cause.fail(error)
-	}))
-}));
-const resolveEntry = Effect.fnUntraced(function* (installation, specifier) {
-	const child = yield* (yield* ChildProcessSpawner.ChildProcessSpawner).spawn(ChildProcess.make(process.execPath, [
-		"--input-type=module",
-		"--eval",
-		"process.stdout.write(import.meta.resolve(process.argv[1]))",
-		"--",
-		specifier
-	], {
-		cwd: installation,
-		env: {},
-		stdin: "ignore",
-		stdout: "pipe",
-		stderr: "pipe"
-	}));
-	const [code, stdout, stderr] = yield* Effect.all([
-		child.exitCode,
-		child.stdout.pipe(Stream.decodeText(), Stream.mkString),
-		child.stderr.pipe(Stream.decodeText(), Stream.mkString)
-	], { concurrency: "unbounded" });
-	if (code !== 0) return yield* PackageError.make({ detail: `Package resolution failed: ${stderr}` });
-	return stdout;
-}, Effect.scoped);
-export { PositiveDuration as a, Supervisor as i, resolveEntry as n, verify as r, resolve as t };

package/dist/Peer-DXeVrGBh.js

@@ -1,342 +0,0 @@
-import { u as TransportError } from "./Errors-DYhsGZcZ.js";
-import { i as encode, r as decoder, t as EndOfStream } from "./Framing-G9eSaeLb.js";
-import { t as make$1 } from "./FailureGroup-BgT73AaR.js";
-import { a as PositiveInt, i as PositiveFinite, r as Limits, t as Priority } from "./port--3x2zJ4D.js";
-import { Array, Cause, Context, Data, Duration, Effect, Fiber, Option, Queue, Schema, Sink, Stream, TxQueue } from "effect";
-import { Rpc, RpcGroup } from "effect/rpc";
-// packages/remote/src/Instance.ts
-const Identity = Schema.Struct({
-	id: Schema.String,
-	generation: Schema.Int
-});
-/** Outside a remote activation the identity is local/0. Local activations use a fresh UUID/1; runners allocate persistent generations. */
-const Instance = Context.Reference("@graftland/plugin-remote/Instance/Instance", { defaultValue: () => ({
-	id: "local",
-	generation: 0
-}) });
-// packages/remote/src/internal/runner/Multiplex.ts
-/** Ports own admission and ACK backpressure. This layer only frames and separates session/instance bytes. */
-const make = Effect.fnUntraced(function* (channel) {
-	const group = yield* make$1();
-	const incoming = {
-		0: yield* Queue.unbounded(),
-		1: yield* Queue.unbounded()
-	};
-	const outgoing = {
-		0: yield* TxQueue.unbounded(),
-		1: yield* TxQueue.unbounded()
-	};
-	const next = Effect.tx(Effect.gen(function* () {
-		const session = yield* TxQueue.poll(outgoing[0]);
-		if (Option.isSome(session)) return session.value;
-		const instance = yield* TxQueue.poll(outgoing[1]);
-		if (Option.isSome(instance)) return instance.value;
-		if ((yield* TxQueue.isDone(outgoing[0])) && (yield* TxQueue.isDone(outgoing[1]))) return yield* Cause.done();
-		return yield* Effect.txRetry;
-	}));
-	const writing = yield* group.run(Stream.fromEffectRepeat(next).pipe(Stream.run(channel.output), Effect.asVoid));
-	const decoder$1 = decoder();
-	yield* group.run(channel.input.pipe(Stream.runForEach((bytes) => Effect.fromResult(decoder$1.decode(bytes)).pipe(Effect.flatMap((frames) => Effect.forEach(frames, (frame) => Queue.offer(incoming[frame.channel], frame.payload), { discard: true })))), Effect.andThen(decoder$1.finish), Effect.andThen(Effect.fail(EndOfStream.make({}))), Effect.mapError((error) => error._tag === "TransportError" ? error : TransportError.make({ cause: Cause.fail(error) }))));
-	return {
-		await: group.await,
-		fail: group.fail,
-		end: Effect.tx(TxQueue.end(outgoing[0]).pipe(Effect.andThen(TxQueue.end(outgoing[1])))).pipe(Effect.andThen(Fiber.join(writing))),
-		send: (id, payload) => group.race(encode({
-			channel: id,
-			payload
-		}).pipe(Effect.flatMap((bytes) => TxQueue.offer(outgoing[id], bytes)), Effect.asVoid)),
-		take: (id) => group.race(Queue.take(incoming[id]))
-	};
-});
-Effect.fnUntraced(function* (socket) {
-	const reader = yield* socket.reader;
-	const writer = yield* socket.writer;
-	return yield* make({
-		input: Stream.fromEffectRepeat(reader.pull).pipe(Stream.flattenIterable, Stream.map((bytes) => typeof bytes === "string" ? new TextEncoder().encode(bytes) : bytes), Stream.mapError((error) => TransportError.make({ cause: Cause.fail(error) }))),
-		output: Sink.forEach((bytes) => writer.write(bytes)).pipe(Sink.mapError((error) => TransportError.make({ cause: Cause.fail(error) })))
-	});
-});
-// packages/remote/src/internal/runner/model.ts
-const diagnosticCause = Schema.Cause(Schema.Defect({ includeStack: true }), Schema.Defect({ includeStack: true }));
-var PackageError = class extends Schema.TaggedError()("PackageError", {
-	detail: Schema.String,
-	cause: Schema.optionalKey(diagnosticCause)
-}) {
-	get message() {
-		return this.detail;
-	}
-};
-var SessionAccessDenied = class extends Schema.TaggedError()("SessionAccessDenied", {
-	detail: Schema.String,
-	cause: Schema.optionalKey(diagnosticCause)
-}) {
-	get message() {
-		return this.detail;
-	}
-};
-var StaleSession = class extends Schema.TaggedError()("StaleSession", {
-	detail: Schema.String,
-	cause: Schema.optionalKey(diagnosticCause)
-}) {
-	get message() {
-		return this.detail;
-	}
-};
-var LeaseExpired = class extends Schema.TaggedError()("LeaseExpired", {
-	detail: Schema.String,
-	cause: Schema.optionalKey(diagnosticCause)
-}) {
-	get message() {
-		return this.detail;
-	}
-};
-var SessionStopped = class extends Schema.TaggedError()("SessionStopped", {
-	detail: Schema.String,
-	cause: Schema.optionalKey(diagnosticCause)
-}) {
-	get message() {
-		return this.detail;
-	}
-};
-var SessionConflict = class extends Schema.TaggedError()("SessionConflict", {
-	detail: Schema.String,
-	cause: Schema.optionalKey(diagnosticCause)
-}) {
-	get message() {
-		return this.detail;
-	}
-};
-var StateStorageError = class extends Schema.TaggedError()("StateStorageError", {
-	detail: Schema.String,
-	cause: Schema.optionalKey(diagnosticCause)
-}) {
-	get message() {
-		return this.detail;
-	}
-};
-var ExecutionError = class extends Schema.TaggedError()("ExecutionError", {
-	detail: Schema.String,
-	cause: Schema.optionalKey(diagnosticCause)
-}) {
-	get message() {
-		return this.detail;
-	}
-};
-var TerminationUnconfirmed = class extends Schema.TaggedError()("TerminationUnconfirmed", {
-	detail: Schema.String,
-	cause: Schema.optionalKey(diagnosticCause)
-}) {
-	get message() {
-		return this.detail;
-	}
-};
-var RunnerClosing = class extends Schema.TaggedError()("RunnerClosing", {
-	detail: Schema.String,
-	cause: Schema.optionalKey(diagnosticCause)
-}) {
-	get message() {
-		return this.detail;
-	}
-};
-var StateDirectoryLocked = class extends Schema.TaggedError()("StateDirectoryLocked", {
-	detail: Schema.String,
-	cause: Schema.optionalKey(diagnosticCause)
-}) {
-	get message() {
-		return this.detail;
-	}
-};
-const Key = Schema.Struct({
-	identity: Schema.NonEmptyString,
-	instance: Schema.NonEmptyString
-});
-/** Structural keys keep identity namespaces separate without delimiter conventions. */
-var SessionKey = class extends Data.Class {};
-const keyOf = (key) => new SessionKey(key);
-const negotiate = (local, peer) => ({
-	control: Math.min(local.control, peer.control),
-	data: Math.min(local.data, peer.data),
-	log: Math.min(local.log, peer.log)
-});
-const Handle = Schema.Struct({
-	key: Key,
-	token: Schema.NonEmptyString,
-	generation: PositiveInt
-});
-const ProcessIdentity = Schema.Struct({
-	pid: Schema.Int,
-	start: Schema.Struct({ born: Schema.String })
-});
-const ExitStatus = Schema.Struct({
-	stderr: Schema.optionalKey(Schema.String),
-	cause: Schema.optionalKey(diagnosticCause),
-	code: Schema.NullOr(Schema.Int),
-	signal: Schema.NullOr(Schema.String)
-});
-const CodeIdentity = Schema.Struct({
-	name: Schema.String,
-	version: Schema.String,
-	digest: Schema.optionalKey(Schema.String)
-});
-const Load = Schema.Struct({
-	specifier: Schema.String,
-	digest: Schema.optionalKey(Schema.Boolean)
-});
-const Termination = Schema.Struct({
-	kind: Schema.Literals(["Exited", "Killed"]),
-	exit: ExitStatus,
-	cause: diagnosticCause
-});
-const Fields = {
-	version: Schema.Literal(1),
-	handle: Handle,
-	requestId: Schema.String,
-	leaseMillis: Schema.Finite,
-	limits: Limits
-};
-const OpenRecord = Schema.Struct({
-	...Fields,
-	phase: Schema.Literal("Open")
-});
-const Launch = Schema.Union([Schema.TaggedStruct("Starting", {}), Schema.TaggedStruct("Registered", { child: ProcessIdentity })]);
-const LoadingRecord = Schema.Struct({
-	...Fields,
-	phase: Schema.Literal("Loading"),
-	load: Load,
-	launch: Launch
-});
-const LoadedRecord = Schema.Struct({
-	...Fields,
-	phase: Schema.Literal("Loaded"),
-	load: Load,
-	child: ProcessIdentity,
-	code: CodeIdentity
-});
-const ActiveRecord = Schema.Union([
-	OpenRecord,
-	LoadingRecord,
-	LoadedRecord
-]);
-const StopReason = Schema.Union([...Array.map([
-	"Disposed",
-	"Expired",
-	"Superseded",
-	"Recovery",
-	"Shutdown",
-	"Exited"
-], (tag) => Schema.TaggedStruct(tag, {})), Schema.TaggedStruct("LoadFailed", { cause: diagnosticCause })]);
-const StoppingRecord = Schema.Struct({
-	...Fields,
-	phase: Schema.Literal("Stopping"),
-	previous: ActiveRecord,
-	reason: StopReason
-});
-const StoppedRecord = Schema.Struct({
-	...Fields,
-	phase: Schema.Literal("Stopped"),
-	previous: ActiveRecord,
-	reason: StopReason,
-	termination: Termination
-});
-const SessionRecord = Schema.Union([
-	OpenRecord,
-	LoadingRecord,
-	LoadedRecord,
-	StoppingRecord,
-	StoppedRecord
-]);
-const childOf = (record) => {
-	switch (record.phase) {
-		case "Open": return Option.none();
-		case "Loading": return record.launch._tag === "Registered" ? Option.some(record.launch.child) : Option.none();
-		case "Loaded": return Option.some(record.child);
-		case "Stopping":
-		case "Stopped": return childOf(record.previous);
-	}
-};
-const stoppingRecord = (previous, reason) => ({
-	version: previous.version,
-	handle: previous.handle,
-	requestId: previous.requestId,
-	leaseMillis: previous.leaseMillis,
-	limits: previous.limits,
-	phase: "Stopping",
-	previous,
-	reason
-});
-const stoppedRecord = (previous, reason, termination) => ({
-	...stoppingRecord(previous, reason),
-	phase: "Stopped",
-	termination
-});
-var Store = class extends Context.Service()("@graftland/plugin-remote/internal/runner/model/Store") {};
-var Execution = class extends Context.Service()("@graftland/plugin-remote/internal/runner/model/Execution") {};
-var RemoteTerminationUnconfirmed = class extends Schema.TaggedError()("RemoteTerminationUnconfirmed", { handle: Handle }) {};
-/** Losing contact never becomes a successful stop merely because a lease duration passed. */
-const awaitTermination = Effect.fnUntraced(function* (handle, confirmation, leaseMillis, marginMillis) {
-	const [elapsed, result] = yield* Effect.exit(Effect.timeoutOption(confirmation, leaseMillis + marginMillis)).pipe(Effect.timed);
-	if (result._tag === "Success") {
-		if (Option.isSome(result.value)) return result.value.value;
-		return yield* RemoteTerminationUnconfirmed.make({ handle });
-	}
-	yield* Effect.sleep(Math.max(0, leaseMillis + marginMillis - Duration.toMillis(elapsed)));
-	return yield* Effect.failCause(Cause.combine(result.cause, Cause.fail(RemoteTerminationUnconfirmed.make({ handle }))));
-});
-// packages/remote/src/internal/runner/Wire.ts
-/** The RPC boundary is the only place that assembles the runner's error schema. */
-const SessionError = Schema.Union([
-	SessionAccessDenied,
-	StaleSession,
-	LeaseExpired,
-	SessionStopped,
-	SessionConflict,
-	StateStorageError,
-	ExecutionError,
-	PackageError,
-	TerminationUnconfirmed,
-	RunnerClosing,
-	StateDirectoryLocked
-]);
-const Session = RpcGroup.make(Rpc.make("HighWater", {
-	payload: { instance: Schema.NonEmptyString },
-	success: Schema.NullOr(PositiveInt),
-	error: SessionError
-}), Rpc.make("Open", {
-	payload: {
-		instance: Schema.NonEmptyString,
-		requestId: Schema.NonEmptyString,
-		expectedGeneration: Schema.NullOr(PositiveInt),
-		leaseMillis: Schema.optionalKey(PositiveFinite),
-		limits: Limits
-	},
-	success: SessionRecord,
-	error: SessionError
-}), Rpc.make("Load", {
-	payload: {
-		handle: Handle,
-		specifier: Schema.NonEmptyString,
-		digest: Schema.optionalKey(Schema.Boolean)
-	},
-	success: CodeIdentity,
-	error: SessionError
-}), Rpc.make("Renew", {
-	payload: Handle,
-	success: Schema.Finite,
-	error: SessionError
-}), Rpc.make("Dispose", {
-	payload: Handle,
-	success: Termination,
-	error: SessionError
-}), Rpc.make("Status", {
-	payload: Handle,
-	success: SessionRecord,
-	error: SessionError
-})).annotateRpcs(Priority, "control");
-/** Preserve the port writer order within each byte channel. */
-const channel = (peer, id) => ({
-	input: Stream.fromEffectRepeat(peer.take(id)),
-	output: Sink.forEach((bytes) => peer.send(id, bytes).pipe(Effect.mapError((error) => TransportError.make({ cause: Cause.fail(error) }))))
-});
-// packages/remote/src/internal/Peer.ts
-var Peer = class extends Context.Service()("@graftland/plugin-remote/internal/Peer") {};
-export { negotiate as C, Identity as D, make as E, Instance as O, keyOf as S, stoppingRecord as T, StateStorageError as _, ExecutionError as a, awaitTermination as b, PackageError as c, SessionAccessDenied as d, SessionConflict as f, StateDirectoryLocked as g, StaleSession as h, Execution as i, RemoteTerminationUnconfirmed as l, SessionStopped as m, Session as n, Key as o, SessionRecord as p, channel as r, LeaseExpired as s, Peer as t, RunnerClosing as u, Store as v, stoppedRecord as w, childOf as x, TerminationUnconfirmed as y };

package/dist/ProcessObservation-gLgGirYv.js

@@ -1,38 +0,0 @@
-import { t as make } from "./FailureGroup-BgT73AaR.js";
-import { Array, Cause, Effect, Exit, Fiber, Ref, Schedule, Stream, String } from "effect";
-// packages/remote/src/internal/runner/ProcessObservation.ts
-/** Time allowed for a direct execution unit or launcher to exit after input EOF. */
-const stdinExitTimeout = "1 second";
-/** Readers outlive the failure monitor so forced termination still captures its diagnostic tail. */
-const observe = Effect.fnUntraced(function* (child, options = {}) {
-	const failures = yield* make();
-	const tail = yield* Ref.make("");
-	const stdout = yield* (options.drainStdout === false ? Effect.void : Stream.runDrain(child.stdout)).pipe(Effect.forkScoped);
-	const stderr = yield* child.stderr.pipe(Stream.decodeText(), Stream.runForEach((text) => Ref.update(tail, (old) => String.takeRight(old + text, 8192))), Effect.forkScoped);
-	yield* failures.run(Fiber.join(stdout));
-	yield* failures.run(Fiber.join(stderr));
-	const exited = yield* Effect.gen(function* () {
-		const result = yield* Effect.exit(child.exitCode);
-		yield* child.isRunning.pipe(Effect.repeat({
-			schedule: Schedule.spaced("25 millis"),
-			while: (running) => running
-		}));
-		const err = yield* Fiber.await(stderr);
-		const out = yield* Fiber.await(stdout);
-		return {
-			code: Exit.isSuccess(result) ? result.value : null,
-			signal: null,
-			stderr: yield* Ref.get(tail),
-			cause: Array.reduce([
-				Exit.asVoid(result),
-				err,
-				out
-			], Cause.empty, (cause, exit) => Exit.isFailure(exit) ? Cause.combine(cause, exit.cause) : cause)
-		};
-	}).pipe(Effect.forkScoped);
-	return {
-		exited: Fiber.join(exited),
-		failure: failures.await
-	};
-});
-export { stdinExitTimeout as n, observe as t };

package/dist/ServeLifecycle-Bd1FPJ6e.js

@@ -1,24 +0,0 @@
-import { n as close } from "./release-DfZPuIcK.js";
-import { Context, Deferred, Effect, Exit, Option, Schema, Scope } from "effect";
-// packages/remote/src/internal/ServeLifecycle.ts
-var StartupError = class extends Schema.TaggedError()("RunnerStartupError", {
-	detail: Schema.String,
-	cause: Schema.optionalKey(Schema.Cause(Schema.Unknown, Schema.Defect()))
-}) {
-	get message() {
-		return this.detail;
-	}
-};
-var ServeLifecycle = class extends Context.Service()("@graftland/plugin-remote/internal/ServeLifecycle") {};
-const make = Effect.all({
-	ended: Deferred.make(),
-	released: Deferred.make()
-});
-/** Observe shutdown independently of the loader, which logs child cleanup failures. */
-const resources = Effect.fnUntraced(function* (lifecycle) {
-	return yield* Effect.acquireRelease(Scope.make(), (scope, exit) => close(scope, exit).pipe(Effect.onExit((released) => Option.isNone(lifecycle) ? Effect.void : Deferred.done(lifecycle.value.released, Exit.isSuccess(released) ? Exit.void : Exit.fail(StartupError.make({
-		detail: "Supervisor shutdown failed",
-		cause: released.cause
-	}))).pipe(Effect.asVoid))));
-});
-export { resources as i, StartupError as n, make as r, ServeLifecycle as t };

package/dist/Transport-DULzpsgR.js

@@ -1,6 +0,0 @@
-import { Context } from "effect";
-// packages/remote/src/Transport.ts
-/** Execution and byte-channel capabilities; implementations live in host plugins. */
-var Connector = class extends Context.Service()("@graftland/plugin-remote/Transport/Connector") {};
-var Listener = class extends Context.Service()("@graftland/plugin-remote/Transport/Listener") {};
-export { Listener as n, Connector as t };

package/dist/WatchdogProtocol-BZmVxrBP.js

@@ -1,17 +0,0 @@
-import { Schema } from "effect";
-// packages/remote/src/internal/runner/WatchdogProtocol.ts
-const Command = Schema.Union([
-	Schema.Struct({
-		kind: Schema.Literal("renew"),
-		millis: Schema.Finite.check(Schema.isGreaterThan(0))
-	}),
-	Schema.Struct({ kind: Schema.Literal("start") }),
-	Schema.Struct({ kind: Schema.Literal("stop") })
-]);
-const CommandJson = Schema.fromJsonString(Command);
-const Notice = Schema.Literals([
-	"ready",
-	"start",
-	"stop"
-]);
-export { Notice as n, CommandJson as t };