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

package/dist/permission.d.ts

@@ -1,306 +0,0 @@
-export * as Permission from "./permission.js";
-import { Schema } from "effect";
-export declare const ID: Schema.brand<Schema.String, "PermissionV2.ID"> & {
-    create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
-};
-export type ID = typeof ID.Type;
-export declare const Source: Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.Literal<"tool">;
-    readonly messageID: Schema.String;
-    readonly callID: Schema.String;
-}>]>;
-export type Source = typeof Source.Type;
-export declare const Request: Schema.Struct<{
-    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-        create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-    };
-    readonly action: Schema.String;
-    readonly resources: Schema.$Array<Schema.String>;
-    readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
-        readonly type: Schema.Literal<"tool">;
-        readonly messageID: Schema.String;
-        readonly callID: Schema.String;
-    }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
-        readonly type: Schema.Literal<"tool">;
-        readonly messageID: Schema.String;
-        readonly callID: Schema.String;
-    }>]>>, never, never>;
-    readonly id: Schema.brand<Schema.String, "PermissionV2.ID"> & {
-        create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
-    };
-}>;
-export interface Request extends Schema.Schema.Type<typeof Request> {
-}
-export declare const Reply: Schema.Literals<readonly ["once", "always", "reject"]>;
-export type Reply = typeof Reply.Type;
-export declare const Event: {
-    Asked: 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<"permission.v2.asked">;
-        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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
-                create: () => string & import("effect/Brand").Brand<"SessionID">;
-                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly action: Schema.String;
-            readonly resources: Schema.$Array<Schema.String>;
-            readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"tool">;
-                readonly messageID: Schema.String;
-                readonly callID: Schema.String;
-            }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"tool">;
-                readonly messageID: Schema.String;
-                readonly callID: Schema.String;
-            }>]>>, never, never>;
-            readonly id: Schema.brand<Schema.String, "PermissionV2.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
-            };
-        }>;
-    }> & {
-        type: "permission.v2.asked";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-                create: () => string & import("effect/Brand").Brand<"SessionID">;
-                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly action: Schema.String;
-            readonly resources: Schema.$Array<Schema.String>;
-            readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"tool">;
-                readonly messageID: Schema.String;
-                readonly callID: Schema.String;
-            }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"tool">;
-                readonly messageID: Schema.String;
-                readonly callID: Schema.String;
-            }>]>>, never, never>;
-            readonly id: Schema.brand<Schema.String, "PermissionV2.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
-            };
-        }>;
-    };
-    Replied: 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<"permission.v2.replied">;
-        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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
-                create: () => string & import("effect/Brand").Brand<"SessionID">;
-                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly requestID: Schema.brand<Schema.String, "PermissionV2.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
-            };
-            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
-        }>;
-    }> & {
-        type: "permission.v2.replied";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-                create: () => string & import("effect/Brand").Brand<"SessionID">;
-                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly requestID: Schema.brand<Schema.String, "PermissionV2.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
-            };
-            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
-        }>;
-    };
-    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<"permission.v2.asked">;
-        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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
-                create: () => string & import("effect/Brand").Brand<"SessionID">;
-                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly action: Schema.String;
-            readonly resources: Schema.$Array<Schema.String>;
-            readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"tool">;
-                readonly messageID: Schema.String;
-                readonly callID: Schema.String;
-            }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"tool">;
-                readonly messageID: Schema.String;
-                readonly callID: Schema.String;
-            }>]>>, never, never>;
-            readonly id: Schema.brand<Schema.String, "PermissionV2.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
-            };
-        }>;
-    }> & {
-        type: "permission.v2.asked";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-                create: () => string & import("effect/Brand").Brand<"SessionID">;
-                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly action: Schema.String;
-            readonly resources: Schema.$Array<Schema.String>;
-            readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, 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 source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"tool">;
-                readonly messageID: Schema.String;
-                readonly callID: Schema.String;
-            }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"tool">;
-                readonly messageID: Schema.String;
-                readonly callID: Schema.String;
-            }>]>>, never, never>;
-            readonly id: Schema.brand<Schema.String, "PermissionV2.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
-            };
-        }>;
-    }, 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<"permission.v2.replied">;
-        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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
-                create: () => string & import("effect/Brand").Brand<"SessionID">;
-                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly requestID: Schema.brand<Schema.String, "PermissionV2.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
-            };
-            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
-        }>;
-    }> & {
-        type: "permission.v2.replied";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-                create: () => string & import("effect/Brand").Brand<"SessionID">;
-                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly requestID: Schema.brand<Schema.String, "PermissionV2.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
-            };
-            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
-        }>;
-    }];
-};
-export declare const Effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
-export type Effect = typeof Effect.Type;
-export interface Rule extends Schema.Schema.Type<typeof Rule> {
-}
-export declare const Rule: Schema.Struct<{
-    readonly action: Schema.String;
-    readonly resource: Schema.String;
-    readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
-}>;
-export declare const Ruleset: Schema.$Array<Schema.Struct<{
-    readonly action: Schema.String;
-    readonly resource: Schema.String;
-    readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
-}>>;
-export type Ruleset = typeof Ruleset.Type;

