@codeworksh/plugin 0.0.1-dev.20260922103030

package/event.d.mts

@@ -0,0 +1,2 @@
+import { a as ID, c as define, d as inventory, f as latest, i as Definition, l as durable, n as AikitToolCallTerminalPart, o as Payload, p as versionedType, r as Data, s as PublishOptions, t as AikitAssistantMessage, u as event_d_exports } from "./event-rIZpnOTo.mjs";
+export { AikitAssistantMessage, AikitToolCallTerminalPart, Data, Definition, event_d_exports as EventSchema, ID, Payload, PublishOptions, define, durable, inventory, latest, versionedType };

package/event.mjs

@@ -0,0 +1,125 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { isAikitAssistantMessage, isAikitToolCallTerminalPart, optional, validateAikitAssistantMessage, validateAikitToolCallTerminalPart, withStatics } from "./schema.mjs";
+import "@codeworksh/aikit";
+import { Effect, Schema, SchemaGetter, SchemaIssue } from "effect";
+import { uuidv7 } from "uuidv7";
+//#region src/event.ts
+var event_exports = /* @__PURE__ */ __exportAll({
+	AikitAssistantMessage: () => AikitAssistantMessage,
+	AikitToolCallTerminalPart: () => AikitToolCallTerminalPart,
+	EventSchema: () => event_exports,
+	ID: () => ID,
+	define: () => define,
+	durable: () => durable,
+	inventory: () => inventory,
+	latest: () => latest,
+	versionedType: () => versionedType
+});
+/** Undeclared fields used only while aikit is assembling a streamed part. */
+const aikitTransientFields = {
+	text: ["streamId"],
+	image: [],
+	thinking: ["streamId"],
+	toolCall: ["partialJson"]
+};
+const omit = (value, keys) => {
+	if (!keys.some((key) => key in value)) return value;
+	const copy = { ...value };
+	for (const key of keys) delete copy[key];
+	return copy;
+};
+const canonicalizeAikitAssistantMessage = (message) => ({
+	...message,
+	parts: message.parts.map((part) => omit(part, aikitTransientFields[part.type]))
+});
+const reasonOf = (cause) => cause instanceof Error ? cause.message : String(cause);
+const decodeAikitAssistantMessage = (value, options) => Effect.try({
+	try: () => canonicalizeAikitAssistantMessage(validateAikitAssistantMessage(value, "aikit assistant message")),
+	catch: (cause) => new SchemaIssue.InvalidValue({ message: reasonOf(cause) }, value, options)
+});
+const aikitAssistantMessageDeclared = Schema.declare(isAikitAssistantMessage, { expected: "aikit AssistantMessage" });
+/**
+* Effect Schema adapter for aikit's TypeBox assistant message. Durable LLM
+* events use it to validate their payload and strip streaming-only fields.
+*/
+const AikitAssistantMessage = Schema.Unknown.pipe(Schema.decodeTo(aikitAssistantMessageDeclared, {
+	decode: SchemaGetter.transformEffect(decodeAikitAssistantMessage),
+	encode: SchemaGetter.transformEffect(decodeAikitAssistantMessage)
+}));
+const decodeAikitToolCallTerminalPart = (value, options) => Effect.try({
+	try: () => validateAikitToolCallTerminalPart(value, "aikit terminal toolcall part"),
+	catch: (cause) => new SchemaIssue.InvalidValue({ message: reasonOf(cause) }, value, options)
+});
+const aikitToolCallTerminalPartDeclared = Schema.declare(isAikitToolCallTerminalPart, { expected: "aikit terminal toolcall part" });
+const AikitToolCallTerminalPart = Schema.Unknown.pipe(Schema.decodeTo(aikitToolCallTerminalPartDeclared, {
+	decode: SchemaGetter.transformEffect(decodeAikitToolCallTerminalPart),
+	encode: SchemaGetter.transformEffect(decodeAikitToolCallTerminalPart)
+}));
+const ID = Schema.String.pipe(Schema.brand("Event.ID"), withStatics((schema) => ({ create: () => schema.make(`evt_${uuidv7()}`) })));
+function define(input) {
+	const data = Schema.Struct(input.schema);
+	return Schema.Struct({
+		id: ID,
+		metadata: optional(Schema.Record(Schema.String, Schema.String)),
+		type: Schema.Literal(input.type),
+		durable: optional(Schema.Struct({
+			aggregateId: Schema.String,
+			seq: Schema.Int,
+			version: Schema.Int
+		})),
+		data
+	}).annotate({ identifier: input.type }).pipe(withStatics(() => ({
+		type: input.type,
+		...input.durable === void 0 ? {} : { durable: input.durable },
+		data
+	})));
+}
+function inventory(...definitions) {
+	return Object.freeze(definitions);
+}
+function versionedType(type, version) {
+	return `${type}.${version}`;
+}
+function durable(definitions) {
+	return readonlyMap(definitions.reduce((result, definition) => {
+		if (!definition.durable) return result;
+		const key = versionedType(definition.type, definition.durable.version);
+		if (result.has(key)) throw new Error(`duplicate durable event definition for ${key}`);
+		result.set(key, definition);
+		return result;
+	}, /* @__PURE__ */ new Map()));
+}
+function readonlyMap(map) {
+	const result = Object.freeze({
+		get size() {
+			return map.size;
+		},
+		entries: () => map.entries(),
+		forEach: (callback, thisArg) => map.forEach((value, key) => callback.call(thisArg, value, key, result)),
+		get: (key) => map.get(key),
+		has: (key) => map.has(key),
+		keys: () => map.keys(),
+		values: () => map.values(),
+		[Symbol.iterator]: () => map[Symbol.iterator]()
+	});
+	return result;
+}
+function latest(definitions) {
+	return readonlyMap(definitions.reduce((result, definition) => {
+		const existing = result.get(definition.type);
+		if (!existing) {
+			result.set(definition.type, definition);
+			return result;
+		}
+		if (definition.durable && existing.durable && definition.durable.version !== existing.durable.version) {
+			if (definition.durable.version > existing.durable.version) result.set(definition.type, definition);
+			return result;
+		}
+		if (definition !== existing) throw new Error(`duplicate latest event definition for ${definition.type}`);
+		return result;
+	}, /* @__PURE__ */ new Map()));
+}
+//#endregion
+export { AikitAssistantMessage, AikitToolCallTerminalPart, event_exports as EventSchema, ID, define, durable, inventory, latest, versionedType };
+
+//# sourceMappingURL=event.mjs.map

