@opencode-ai/schema 0.0.0-next-14855 → 0.0.0-reserved.0

package/dist/event-manifest.js

@@ -1,52 +0,0 @@
-export * as EventManifest from "./event-manifest.js";
-import { Agent } from "./agent.js";
-import { Catalog } from "./catalog.js";
-import { Command } from "./command.js";
-import { Config } from "./config.js";
-import { Durable } from "./durable-event-manifest.js";
-import { Event } from "./event.js";
-import { FileSystem } from "./filesystem.js";
-import { FileSystemV1 } from "./filesystem-v1.js";
-import { Form } from "./form.js";
-import { InstallationEvent } from "./installation-event.js";
-import { Integration } from "./integration.js";
-import { LegacyEvent } from "./legacy-event.js";
-import { LspEvent } from "./lsp-event.js";
-import { McpEvent } from "./mcp-event.js";
-import { ModelsDev } from "./models-dev.js";
-import { Permission } from "./permission.js";
-import { PermissionV1 } from "./permission-v1.js";
-import { Plugin } from "./plugin.js";
-import { Project } from "./project.js";
-import { ProjectDirectories } from "./project-directories.js";
-import { Pty } from "./pty.js";
-import { Question } from "./question.js";
-import { QuestionV1 } from "./question-v1.js";
-import { Reference } from "./reference.js";
-import { ServerEvent } from "./server-event.js";
-import { Shell } from "./shell.js";
-import { Skill } from "./skill.js";
-import { SessionCompactionEvent } from "./session-compaction-event.js";
-import { SessionEvent } from "./session-event.js";
-import { SessionStatusEvent } from "./session-status-event.js";
-import { SessionTodo } from "./session-todo.js";
-import { SessionV1 } from "./session-v1.js";
-import { TuiEvent } from "./tui-event.js";
-import { VcsEvent } from "./vcs-event.js";
-import { WorkspaceEvent } from "./workspace-event.js";
-import { WorktreeEvent } from "./worktree-event.js";
-const sessionV1DurableDefinitions = SessionV1.Event.Definitions.filter((definition) => definition.durability === "durable");
-const sessionV1LiveDefinitions = SessionV1.Event.Definitions.filter((definition) => definition.durability === "ephemeral");
-const coreDefinitions = Event.inventory(...sessionV1DurableDefinitions, ...SessionEvent.Definitions);
-const foundationDefinitions = Event.inventory(...ModelsDev.Event.Definitions, ...Integration.Event.Definitions, ...Catalog.Event.Definitions, ...Agent.Event.Definitions, ...coreDefinitions);
-const featureDefinitions = Event.inventory(...FileSystem.Event.Definitions, ...Reference.Event.Definitions, ...Permission.Event.Definitions, ...Plugin.Event.Definitions, ...ProjectDirectories.Event.Definitions, ...Command.Event.Definitions, ...Config.Event.Definitions, ...Skill.Event.Definitions, ...Pty.Event.Definitions, ...Shell.Event.Definitions, ...Question.Event.Definitions, ...Form.Event.Definitions);
-export const ServerDefinitions = Event.inventory(...foundationDefinitions, ...featureDefinitions, ...SessionTodo.Event.Definitions, 
-// Current events the TUI consumes from the public stream.
-...SessionStatusEvent.Definitions, ...TuiEvent.Definitions, ...InstallationEvent.Definitions, ...VcsEvent.Definitions, McpEvent.StatusChanged, 
-// Shared transitional: V1 contracts the current TUI still consumes during
-// the migration (permission.asked/replied, question.asked, session.error).
-// Remove when the TUI moves to the current permission/question surfaces.
-...PermissionV1.Event.Definitions, ...QuestionV1.Event.Definitions, SessionV1.Error);
-export const Definitions = Event.inventory(...foundationDefinitions, ...sessionV1LiveDefinitions, ...InstallationEvent.Definitions, ...featureDefinitions, ...SessionTodo.Event.Definitions, ...LspEvent.Definitions, ...PermissionV1.Event.Definitions, ...TuiEvent.Definitions, ...McpEvent.Definitions, ...LegacyEvent.Definitions, ...FileSystemV1.Event.Definitions, ...Project.Event.Definitions, ...SessionStatusEvent.Definitions, ...QuestionV1.Event.Definitions, ...SessionCompactionEvent.Definitions, ...VcsEvent.Definitions, ...WorkspaceEvent.Definitions, ...WorktreeEvent.Definitions, ...ServerEvent.Definitions);
-export const Latest = Event.latest(Definitions);
-export { Durable };