package/dist/permission.js

@@ -1,45 +0,0 @@
-export * as Permission from "./permission.js";
-import { Schema } from "effect";
-import { optional } from "./schema.js";
-import { ephemeral, inventory } from "./event.js";
-import { ascending } from "./identifier.js";
-import { SessionID } from "./session-id.js";
-import { statics } from "./schema.js";
-export const ID = Schema.String.check(Schema.isStartsWith("per")).pipe(Schema.brand("PermissionV2.ID"), statics((schema) => ({ create: (id) => schema.make(id ?? "per_" + ascending()) })));
-export const Source = Schema.Union([
-    Schema.Struct({
-        type: Schema.Literal("tool"),
-        messageID: Schema.String,
-        callID: Schema.String,
-    }),
-]).annotate({ identifier: "PermissionV2.Source" });
-const RequestFields = {
-    sessionID: SessionID,
-    action: Schema.String,
-    resources: Schema.Array(Schema.String),
-    save: Schema.Array(Schema.String).pipe(optional),
-    metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
-    source: Source.pipe(optional),
-};
-export const Request = Schema.Struct({
-    id: ID,
-    ...RequestFields,
-}).annotate({ identifier: "PermissionV2.Request" });
-export const Reply = Schema.Literals(["once", "always", "reject"]).annotate({ identifier: "PermissionV2.Reply" });
-const Asked = ephemeral({ type: "permission.v2.asked", schema: Request.fields });
-const Replied = ephemeral({
-    type: "permission.v2.replied",
-    schema: {
-        sessionID: SessionID,
-        requestID: ID,
-        reply: Reply,
-    },
-});
-export const Event = { Asked, Replied, Definitions: inventory(Asked, Replied) };
-export const Effect = Schema.Literals(["allow", "deny", "ask"]).annotate({ identifier: "PermissionV2.Effect" });
-export const Rule = Schema.Struct({
-    action: Schema.String,
-    resource: Schema.String,
-    effect: Effect,
-}).annotate({ identifier: "PermissionV2.Rule" });
-export const Ruleset = Schema.Array(Rule).annotate({ identifier: "PermissionV2.Ruleset" });

package/dist/plugin.d.ts

@@ -1,85 +0,0 @@
-export * as Plugin from "./plugin.js";
-import { Schema } from "effect";
-export declare const ID: Schema.brand<Schema.String, "Plugin.ID">;
-export type ID = typeof ID.Type;
-export interface Info extends Schema.Schema.Type<typeof Info> {
-}
-export declare const Info: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Plugin.ID">;
-}>;
-export declare const Event: {
-    Added: 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<"plugin.added">;
-        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 id: Schema.brand<Schema.String, "Plugin.ID">;
-        }>;
-    }> & {
-        type: "plugin.added";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Plugin.ID">;
-        }>;
-    };
-    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<"plugin.added">;
-        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 id: Schema.brand<Schema.String, "Plugin.ID">;
-        }>;
-    }> & {
-        type: "plugin.added";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Plugin.ID">;
-        }>;
-    }];
-};

package/dist/plugin.js

@@ -1,12 +0,0 @@
-export * as Plugin from "./plugin.js";
-import { Schema } from "effect";
-import { ephemeral, inventory } from "./event.js";
-export const ID = Schema.String.pipe(Schema.brand("Plugin.ID"));
-export const Info = Schema.Struct({
-    id: ID,
-}).annotate({ identifier: "Plugin.Info" });
-const Added = ephemeral({
-    type: "plugin.added",
-    schema: { id: ID },
-});
-export const Event = { Added, Definitions: inventory(Added) };

package/dist/project-copy.d.ts