package/event.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.mjs","names":[],"sources":["../../src/event.ts"],"sourcesContent":["import { Message } from \"@codeworksh/aikit\";\nimport { Effect, Schema, type SchemaAST, SchemaGetter, SchemaIssue } from \"effect\";\nimport { uuidv7 } from \"uuidv7\";\nimport {\n\tisAikitAssistantMessage,\n\tisAikitToolCallTerminalPart,\n\toptional,\n\tvalidateAikitAssistantMessage,\n\tvalidateAikitToolCallTerminalPart,\n\twithStatics,\n} from \"./schema.ts\";\n\ntype AikitAssistantPart = Message.AssistantMessage[\"parts\"][number];\n\n/** Undeclared fields used only while aikit is assembling a streamed part. */\nconst aikitTransientFields: Readonly<Record<AikitAssistantPart[\"type\"], ReadonlyArray<string>>> = {\n\ttext: [\"streamId\"],\n\timage: [],\n\tthinking: [\"streamId\"],\n\ttoolCall: [\"partialJson\"],\n};\n\nconst omit = <T extends object>(value: T, keys: ReadonlyArray<string>): T => {\n\tif (!keys.some((key) => key in value)) return value;\n\tconst copy = { ...value } as T & Record<string, unknown>;\n\tfor (const key of keys) delete copy[key];\n\treturn copy;\n};\n\nconst canonicalizeAikitAssistantMessage = (message: Message.AssistantMessage): Message.AssistantMessage => ({\n\t...message,\n\tparts: message.parts.map((part) => omit(part, aikitTransientFields[part.type])),\n});\n\nconst reasonOf = (cause: unknown): string => (cause instanceof Error ? cause.message : String(cause));\n\nconst decodeAikitAssistantMessage = (value: unknown, options: SchemaAST.ParseOptions) =>\n\tEffect.try({\n\t\ttry: () => canonicalizeAikitAssistantMessage(validateAikitAssistantMessage(value, \"aikit assistant message\")),\n\t\tcatch: (cause) => new SchemaIssue.InvalidValue({ message: reasonOf(cause) }, value, options),\n\t});\n\nconst aikitAssistantMessageDeclared = Schema.declare<Message.AssistantMessage>(isAikitAssistantMessage, {\n\texpected: \"aikit AssistantMessage\",\n});\n\n/**\n * Effect Schema adapter for aikit's TypeBox assistant message. Durable LLM\n * events use it to validate their payload and strip streaming-only fields.\n */\nexport const AikitAssistantMessage = Schema.Unknown.pipe(\n\tSchema.decodeTo(aikitAssistantMessageDeclared, {\n\t\tdecode: SchemaGetter.transformEffect(decodeAikitAssistantMessage),\n\t\tencode: SchemaGetter.transformEffect(decodeAikitAssistantMessage),\n\t}),\n);\nexport type AikitAssistantMessage = typeof AikitAssistantMessage.Type;\n\nconst decodeAikitToolCallTerminalPart = (value: unknown, options: SchemaAST.ParseOptions) =>\n\tEffect.try({\n\t\ttry: () => validateAikitToolCallTerminalPart(value, \"aikit terminal toolcall part\"),\n\t\tcatch: (cause) => new SchemaIssue.InvalidValue({ message: reasonOf(cause) }, value, options),\n\t});\n\nconst aikitToolCallTerminalPartDeclared = Schema.declare<Message.ToolCallTerminalPart>(isAikitToolCallTerminalPart, {\n\texpected: \"aikit terminal toolcall part\",\n});\n\nexport const AikitToolCallTerminalPart = Schema.Unknown.pipe(\n\tSchema.decodeTo(aikitToolCallTerminalPartDeclared, {\n\t\tdecode: SchemaGetter.transformEffect(decodeAikitToolCallTerminalPart),\n\t\tencode: SchemaGetter.transformEffect(decodeAikitToolCallTerminalPart),\n\t}),\n);\nexport type AikitToolCallTerminalPart = typeof AikitToolCallTerminalPart.Type;\n\nexport const ID = Schema.String.pipe(\n\tSchema.brand(\"Event.ID\"),\n\twithStatics((schema) => ({\n\t\tcreate: () => schema.make(`evt_${uuidv7()}`),\n\t})),\n);\nexport type ID = typeof ID.Type;\n\nexport type Definition<\n\tType extends string = string,\n\tDataSchema extends Schema.Codec<unknown, unknown> = Schema.Codec<unknown, unknown>,\n> = Schema.Top & {\n\treadonly type: Type;\n\treadonly durable?: {\n\t\treadonly version: number; // event versioning for decoding in later time\n\t\treadonly aggregate: string;\n\t};\n\treadonly data: DataSchema;\n};\n\nexport type Data<D extends Definition> = Schema.Schema.Type<D[\"data\"]>;\n\n/** Publish-time options. Lives beside the definition so the plugin-facing publisher can name it. */\nexport interface PublishOptions {\n\t/** Caller-supplied event ID. Publishing the same ID twice is a defect, not an upsert. */\n\treadonly id?: ID;\n\t/**\n\t * Publish-time context — correlation, tracing — carried to projectors on the\n\t * in-memory payload and deliberately not stored in the event row. A projector\n\t * persists it into its own projection if it means something there; the log\n\t * records what happened, not who asked. It therefore does not survive a\n\t * durable reread or a rebuild, which `event.test.ts` pins explicitly.\n\t */\n\treadonly metadata?: Record<string, string>;\n}\n\nexport type Payload<D extends Definition = Definition> = {\n\treadonly id: ID;\n\treadonly type: D[\"type\"];\n\treadonly data: Data<D>;\n\treadonly durable?: {\n\t\treadonly aggregateId: string;\n\t\treadonly seq: number;\n\t\treadonly version: number;\n\t};\n\treadonly metadata?: Record<string, string>;\n};\n\nexport function define<\n\tconst Type extends string,\n\tconst Fields extends Readonly<Record<PropertyKey, Schema.Codec<unknown, unknown>>>,\n>(input: {\n\treadonly type: Type;\n\treadonly durable?: {\n\t\treadonly version: number;\n\t\treadonly aggregate: string;\n\t};\n\treadonly schema: Fields;\n}) {\n\tconst data = Schema.Struct(input.schema);\n\treturn Schema.Struct({\n\t\tid: ID,\n\t\tmetadata: optional(Schema.Record(Schema.String, Schema.String)),\n\t\ttype: Schema.Literal(input.type),\n\t\tdurable: optional(Schema.Struct({ aggregateId: Schema.String, seq: Schema.Int, version: Schema.Int })),\n\t\tdata,\n\t})\n\t\t.annotate({ identifier: input.type })\n\t\t.pipe(\n\t\t\twithStatics(() => ({\n\t\t\t\ttype: input.type,\n\t\t\t\t...(input.durable === undefined ? {} : { durable: input.durable }),\n\t\t\t\tdata,\n\t\t\t})),\n\t\t) satisfies Definition<Type, typeof data>;\n}\n\n// Register all the event definitions.\nexport function inventory<const Definitions extends ReadonlyArray<Definition>>(...definitions: Definitions) {\n\treturn Object.freeze(definitions);\n}\n\nexport function versionedType(type: string, version: number) {\n\treturn `${type}.${version}`;\n}\n\nexport function durable<const Definitions extends ReadonlyArray<Definition>>(definitions: Definitions) {\n\treturn readonlyMap(\n\t\tdefinitions.reduce((result, definition) => {\n\t\t\tif (!definition.durable) return result;\n\t\t\tconst key = versionedType(definition.type, definition.durable.version);\n\t\t\tif (result.has(key)) throw new Error(`duplicate durable event definition for ${key}`);\n\t\t\tresult.set(key, definition);\n\t\t\treturn result;\n\t\t}, new Map<string, Definitions[number]>()),\n\t);\n}\n\nfunction readonlyMap<Key, Value>(map: Map<Key, Value>): ReadonlyMap<Key, Value> {\n\tconst result: ReadonlyMap<Key, Value> = Object.freeze({\n\t\tget size() {\n\t\t\treturn map.size;\n\t\t},\n\t\tentries: () => map.entries(),\n\t\tforEach: (callback: (value: Value, key: Key, map: ReadonlyMap<Key, Value>) => void, thisArg?: unknown) =>\n\t\t\tmap.forEach((value, key) => callback.call(thisArg, value, key, result)),\n\t\tget: (key: Key) => map.get(key),\n\t\thas: (key: Key) => map.has(key),\n\t\tkeys: () => map.keys(),\n\t\tvalues: () => map.values(),\n\t\t[Symbol.iterator]: () => map[Symbol.iterator](),\n\t});\n\treturn result;\n}\n\nexport function latest(definitions: ReadonlyArray<Definition>) {\n\treturn readonlyMap(\n\t\tdefinitions.reduce((result, definition) => {\n\t\t\tconst existing = result.get(definition.type);\n\t\t\tif (!existing) {\n\t\t\t\tresult.set(definition.type, definition);\n\t\t\t\treturn result;\n\t\t\t}\n\t\t\tif (definition.durable && existing.durable && definition.durable.version !== existing.durable.version) {\n\t\t\t\tif (definition.durable.version > existing.durable.version) result.set(definition.type, definition);\n\t\t\t\treturn result;\n\t\t\t}\n\t\t\tif (definition !== existing) throw new Error(`duplicate latest event definition for ${definition.type}`);\n\t\t\treturn result;\n\t\t}, new Map<string, Definition>()),\n\t);\n}\n\nexport * as EventSchema from \"./event.ts\";\n"],"mappings":"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"}