package/dist/event.d.ts

@@ -1,142 +0,0 @@
-export * as Event from "./event.js";
-import { Schema } from "effect";
-import { Location } from "./location.js";
-import { DateTimeUtcFromMillis } from "./schema.js";
-export declare const ID: Schema.brand<Schema.String, "Event.ID"> & {
-    create: () => string & import("effect/Brand").Brand<"Event.ID">;
-};
-export type ID = typeof ID.Type;
-/**
- * Position in one aggregate's durable log. Values originate from the durable
- * event envelope, synced markers, change hints, and snapshot watermarks;
- * `after` cursors accept only values that came from those sources.
- */
-export declare const Seq: Schema.brand<Schema.Int, "Event.Seq">;
-export type Seq = typeof Seq.Type;
-/** Durable schema version of one event type, from the event definition that committed it. */
-export declare const Version: Schema.brand<Schema.Int, "Event.Version">;
-export type Version = typeof Version.Type;
-declare const DurableEnvelope: Schema.Struct<{
-    readonly aggregateID: Schema.String;
-    readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-    readonly version: Schema.brand<Schema.Int, "Event.Version">;
-}>;
-export type DurableEnvelope = typeof DurableEnvelope.Type;
-export type DurableDefinition<Type extends string = string, DataSchema extends Schema.Codec<unknown, unknown> = Schema.Codec<unknown, unknown>> = Schema.Top & {
-    readonly type: Type;
-    readonly durability: "durable";
-    readonly durable: {
-        readonly version: number;
-        readonly aggregate: string;
-    };
-    readonly data: DataSchema;
-};
-export type EphemeralDefinition<Type extends string = string, DataSchema extends Schema.Codec<unknown, unknown> = Schema.Codec<unknown, unknown>> = Schema.Top & {
-    readonly type: Type;
-    readonly durability: "ephemeral";
-    readonly durable?: never;
-    readonly data: DataSchema;
-};
-export type Definition<Type extends string = string, DataSchema extends Schema.Codec<unknown, unknown> = Schema.Codec<unknown, unknown>> = DurableDefinition<Type, DataSchema> | EphemeralDefinition<Type, DataSchema>;
-export type Data<D extends Definition> = Schema.Schema.Type<D["data"]>;
-type PayloadBase<D extends Definition> = {
-    readonly id: ID;
-    readonly type: D["type"];
-    readonly created: typeof DateTimeUtcFromMillis.Type;
-    readonly data: Data<D>;
-    readonly location?: Location.Ref;
-    readonly metadata?: Record<string, unknown>;
-};
-export type Payload<D extends Definition = Definition> = D extends DurableDefinition ? PayloadBase<D> & {
-    readonly durable: DurableEnvelope;
-} : PayloadBase<D> & {
-    readonly durable?: never;
-};
-type Input<Type extends string, Fields extends Readonly<Record<PropertyKey, Schema.Codec<unknown, unknown>>>> = {
-    readonly type: Type;
-    readonly durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    };
-    readonly schema: Fields;
-};
-export declare function durable<const Type extends string, const Fields extends Readonly<Record<PropertyKey, Schema.Codec<unknown, unknown>>>>(input: Input<Type, Fields> & {
-    readonly durable: NonNullable<Input<Type, Fields>["durable"]>;
-}): Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-        create: () => string & import("effect/Brand").Brand<"Event.ID">;
-    };
-    readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-    readonly type: Schema.Literal<Type>;
-    readonly durable: Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>;
-    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>, never, never>;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>, never, never>;
-    }>>, never, never>;
-    readonly data: Schema.Struct<Fields>;
-}> & {
-    type: Type;
-    durability: "durable";
-    durable: {
-        readonly version: number;
-        readonly aggregate: string;
-    };
-    data: Schema.Struct<Fields>;
-};
-export declare function ephemeral<const Type extends string, const Fields extends Readonly<Record<PropertyKey, Schema.Codec<unknown, unknown>>>>(input: Omit<Input<Type, Fields>, "durable">): Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-        create: () => string & import("effect/Brand").Brand<"Event.ID">;
-    };
-    readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-    readonly type: Schema.Literal<Type>;
-    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>, never, never>;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>, never, never>;
-    }>>, never, never>;
-    readonly data: Schema.Struct<Fields>;
-}> & {
-    type: Type;
-    durability: "ephemeral";
-    durable: undefined;
-    data: Schema.Struct<Fields>;
-};
-export declare function inventory<const Definitions extends ReadonlyArray<Definition>>(...definitions: Definitions): Readonly<Definitions>;
-export declare function latest(definitions: ReadonlyArray<Definition>): ReadonlyMap<string, Definition<string, Schema.Codec<unknown, unknown, never, never>>>;
-export declare function versionedType(type: string, version: number): string;
-export declare function durableMap<const Definitions extends ReadonlyArray<Definition>>(definitions: Definitions): ReadonlyMap<string, DurableDefinition<string, Schema.Codec<unknown, unknown, never, never>>>;