@@ -1,29 +0,0 @@
-export * as ProjectCopy from "./project-copy.js";
-import { Schema } from "effect";
-export declare const StrategyID: Schema.brand<Schema.Trim, "ProjectCopy.StrategyID">;
-export type StrategyID = typeof StrategyID.Type;
-export declare const CreateInput: Schema.Struct<{
-    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
-        global: string & import("effect/Brand").Brand<"Project.ID">;
-    };
-    readonly strategy: Schema.brand<Schema.Trim, "ProjectCopy.StrategyID">;
-    readonly sourceDirectory: Schema.brand<Schema.String, "AbsolutePath">;
-    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-}>;
-export interface CreateInput extends Schema.Schema.Type<typeof CreateInput> {
-}
-export declare const RemoveInput: Schema.Struct<{
-    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
-        global: string & import("effect/Brand").Brand<"Project.ID">;
-    };
-    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-    readonly force: Schema.Boolean;
-}>;
-export interface RemoveInput extends Schema.Schema.Type<typeof RemoveInput> {
-}
-export declare const Copy: Schema.Struct<{
-    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-}>;
-export interface Copy extends Schema.Schema.Type<typeof Copy> {
-}

package/dist/project-copy.js

@@ -1,21 +0,0 @@
-export * as ProjectCopy from "./project-copy.js";
-import { Schema } from "effect";
-import { optional } from "./schema.js";
-import { ProjectID } from "./project-id.js";
-import { AbsolutePath } from "./schema.js";
-export const StrategyID = Schema.Trim.pipe(Schema.check(Schema.isNonEmpty()), Schema.brand("ProjectCopy.StrategyID"));
-export const CreateInput = Schema.Struct({
-    projectID: ProjectID,
-    strategy: StrategyID,
-    sourceDirectory: AbsolutePath,
-    directory: AbsolutePath,
-    name: optional(Schema.String),
-}).annotate({ identifier: "ProjectCopy.CreateInput" });
-export const RemoveInput = Schema.Struct({
-    projectID: ProjectID,
-    directory: AbsolutePath,
-    force: Schema.Boolean,
-}).annotate({ identifier: "ProjectCopy.RemoveInput" });
-export const Copy = Schema.Struct({
-    directory: AbsolutePath,
-}).annotate({ identifier: "ProjectCopy.Copy" });

package/dist/project-directories.d.ts

@@ -1,85 +0,0 @@
-export * as ProjectDirectories from "./project-directories.js";
-export declare const Event: {
-    Updated: import("effect/Schema").Struct<{
-        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>;
-        readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
-        readonly type: import("effect/Schema").Literal<"project.directories.updated">;
-        readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: import("effect/Schema").Struct<{
-            readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-        }>;
-    }> & {
-        type: "project.directories.updated";
-        durability: "ephemeral";
-        durable: undefined;
-        data: import("effect/Schema").Struct<{
-            readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-        }>;
-    };
-    Definitions: readonly [import("effect/Schema").Struct<{
-        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: import("effect/Schema").decodeTo<import("effect/Schema").DateTimeUtc, import("effect/Schema").Finite, never, never>;
-        readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
-        readonly type: import("effect/Schema").Literal<"project.directories.updated">;
-        readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: import("effect/Schema").Struct<{
-            readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-        }>;
-    }> & {
-        type: "project.directories.updated";
-        durability: "ephemeral";
-        durable: undefined;
-        data: import("effect/Schema").Struct<{
-            readonly projectID: import("effect/Schema").brand<import("effect/Schema").String, "Project.ID"> & {
-                global: string & import("effect/Brand").Brand<"Project.ID">;
-            };
-        }>;
-    }];
-};

package/dist/project-directories.js

@@ -1,8 +0,0 @@
-export * as ProjectDirectories from "./project-directories.js";
-import { ephemeral, inventory } from "./event.js";
-import { Project } from "./project.js";
-const Updated = ephemeral({
-    type: "project.directories.updated",
-    schema: { projectID: Project.ID },
-});
-export const Event = { Updated, Definitions: inventory(Updated) };

package/dist/project-id.d.ts

@@ -1,5 +0,0 @@
-import { Schema } from "effect";
-export declare const ProjectID: Schema.brand<Schema.String, "Project.ID"> & {
-    global: string & import("effect/Brand").Brand<"Project.ID">;
-};
-export type ProjectID = typeof ProjectID.Type;

package/dist/project-id.js

@@ -1,3 +0,0 @@
-import { Schema } from "effect";
-import { statics } from "./schema.js";
-export const ProjectID = Schema.String.pipe(Schema.brand("Project.ID"), statics((schema) => ({ global: schema.make("global") })));