package/filesystem-Cp-KapCE.d.mts

@@ -0,0 +1,142 @@
+import { Context, Effect, Schema } from "effect";
+declare namespace filesystem_d_exports {
+  export { FileStat, FileSystemError, Interface, OperationUnsupportedError, Provider, RmOptions, filesystem_d_exports as SandboxFileSystem, Service, fromProvider, isNotFoundError, realpathScripts, validateRmOptions, withCwd };
+}
+declare const OperationUnsupportedError_base: Schema.Class<OperationUnsupportedError, Schema.TaggedStruct<"OperationUnsupportedError", {
+  readonly operation: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The runtime filesystem contract, independent of any backend.
+ *
+ * Two surfaces, deliberately:
+ * - {@link Provider} is what a backend implements — plain promises that reject,
+ *   matching every SDK we wrap.
+ * - {@link Interface} is what the harness consumes — Effect with a typed error
+ *   channel and tracing spans. {@link fromProvider} bridges the two exactly
+ *   once, so no consumer ever writes `Effect.tryPromise` against a filesystem.
+ *
+ * Implementations:
+ * - Local:
+ * implement it over a VFS (`./local`);
+ * local filesystem use OS primitives; hence have broader filesytem capabilities.
+ *
+ * - Remote:
+ * implement it over a provider (`./remote`).
+ * remote filesytems depends on the interface provided by the remote provider; hence can have limited filesytem capabilities.
+ *
+ * `isFile`/`isDirectory` are required booleans; size, mtime, and isSymbolicLink are omitted when the
+ * backend cannot report them — never fabricated.
+ *
+ * **Paths are POSIX, and the harness is Unix-only (for now!).** Every path uses `/`
+ * separators on both the host and inside a sandbox — Windows is not supported,
+ * so no translation layer exists. Consumers must use the shared Effect POSIX
+ * path implementation, never the platform default, or a host running the harness would
+ * impose its own flavour on a remote sandbox's paths. Relative paths resolve
+ * against the backend's configured `cwd`.
+ */
+declare class OperationUnsupportedError extends OperationUnsupportedError_base {}
+declare const FileSystemError_base: Schema.Class<FileSystemError, Schema.TaggedStruct<"SandboxFileSystemError", {
+  readonly method: Schema.String;
+  readonly path: Schema.String;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** A backend operation failed. `cause` carries the provider's own rejection. */
+declare class FileSystemError extends FileSystemError_base {}
+interface FileStat {
+  readonly isFile: boolean;
+  readonly isDirectory: boolean;
+  readonly isSymbolicLink?: boolean;
+  readonly size?: number;
+  readonly mtime?: Date;
+}
+interface RmOptions {
+  readonly recursive?: boolean;
+  readonly force?: boolean;
+}
+/** Whether a provider failure means the path itself is definitively absent. */
+declare const isNotFoundError: (cause: unknown) => boolean;
+/**
+ * Shell forms of `realpath` for backends that only expose a process API.
+ * `pwd -P` is the portable primitive: directories resolve directly, anything
+ * else resolves its parent and keeps the final name as given. Run as
+ * `sh -c <script> _ <path>`; try the first, fall back to the second.
+ */
+declare const realpathScripts: readonly ['cd -- "$1" && pwd -P', 'cd -- "$(dirname -- "$1")" && printf \'%s/%s\' "$(pwd -P)" "$(basename -- "$1")"'];
+/**
+ * The backend-facing contract. Backends author plain promises and let them
+ * reject; {@link fromProvider} turns rejections into typed failures.
+ */
+interface Provider {
+  readonly readFile: (path: string) => Promise<string>;
+  readonly readFileBuffer: (path: string) => Promise<Uint8Array>;
+  /**
+   * Write the file. Parents may be missing — do not create them here;
+   * {@link fromProvider} owns that guarantee for every backend.
+   */
+  readonly writeFile: (path: string, content: string | Uint8Array) => Promise<void>;
+  readonly stat: (path: string) => Promise<FileStat>;
+  readonly readdir: (path: string) => Promise<string[]>;
+  readonly exists: (path: string) => Promise<boolean>;
+  readonly mkdir: (path: string, options?: {
+    recursive?: boolean;
+  }) => Promise<void>;
+  readonly rm: (path: string, options?: RmOptions) => Promise<void>;
+  /** Canonical absolute path with symlinks resolved; rejects when the path does not exist. */
+  readonly realpath: (path: string) => Promise<string>;
+  /**
+   * Metadata for the directory entry itself rather than a symlink's target.
+   * Optional: a backend whose `stat` has mixed symlink semantics implements it
+   * so symlink identity is asked for explicitly, never inferred.
+   */
+  readonly lstat?: (path: string) => Promise<FileStat>;
+}
+/**
+ * The consumer-facing contract. `exists` distinguishes "absent" from "could not
+ * tell": a backend failure is a typed failure, not `false`, so a caller acting
+ * on absence never acts on a network blip. Use `SandboxFs.existsOrFalse` where
+ * a best-effort answer really is wanted.
+ */
+interface Interface {
+  readonly readFile: (path: string) => Effect.Effect<string, FileSystemError>;
+  readonly readFileBuffer: (path: string) => Effect.Effect<Uint8Array, FileSystemError>;
+  /** Creates missing parent directories, on every backend. */
+  readonly writeFile: (path: string, content: string | Uint8Array) => Effect.Effect<void, FileSystemError>;
+  readonly stat: (path: string) => Effect.Effect<FileStat, FileSystemError>;
+  readonly readdir: (path: string) => Effect.Effect<string[], FileSystemError>;
+  readonly exists: (path: string) => Effect.Effect<boolean, FileSystemError>;
+  readonly mkdir: (path: string, options?: {
+    recursive?: boolean;
+  }) => Effect.Effect<void, FileSystemError>;
+  readonly rm: (path: string, options?: RmOptions) => Effect.Effect<void, FileSystemError | OperationUnsupportedError>;
+  /** Canonical absolute path with symlinks resolved; fails when the path does not exist. */
+  readonly realpath: (path: string) => Effect.Effect<string, FileSystemError>;
+  readonly lstat?: (path: string) => Effect.Effect<FileStat, FileSystemError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@codeworksh/plugin/sandbox/filesystem/Service", Interface>;
+/** The runtime filesystem service — the live {@link Interface} for the active sandbox. */
+declare class Service extends Service_base {}
+/**
+ * Reject `rm` options a provider does not implement, before any mutation. Only
+ * `recursive` and `force` are part of the contract; anything else is refused
+ * loudly rather than silently ignored.
+ */
+declare const validateRmOptions: (options: RmOptions | undefined, operation?: string) => Effect.Effect<void, OperationUnsupportedError>;
+/**
+ * Lift a {@link Provider} into the runtime {@link Interface}: one place that
+ * converts rejections into {@link FileSystemError}, validates `rm` options,
+ * creates missing parents on write, and names a tracing span per operation.
+ */
+declare const fromProvider: (provider: Provider) => Interface;
+/**
+ * Bind a cwd-neutral filesystem to one mount's working directory.
+ *
+ * The counterpart of `Shell.withCwd`, and the reason relative paths mean the
+ * same thing to both: a shared transport stays rooted at the namespace root, so
+ * resolution happens here, per mount, rather than inside a VFS whose `chdir` is
+ * global state two mounts would fight over.
+ */
+declare const withCwd: (fs: Interface, cwd: string) => Interface;
+//#endregion
+export { Provider as a, filesystem_d_exports as c, realpathScripts as d, validateRmOptions as f, OperationUnsupportedError as i, fromProvider as l, FileSystemError as n, RmOptions as o, withCwd as p, Interface as r, Service as s, FileStat as t, isNotFoundError as u };
+//# sourceMappingURL=filesystem-Cp-KapCE.d.mts.map

package/ids-CHjmAdTc.d.mts

@@ -0,0 +1,43 @@
+import { Schema } from "effect";
+//#region src/ids.d.ts
+/**
+ * The identifiers that cross the plugin boundary.
+ *
+ * A plugin reads a session id off its context and a message id off every tool call, so both
+ * brands have to be the ones the harness itself mints -- a structurally identical brand declared
+ * twice is two types, and a plugin would have to cast to hand either back. They live here, in the
+ * package both sides depend on, rather than being re-declared on each side.
+ */
+declare const SessionID: Schema.brand<Schema.String, "Session.ID"> & {
+  ascending: (id?: string) => string & import("effect/Brand").Brand<"Session.ID">;
+  create: () => string & import("effect/Brand").Brand<"Session.ID">;
+};
+type SessionID = typeof SessionID.Type;
+/**
+ * A conversation message id.
+ *
+ * Deliberately unprefixed. aikit mints assistant message ids itself, as bare
+ * uuidv7, and `stream()` accepts no id -- so any naming rule of ours would have
+ * to be imposed on messages aikit hands us, by rewriting a field of the value we
+ * were given. Sharing aikit's format instead means an id means the same thing on
+ * both sides of the boundary and never needs translating.
+ *
+ * The brand carries the meaning; uuidv7 keeps ids time-ordered, so they sort by
+ * creation.
+ */
+declare const MessageID: Schema.brand<Schema.String, "Message.ID"> & {
+  create: () => string & import("effect/Brand").Brand<"Message.ID">;
+  /**
+   * Adopt an id minted elsewhere -- in practice aikit's, which arrives as a
+   * plain string on every stream event and inside every assistant message.
+   *
+   * `make` does the same thing. This exists so the boundary where a foreign
+   * id enters the domain is named and greppable, and so the pairing with
+   * `create` says which side chose the id.
+   */
+  from: (id: string) => string & import("effect/Brand").Brand<"Message.ID">;
+};
+type MessageID = typeof MessageID.Type;
+//#endregion
+export { SessionID as n, MessageID as t };
+//# sourceMappingURL=ids-CHjmAdTc.d.mts.map

package/ids.d.mts

@@ -0,0 +1,2 @@
+import { n as SessionID, t as MessageID } from "./ids-CHjmAdTc.mjs";
+export { MessageID, SessionID };

package/ids.mjs

@@ -0,0 +1,48 @@
+import { withStatics } from "./schema.mjs";
+import { Schema } from "effect";
+import { uuidv7 } from "uuidv7";
+//#region src/ids.ts
+/**
+* The identifiers that cross the plugin boundary.
+*
+* A plugin reads a session id off its context and a message id off every tool call, so both
+* brands have to be the ones the harness itself mints -- a structurally identical brand declared
+* twice is two types, and a plugin would have to cast to hand either back. They live here, in the
+* package both sides depend on, rather than being re-declared on each side.
+*/
+const SessionID = Schema.String.check(Schema.isStartsWith("ses")).pipe(Schema.brand("Session.ID"), withStatics((schema) => ({
+	ascending: (id) => {
+		if (!id) return schema.make("ses_" + uuidv7());
+		if (!id.startsWith("ses")) throw new Error(`ID ${id} does not start with ses`);
+		return schema.make(id);
+	},
+	create: () => schema.make("ses_" + uuidv7())
+})));
+/**
+* A conversation message id.
+*
+* Deliberately unprefixed. aikit mints assistant message ids itself, as bare
+* uuidv7, and `stream()` accepts no id -- so any naming rule of ours would have
+* to be imposed on messages aikit hands us, by rewriting a field of the value we
+* were given. Sharing aikit's format instead means an id means the same thing on
+* both sides of the boundary and never needs translating.
+*
+* The brand carries the meaning; uuidv7 keeps ids time-ordered, so they sort by
+* creation.
+*/
+const MessageID = Schema.String.pipe(Schema.brand("Message.ID"), withStatics((schema) => ({
+	create: () => schema.make(uuidv7()),
+	/**
+	* Adopt an id minted elsewhere -- in practice aikit's, which arrives as a
+	* plain string on every stream event and inside every assistant message.
+	*
+	* `make` does the same thing. This exists so the boundary where a foreign
+	* id enters the domain is named and greppable, and so the pairing with
+	* `create` says which side chose the id.
+	*/
+	from: (id) => schema.make(id)
+})));
+//#endregion
+export { MessageID, SessionID };
+
+//# sourceMappingURL=ids.mjs.map

package/ids.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.mjs","names":[],"sources":["../../src/ids.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport { uuidv7 } from \"uuidv7\";\nimport { withStatics } from \"./schema.ts\";\n\n/**\n * The identifiers that cross the plugin boundary.\n *\n * A plugin reads a session id off its context and a message id off every tool call, so both\n * brands have to be the ones the harness itself mints -- a structurally identical brand declared\n * twice is two types, and a plugin would have to cast to hand either back. They live here, in the\n * package both sides depend on, rather than being re-declared on each side.\n */\n\n// Session identity. Branded so a session ID is not interchangeable with an\n// entry, part, or workspace ID at the type level — service signatures take\n// `SessionID`, never a bare `string`.\n//\n// `create` mints a new one; `ascending` adopts an ID that came from outside\n// (a persisted row, a request payload) and rejects a foreign prefix rather\n// than branding it silently. uuidv7 keeps IDs lexicographically sortable by\n// creation time, so `ORDER BY id` is `ORDER BY created`.\nexport const SessionID = Schema.String.check(Schema.isStartsWith(\"ses\")).pipe(\n\tSchema.brand(\"Session.ID\"),\n\twithStatics((schema) => ({\n\t\tascending: (id?: string) => {\n\t\t\tif (!id) return schema.make(\"ses_\" + uuidv7());\n\t\t\tif (!id.startsWith(\"ses\")) throw new Error(`ID ${id} does not start with ses`);\n\t\t\treturn schema.make(id);\n\t\t},\n\t\tcreate: () => schema.make(\"ses_\" + uuidv7()),\n\t})),\n);\nexport type SessionID = typeof SessionID.Type;\n\n/**\n * A conversation message id.\n *\n * Deliberately unprefixed. aikit mints assistant message ids itself, as bare\n * uuidv7, and `stream()` accepts no id -- so any naming rule of ours would have\n * to be imposed on messages aikit hands us, by rewriting a field of the value we\n * were given. Sharing aikit's format instead means an id means the same thing on\n * both sides of the boundary and never needs translating.\n *\n * The brand carries the meaning; uuidv7 keeps ids time-ordered, so they sort by\n * creation.\n */\nexport const MessageID = Schema.String.pipe(\n\tSchema.brand(\"Message.ID\"),\n\twithStatics((schema) => ({\n\t\tcreate: () => schema.make(uuidv7()),\n\t\t/**\n\t\t * Adopt an id minted elsewhere -- in practice aikit's, which arrives as a\n\t\t * plain string on every stream event and inside every assistant message.\n\t\t *\n\t\t * `make` does the same thing. This exists so the boundary where a foreign\n\t\t * id enters the domain is named and greppable, and so the pairing with\n\t\t * `create` says which side chose the id.\n\t\t */\n\t\tfrom: (id: string) => schema.make(id),\n\t})),\n);\nexport type MessageID = typeof MessageID.Type;\n"],"mappings":";;;;;;;;;;;;AAqBA,MAAa,YAAY,OAAO,OAAO,MAAM,OAAO,aAAa,KAAK,CAAC,CAAC,CAAC,KACxE,OAAO,MAAM,YAAY,GACzB,aAAa,YAAY;CACxB,YAAY,OAAgB;EAC3B,IAAI,CAAC,IAAI,OAAO,OAAO,KAAK,SAAS,OAAO,CAAC;EAC7C,IAAI,CAAC,GAAG,WAAW,KAAK,GAAG,MAAM,IAAI,MAAM,MAAM,GAAG,yBAAyB;EAC7E,OAAO,OAAO,KAAK,EAAE;CACtB;CACA,cAAc,OAAO,KAAK,SAAS,OAAO,CAAC;AAC5C,EAAE,CACH;;;;;;;;;;;;;AAeA,MAAa,YAAY,OAAO,OAAO,KACtC,OAAO,MAAM,YAAY,GACzB,aAAa,YAAY;CACxB,cAAc,OAAO,KAAK,OAAO,CAAC;;;;;;;;;CASlC,OAAO,OAAe,OAAO,KAAK,EAAE;AACrC,EAAE,CACH"}

package/index.d.mts

@@ -0,0 +1,3 @@
+import { g as tool_d_exports } from "./tool-DuYBgiJf.mjs";
+import { t as plugin_d_exports } from "./plugin-DbJEpY3M.mjs";
+export { plugin_d_exports as Plugin, tool_d_exports as Tool };

package/index.mjs

@@ -0,0 +1,3 @@
+import { t as plugin_exports } from "./plugin-lorpq7Oi.mjs";
+import { t as tool_exports } from "./tool.mjs";
+export { plugin_exports as Plugin, tool_exports as Tool };