package/dist/event.js

@@ -1,102 +0,0 @@
-export * as Event from "./event.js";
-import { Schema } from "effect";
-import { optional } from "./schema.js";
-import { ascending } from "./identifier.js";
-import { Location } from "./location.js";
-import { DateTimeUtcFromMillis, statics } from "./schema.js";
-export const ID = Schema.String.check(Schema.isStartsWith("evt_")).pipe(Schema.brand("Event.ID"), statics((schema) => ({ create: () => schema.make("evt_" + ascending()) })));
-/**
- * Position in one aggregate's durable log. Values originate from the durable
- * event envelope, synced markers, change hints, and snapshot watermarks;
- * `after` cursors accept only values that came from those sources.
- */
-export const Seq = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)).pipe(Schema.brand("Event.Seq"));
-/** Durable schema version of one event type, from the event definition that committed it. */
-export const Version = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).pipe(Schema.brand("Event.Version"));
-const DurableEnvelope = Schema.Struct({ aggregateID: Schema.String, seq: Seq, version: Version });
-export function durable(input) {
-    const data = Schema.Struct(input.schema);
-    return Schema.Struct({
-        id: ID,
-        created: DateTimeUtcFromMillis,
-        metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
-        type: Schema.Literal(input.type),
-        durable: DurableEnvelope,
-        location: optional(Location.Ref),
-        data,
-    })
-        .annotate({ identifier: input.type })
-        .pipe(statics(() => ({
-        type: input.type,
-        durability: "durable",
-        durable: input.durable,
-        data,
-    })));
-}
-export function ephemeral(input) {
-    const data = Schema.Struct(input.schema);
-    return Schema.Struct({
-        id: ID,
-        created: DateTimeUtcFromMillis,
-        metadata: optional(Schema.Record(Schema.String, Schema.Unknown)),
-        type: Schema.Literal(input.type),
-        location: optional(Location.Ref),
-        data,
-    })
-        .annotate({ identifier: input.type })
-        .pipe(statics(() => ({
-        type: input.type,
-        durability: "ephemeral",
-        durable: undefined,
-        data,
-    })));
-}
-export function inventory(...definitions) {
-    return Object.freeze(definitions);
-}
-export 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;
-    }, new Map()));
-}
-export function versionedType(type, version) {
-    return `${type}.${version}`;
-}
-export function durableMap(definitions) {
-    return readonlyMap(definitions.reduce((result, definition) => {
-        if (definition.durability !== "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;
-    }, 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;
-}

package/dist/file-diff.d.ts

@@ -1,11 +0,0 @@
-export * as FileDiff from "./file-diff.js";
-import { Schema } from "effect";
-export declare const Info: Schema.Struct<{
-    readonly file: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly patch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly additions: Schema.Finite;
-    readonly deletions: Schema.Finite;
-    readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["added", "deleted", "modified"]>>>, Schema.optionalKey<Schema.Literals<readonly ["added", "deleted", "modified"]>>, never, never>;
-}>;
-export interface Info extends Schema.Schema.Type<typeof Info> {
-}

package/dist/file-diff.js

@@ -1,10 +0,0 @@
-export * as FileDiff from "./file-diff.js";
-import { Schema } from "effect";
-import { optional } from "./schema.js";
-export const Info = Schema.Struct({
-    file: optional(Schema.String),
-    patch: optional(Schema.String),
-    additions: Schema.Finite,
-    deletions: Schema.Finite,
-    status: optional(Schema.Literals(["added", "deleted", "modified"])),
-}).annotate({ identifier: "SnapshotFileDiff" });

package/dist/filesystem-v1.d.ts

@@ -1 +0,0 @@
-export * from "./v1/filesystem.js";

package/dist/filesystem-v1.js

@@ -1 +0,0 @@
-export * from "./v1/filesystem.js";

package/dist/filesystem.d.ts

@@ -1,118 +0,0 @@
-export * as FileSystem from "./filesystem.js";
-import { Schema } from "effect";
-export declare const Event: {
-    Changed: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        readonly type: Schema.Literal<"filesystem.changed">;
-        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>, never, never>;
-        readonly data: Schema.Struct<{
-            readonly file: Schema.String;
-            readonly event: Schema.Literals<readonly ["add", "change", "unlink"]>;
-        }>;
-    }> & {
-        type: "filesystem.changed";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly file: Schema.String;
-            readonly event: Schema.Literals<readonly ["add", "change", "unlink"]>;
-        }>;
-    };
-    Definitions: readonly [Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        readonly type: Schema.Literal<"filesystem.changed">;
-        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>, never, never>;
-        readonly data: Schema.Struct<{
-            readonly file: Schema.String;
-            readonly event: Schema.Literals<readonly ["add", "change", "unlink"]>;
-        }>;
-    }> & {
-        type: "filesystem.changed";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly file: Schema.String;
-            readonly event: Schema.Literals<readonly ["add", "change", "unlink"]>;
-        }>;
-    }];
-};
-export interface Entry extends Schema.Schema.Type<typeof Entry> {
-}
-export declare const Entry: Schema.Struct<{
-    readonly path: Schema.brand<Schema.String, "RelativePath">;
-    readonly type: Schema.Literals<readonly ["file", "directory"]>;
-}>;
-export interface Submatch extends Schema.Schema.Type<typeof Submatch> {
-}
-export declare const Submatch: Schema.Struct<{
-    readonly text: Schema.String;
-    readonly start: Schema.Int;
-    readonly end: Schema.Int;
-}>;
-export interface Match extends Schema.Schema.Type<typeof Match> {
-}
-export declare const Match: Schema.Struct<{
-    readonly entry: Schema.Struct<{
-        readonly path: Schema.brand<Schema.String, "RelativePath">;
-        readonly type: Schema.Literals<readonly ["file", "directory"]>;
-    }>;
-    readonly line: Schema.Int;
-    readonly offset: Schema.Int;
-    readonly text: Schema.String;
-    readonly submatches: Schema.$Array<Schema.Struct<{
-        readonly text: Schema.String;
-        readonly start: Schema.Int;
-        readonly end: Schema.Int;
-    }>>;
-}>;
-declare const FindInput_base: Schema.Class<FindInput, Schema.Struct<{
-    readonly query: Schema.String;
-    readonly type: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["file", "directory"]>>>, Schema.optionalKey<Schema.Literals<readonly ["file", "directory"]>>, never, never>;
-    readonly limit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
-}>, {}>;
-export declare class FindInput extends FindInput_base {
-}

package/dist/filesystem.js

@@ -1,35 +0,0 @@
-export * as FileSystem from "./filesystem.js";
-import { Schema } from "effect";
-import { optional } from "./schema.js";
-import { ephemeral, inventory } from "./event.js";
-import { NonNegativeInt, PositiveInt, RelativePath } from "./schema.js";
-const Changed = ephemeral({
-    type: "filesystem.changed",
-    schema: {
-        file: Schema.String,
-        event: Schema.Literals(["add", "change", "unlink"]),
-    },
-});
-export const Event = { Changed, Definitions: inventory(Changed) };
-export const Entry = Schema.Struct({
-    path: RelativePath,
-    type: Schema.Literals(["file", "directory"]),
-}).annotate({ identifier: "FileSystem.Entry" });
-export const Submatch = Schema.Struct({
-    text: Schema.String,
-    start: NonNegativeInt,
-    end: NonNegativeInt,
-}).annotate({ identifier: "FileSystem.Submatch" });
-export const Match = Schema.Struct({
-    entry: Entry,
-    line: PositiveInt,
-    offset: NonNegativeInt,
-    text: Schema.String,
-    submatches: Schema.Array(Submatch),
-}).annotate({ identifier: "FileSystem.Match" });
-export class FindInput extends Schema.Class("FileSystem.FindInput")({
-    query: Schema.String,
-    type: Schema.Literals(["file", "directory"]).pipe(optional),
-    limit: PositiveInt.pipe(optional),
-}) {
-}