@popcomputer/structured-chat 0.1.0 → 0.2.0

package/dist/core/protocol.d.ts

@@ -2,74 +2,74 @@ import { Effect, Schema } from "effect";
 import { ChatSessionIdSchema, ChatSessionRevisionSchema } from "./session.js";
 /** Bounded plain text emitted by a structured chat presenter. */
 export declare const AssistantTextPartSchema: Schema.Struct<{
-    type: Schema.Literal<["text"]>;
-    text: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.Trimmed;
 }>;
 /** Provider-neutral named data emitted by a structured chat presenter. */
 export declare const AssistantDataPartSchema: Schema.Struct<{
-    type: Schema.Literal<["data"]>;
-    name: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
-    data: typeof Schema.Unknown;
+    readonly type: Schema.Literal<"data">;
+    readonly name: Schema.Trimmed;
+    readonly data: Schema.Unknown;
 }>;
 /** Message parts transported from a structured chat action to a browser. */
-export declare const AssistantMessagePartSchema: Schema.Union<[Schema.Struct<{
-    type: Schema.Literal<["text"]>;
-    text: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+export declare const AssistantMessagePartSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"text">;
+    readonly text: Schema.Trimmed;
 }>, Schema.Struct<{
-    type: Schema.Literal<["data"]>;
-    name: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
-    data: typeof Schema.Unknown;
+    readonly type: Schema.Literal<"data">;
+    readonly name: Schema.Trimmed;
+    readonly data: Schema.Unknown;
 }>]>;
 /** Message parts transported from a structured chat action to a browser. */
 export type AssistantMessagePart = Schema.Schema.Type<typeof AssistantMessagePartSchema>;
 /** Strict assistant message returned by one structured chat action. */
 export declare const StructuredChatAssistantMessageSchema: Schema.Struct<{
-    role: Schema.Literal<["assistant"]>;
-    content: Schema.filter<Schema.NonEmptyArray<Schema.Union<[Schema.Struct<{
-        type: Schema.Literal<["text"]>;
-        text: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+    readonly role: Schema.Literal<"assistant">;
+    readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.Trimmed;
     }>, Schema.Struct<{
-        type: Schema.Literal<["data"]>;
-        name: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
-        data: typeof Schema.Unknown;
-    }>]>>>;
+        readonly type: Schema.Literal<"data">;
+        readonly name: Schema.Trimmed;
+        readonly data: Schema.Unknown;
+    }>]>>;
 }>;
 /** Strict assistant message returned by one structured chat action. */
 export type StructuredChatAssistantMessage = Schema.Schema.Type<typeof StructuredChatAssistantMessageSchema>;
 /** Opaque browser-held reference to one server-owned chat session. */
 export declare const StructuredChatSessionReferenceSchema: Schema.Struct<{
-    id: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
-    revision: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+    readonly id: Schema.Trimmed;
+    readonly revision: Schema.Trimmed;
 }>;
 /** Opaque browser-held reference to one server-owned chat session. */
 export type StructuredChatSessionReference = Schema.Schema.Type<typeof StructuredChatSessionReferenceSchema>;
 /** Browser request carrying no server-owned chat state. */
 export declare const StructuredChatTurnRequestSchema: Schema.Struct<{
-    session: Schema.optional<Schema.Struct<{
-        id: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
-        revision: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+    readonly session: Schema.optional<Schema.Struct<{
+        readonly id: Schema.Trimmed;
+        readonly revision: Schema.Trimmed;
     }>>;
-    message: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+    readonly message: Schema.Trimmed;
 }>;
 /** Browser request carrying no server-owned chat state. */
 export type StructuredChatTurnRequest = Schema.Schema.Type<typeof StructuredChatTurnRequestSchema>;
 /** Versioned browser response for one persisted structured chat turn. */
 export declare const StructuredChatTurnResponseSchema: Schema.Struct<{
-    schemaVersion: Schema.Literal<[1]>;
-    session: Schema.optional<Schema.Struct<{
-        id: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
-        revision: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly session: Schema.optional<Schema.Struct<{
+        readonly id: Schema.Trimmed;
+        readonly revision: Schema.Trimmed;
     }>>;
-    message: Schema.Struct<{
-        role: Schema.Literal<["assistant"]>;
-        content: Schema.filter<Schema.NonEmptyArray<Schema.Union<[Schema.Struct<{
-            type: Schema.Literal<["text"]>;
-            text: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+    readonly message: Schema.Struct<{
+        readonly role: Schema.Literal<"assistant">;
+        readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.Trimmed;
         }>, Schema.Struct<{
-            type: Schema.Literal<["data"]>;
-            name: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
-            data: typeof Schema.Unknown;
-        }>]>>>;
+            readonly type: Schema.Literal<"data">;
+            readonly name: Schema.Trimmed;
+            readonly data: Schema.Unknown;
+        }>]>>;
     }>;
 }>;
 /** Versioned browser response for one persisted structured chat turn. */
@@ -79,102 +79,107 @@ export declare const CollectQuestionView: {
     name: "collect_question";
     version: 1;
     inputSchema: Schema.Struct<{
-        stage: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-        field: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-        text: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-        options: Schema.filter<Schema.Array$<Schema.Struct<{
-            label: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-        }>>>;
+        readonly stage: Schema.Trimmed;
+        readonly field: Schema.Trimmed;
+        readonly text: Schema.Trimmed;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.Trimmed;
+        }>>;
     }>;
     dataSchema: Schema.Struct<{
-        readonly schemaVersion: Schema.Literal<[1]>;
+        readonly schemaVersion: Schema.Literal<1>;
     } & {
-        stage: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-        field: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-        text: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-        options: Schema.filter<Schema.Array$<Schema.Struct<{
-            label: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-        }>>>;
+        readonly stage: Schema.Trimmed;
+        readonly field: Schema.Trimmed;
+        readonly text: Schema.Trimmed;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.Trimmed;
+        }>>;
     }>;
     partSchema: Schema.Struct<{
-        readonly type: Schema.Literal<["data"]>;
-        readonly name: Schema.Literal<["collect_question"]>;
+        readonly type: Schema.Literal<"data">;
+        readonly name: Schema.Literal<"collect_question">;
         readonly data: Schema.Struct<{
-            readonly schemaVersion: Schema.Literal<[1]>;
+            readonly schemaVersion: Schema.Literal<1>;
         } & {
-            stage: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-            field: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-            text: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-            options: Schema.filter<Schema.Array$<Schema.Struct<{
-                label: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-            }>>>;
+            readonly stage: Schema.Trimmed;
+            readonly field: Schema.Trimmed;
+            readonly text: Schema.Trimmed;
+            readonly options: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.Trimmed;
+            }>>;
         }>;
     }>;
     make: (input: {
-        readonly text: string;
         readonly stage: string;
         readonly field: string;
+        readonly text: string;
         readonly options: readonly {
             readonly label: string;
         }[];
     }) => {
-        readonly name: "collect_question";
         readonly type: "data";
+        readonly name: "collect_question";
         readonly data: {
             readonly schemaVersion: 1;
-            readonly text: string;
             readonly stage: string;
             readonly field: string;
+            readonly text: string;
             readonly options: readonly {
                 readonly label: string;
             }[];
         };
     };
-    parseData: (input: import("./json-value.js").JsonValue) => Effect.Effect<{
-        readonly name: "collect_question";
+    parseData: (input: {
+        readonly stage: string;
+        readonly field: string;
+        readonly text: string;
+        readonly options: readonly {
+            readonly label: string;
+        }[];
+    }) => Effect.Effect<{
         readonly type: "data";
+        readonly name: "collect_question";
         readonly data: {
             readonly schemaVersion: 1;
-            readonly text: string;
             readonly stage: string;
             readonly field: string;
+            readonly text: string;
             readonly options: readonly {
                 readonly label: string;
             }[];
         };
-    }, import("effect/ParseResult").ParseError, never>;
+    }, Schema.SchemaError, never>;
     decode: (input: import("./json-value.js").JsonValue) => Effect.Effect<{
-        readonly name: "collect_question";
         readonly type: "data";
+        readonly name: "collect_question";
         readonly data: {
             readonly schemaVersion: 1;
-            readonly text: string;
             readonly stage: string;
             readonly field: string;
+            readonly text: string;
             readonly options: readonly {
                 readonly label: string;
             }[];
         };
-    }, import("effect/ParseResult").ParseError, never>;
-    decodeEither: (input: import("./json-value.js").JsonValue) => import("effect/Either").Either<{
-        readonly name: "collect_question";
+    }, Schema.SchemaError, never>;
+    decodeResult: (input: import("./json-value.js").JsonValue) => import("effect/Result").Result<{
         readonly type: "data";
+        readonly name: "collect_question";
         readonly data: {
             readonly schemaVersion: 1;
-            readonly text: string;
             readonly stage: string;
             readonly field: string;
+            readonly text: string;
             readonly options: readonly {
                 readonly label: string;
             }[];
         };
-    }, import("effect/ParseResult").ParseError>;
+    }, Schema.SchemaError>;
 };
-declare const InvalidChatPresentation_base: Schema.TaggedErrorClass<InvalidChatPresentation, "InvalidChatPresentation", {
-    readonly _tag: Schema.tag<"InvalidChatPresentation">;
-} & {
-    reason: Schema.Literal<["invalid_message"]>;
-}>;
+declare const InvalidChatPresentation_base: Schema.Class<InvalidChatPresentation, Schema.TaggedStruct<"InvalidChatPresentation", {
+    readonly reason: Schema.Literal<"invalid_message">;
+}>, import("effect/Cause").YieldableError>;
 /** Safe reason that application-owned message presentation was rejected. */
 export declare class InvalidChatPresentation extends InvalidChatPresentation_base {
 }

package/dist/core/protocol.js

@@ -4,20 +4,23 @@ import { defineView } from "./view.js";
 /** Bounded plain text emitted by a structured chat presenter. */
 export const AssistantTextPartSchema = Schema.Struct({
     type: Schema.Literal("text"),
-    text: Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(20_000)),
+    text: Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(20_000)),
 });
 /** Provider-neutral named data emitted by a structured chat presenter. */
 export const AssistantDataPartSchema = Schema.Struct({
     type: Schema.Literal("data"),
-    name: Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100), Schema.pattern(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/)),
+    name: Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100), Schema.isPattern(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/)),
     data: Schema.Unknown,
 });
 /** Message parts transported from a structured chat action to a browser. */
-export const AssistantMessagePartSchema = Schema.Union(AssistantTextPartSchema, AssistantDataPartSchema);
+export const AssistantMessagePartSchema = Schema.Union([
+    AssistantTextPartSchema,
+    AssistantDataPartSchema,
+]);
 /** Strict assistant message returned by one structured chat action. */
 export const StructuredChatAssistantMessageSchema = Schema.Struct({
     role: Schema.Literal("assistant"),
-    content: Schema.NonEmptyArray(AssistantMessagePartSchema).pipe(Schema.maxItems(20)),
+    content: Schema.NonEmptyArray(AssistantMessagePartSchema).check(Schema.isMaxLength(20)),
 });
 /** Opaque browser-held reference to one server-owned chat session. */
 export const StructuredChatSessionReferenceSchema = Schema.Struct({
@@ -27,7 +30,7 @@ export const StructuredChatSessionReferenceSchema = Schema.Struct({
 /** Browser request carrying no server-owned chat state. */
 export const StructuredChatTurnRequestSchema = Schema.Struct({
     session: Schema.optional(StructuredChatSessionReferenceSchema),
-    message: Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(50_000)),
+    message: Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(50_000)),
 });
 /** Versioned browser response for one persisted structured chat turn. */
 export const StructuredChatTurnResponseSchema = Schema.Struct({
@@ -40,25 +43,28 @@ export const CollectQuestionView = defineView({
     name: "collect_question",
     version: 1,
     schema: Schema.Struct({
-        stage: Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100)),
-        field: Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100)),
-        text: Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(500)),
+        stage: Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100)),
+        field: Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100)),
+        text: Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(500)),
         options: Schema.Array(Schema.Struct({
-            label: Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100)),
-        })).pipe(Schema.maxItems(20)),
+            label: Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100)),
+        })).check(Schema.isMaxLength(20)),
     }),
 });
 /** Safe reason that application-owned message presentation was rejected. */
 export class InvalidChatPresentation extends Schema.TaggedError()("InvalidChatPresentation", { reason: Schema.Literal("invalid_message") }) {
 }
 /** Construct and validate one plain assistant text part. */
-const makeText = (text) => Schema.validateSync(AssistantTextPartSchema)({ type: "text", text });
+const makeText = (text) => Schema.decodeSync(Schema.toType(AssistantTextPartSchema))({
+    type: "text",
+    text,
+});
 /** Constructors for deterministic assistant message parts. */
 export const Text = {
     make: makeText,
 };
 const invalidPresentation = () => new InvalidChatPresentation({ reason: "invalid_message" });
-const parseResponse = (input) => Schema.decodeUnknown(StructuredChatTurnResponseSchema)(input, {
+const parseResponse = (input) => Schema.decodeUnknownEffect(StructuredChatTurnResponseSchema)(input, {
     onExcessProperty: "error",
 }).pipe(Effect.mapError(invalidPresentation));
 const buildPresentation = (evaluate) => Effect.try({

package/dist/core/question.js

@@ -1,7 +1,8 @@
-import { Schema, unsafeCoerce } from "effect";
-const QuestionTextSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(500));
-const QuestionGoalSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(1_000));
-const ChoiceLabelSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100));
+import { Schema } from "effect";
+const QuestionTextSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(500));
+const QuestionGoalSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(1_000));
+const ChoiceLabelSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100));
+const ChoiceCountSchema = Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: 1, maximum: 20 }));
 const fixed = (text) => ({
     _tag: "FixedQuestion",
     text: Schema.decodeSync(QuestionTextSchema)(text),
@@ -12,8 +13,8 @@ const adaptive = (goal, options) => ({
     fallback: Schema.decodeSync(QuestionTextSchema)(options.fallback),
 });
 const adaptiveChoice = (prompt, options) => {
-    const minimumOptions = Schema.decodeSync(Schema.Number.pipe(Schema.int(), Schema.between(1, 20)))(options.minimumOptions);
-    const maximumOptions = Schema.decodeSync(Schema.Number.pipe(Schema.int(), Schema.between(1, 20)))(options.maximumOptions);
+    const minimumOptions = Schema.decodeSync(ChoiceCountSchema)(options.minimumOptions);
+    const maximumOptions = Schema.decodeSync(ChoiceCountSchema)(options.maximumOptions);
     if (minimumOptions > maximumOptions) {
         throw new Error("Adaptive choice minimumOptions cannot exceed maximumOptions");
     }
@@ -36,21 +37,22 @@ const adaptiveChoice = (prompt, options) => {
     };
 };
 const choice = (text, options) => {
-    const labels = options.map(({ label }) => Schema.decodeSync(ChoiceLabelSchema)(label));
-    const normalized = labels.map((label) => label.toLocaleLowerCase("en"));
+    const firstOption = {
+        ...options[0],
+        label: Schema.decodeSync(ChoiceLabelSchema)(options[0].label),
+    };
+    const remainingOptions = options.slice(1).map((option) => ({
+        ...option,
+        label: Schema.decodeSync(ChoiceLabelSchema)(option.label),
+    }));
+    const normalized = [firstOption, ...remainingOptions].map(({ label }) => label.toLocaleLowerCase("en"));
     if (new Set(normalized).size !== normalized.length) {
         throw new Error("Choice question labels must be unique");
     }
-    const parsedOptions = options.map((option, index) => ({
-        ...option,
-        label: labels[index] ?? option.label,
-    }));
-    // SAFETY: map preserves the non-empty tuple length and each option's value;
-    // every replacement label was parsed at the same array index.
     return {
         _tag: "ChoiceQuestion",
         text: Schema.decodeSync(QuestionTextSchema)(text),
-        options: unsafeCoerce(parsedOptions),
+        options: [firstOption, ...remainingOptions],
     };
 };
 /** Constructors for static, adaptive, and typed choice questions. */

package/dist/core/repair.js

@@ -1,6 +1,6 @@
 import { Schema } from "effect";
 import { structuredDefinition, } from "./definition.js";
-const maximumCorrectionsSchema = Schema.Number.pipe(Schema.int(), Schema.between(1, 20));
+const maximumCorrectionsSchema = Schema.Number.check(Schema.isInt(), Schema.isBetween({ minimum: 1, maximum: 20 }));
 const standard = (options = {}) => structuredDefinition("repair")({
     _tag: "StandardRepair",
     maximumCorrections: Schema.decodeSync(maximumCorrectionsSchema)(options.maximumCorrections ?? 5),

package/dist/core/session.d.ts

@@ -1,53 +1,47 @@
 import { Context, Effect, Schema } from "effect";
 import { type UntrustedMessage } from "./model.js";
 /** Stable application-owned identifier for one chat session. */
-export declare const ChatSessionIdSchema: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+export declare const ChatSessionIdSchema: Schema.Trimmed;
 /** Optional application-owned partition for otherwise public session IDs. */
-export declare const ChatSessionNamespaceSchema: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+export declare const ChatSessionNamespaceSchema: Schema.Trimmed;
 /** Opaque optimistic revision emitted by a session store adapter. */
-export declare const ChatSessionRevisionSchema: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+export declare const ChatSessionRevisionSchema: Schema.Trimmed;
 /** Persisted session snapshot revalidated by the chat runtime after loading. */
 export declare const ChatSessionSnapshotSchema: Schema.Struct<{
-    revision: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
-    state: typeof Schema.Unknown;
-    messages: Schema.filter<Schema.Array$<Schema.Struct<{
-        role: Schema.Literal<["user", "assistant"]>;
-        content: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-    }>>>;
+    readonly revision: Schema.Trimmed;
+    readonly state: Schema.Unknown;
+    readonly messages: Schema.$Array<Schema.Struct<{
+        readonly role: Schema.Literals<readonly ["user", "assistant"]>;
+        readonly content: Schema.Trimmed;
+    }>>;
 }>;
 /** Parsed persisted chat session snapshot. */
 export type ChatSessionSnapshot = Schema.Schema.Type<typeof ChatSessionSnapshotSchema>;
 /** Successful optimistic session replacement returned by an adapter. */
 export declare const ChatSessionReplacementSchema: Schema.Struct<{
-    revision: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+    readonly revision: Schema.Trimmed;
 }>;
 /** Successful optimistic session replacement returned by an adapter. */
 export type ChatSessionReplacement = Schema.Schema.Type<typeof ChatSessionReplacementSchema>;
 /** Safe reason that a session store dependency was unavailable. */
-export declare const ChatSessionStoreUnavailableReasonSchema: Schema.Literal<["load_failed", "write_failed"]>;
-declare const ChatSessionStoreUnavailable_base: Schema.TaggedErrorClass<ChatSessionStoreUnavailable, "ChatSessionStoreUnavailable", {
-    readonly _tag: Schema.tag<"ChatSessionStoreUnavailable">;
-} & {
-    reason: Schema.Literal<["load_failed", "write_failed"]>;
-}>;
+export declare const ChatSessionStoreUnavailableReasonSchema: Schema.Literals<readonly ["load_failed", "write_failed"]>;
+declare const ChatSessionStoreUnavailable_base: Schema.Class<ChatSessionStoreUnavailable, Schema.TaggedStruct<"ChatSessionStoreUnavailable", {
+    readonly reason: Schema.Literals<readonly ["load_failed", "write_failed"]>;
+}>, import("effect/Cause").YieldableError>;
 /** A session store adapter could not load or replace state. */
 export declare class ChatSessionStoreUnavailable extends ChatSessionStoreUnavailable_base {
 }
-declare const ChatSessionConflict_base: Schema.TaggedErrorClass<ChatSessionConflict, "ChatSessionConflict", {
-    readonly _tag: Schema.tag<"ChatSessionConflict">;
-} & {
-    reason: Schema.Literal<["concurrent_update"]>;
-}>;
+declare const ChatSessionConflict_base: Schema.Class<ChatSessionConflict, Schema.TaggedStruct<"ChatSessionConflict", {
+    readonly reason: Schema.Literal<"concurrent_update">;
+}>, import("effect/Cause").YieldableError>;
 /** A concurrent or stale transition attempted to replace newer state. */
 export declare class ChatSessionConflict extends ChatSessionConflict_base {
 }
 /** Safe reason that session input or persisted data was rejected. */
-export declare const InvalidChatSessionReasonSchema: Schema.Literal<["invalid_input", "invalid_snapshot", "invalid_state", "invalid_replacement", "history_limit"]>;
-declare const InvalidChatSession_base: Schema.TaggedErrorClass<InvalidChatSession, "InvalidChatSession", {
-    readonly _tag: Schema.tag<"InvalidChatSession">;
-} & {
-    reason: Schema.Literal<["invalid_input", "invalid_snapshot", "invalid_state", "invalid_replacement", "history_limit"]>;
-}>;
+export declare const InvalidChatSessionReasonSchema: Schema.Literals<readonly ["invalid_input", "invalid_snapshot", "invalid_state", "invalid_replacement", "history_limit"]>;
+declare const InvalidChatSession_base: Schema.Class<InvalidChatSession, Schema.TaggedStruct<"InvalidChatSession", {
+    readonly reason: Schema.Literals<readonly ["invalid_input", "invalid_snapshot", "invalid_state", "invalid_replacement", "history_limit"]>;
+}>, import("effect/Cause").YieldableError>;
 /** Session input or persisted state failed runtime validation. */
 export declare class InvalidChatSession extends InvalidChatSession_base {
 }
@@ -71,7 +65,7 @@ export interface ChatSessionStoreService {
     /** Atomically replace one complete session at its expected revision. */
     readonly replace: (input: ReplaceChatSessionInput) => Effect.Effect<unknown, ChatSessionStoreUnavailable | ChatSessionConflict>;
 }
-declare const ChatSessionStore_base: Context.TagClass<ChatSessionStore, "@popcomputer/structured-chat/ChatSessionStore", ChatSessionStoreService>;
+declare const ChatSessionStore_base: Context.ServiceClass<ChatSessionStore, "@popcomputer/structured-chat/ChatSessionStore", ChatSessionStoreService>;
 /** Effect service for the configured server-owned chat session store. */
 export declare class ChatSessionStore extends ChatSessionStore_base {
 }

package/dist/core/session.js

@@ -1,23 +1,26 @@
 import { Context, Effect, Schema } from "effect";
 import { UntrustedMessageSchema } from "./model.js";
 /** Stable application-owned identifier for one chat session. */
-export const ChatSessionIdSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(200), Schema.pattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/));
+export const ChatSessionIdSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(200), Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/));
 /** Optional application-owned partition for otherwise public session IDs. */
-export const ChatSessionNamespaceSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(200), Schema.pattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/));
+export const ChatSessionNamespaceSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(200), Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/));
 /** Opaque optimistic revision emitted by a session store adapter. */
-export const ChatSessionRevisionSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(200), Schema.pattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/));
+export const ChatSessionRevisionSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(200), Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/));
 /** Persisted session snapshot revalidated by the chat runtime after loading. */
 export const ChatSessionSnapshotSchema = Schema.Struct({
     revision: ChatSessionRevisionSchema,
     state: Schema.Unknown,
-    messages: Schema.Array(UntrustedMessageSchema).pipe(Schema.maxItems(200)),
+    messages: Schema.Array(UntrustedMessageSchema).check(Schema.isMaxLength(200)),
 });
 /** Successful optimistic session replacement returned by an adapter. */
 export const ChatSessionReplacementSchema = Schema.Struct({
     revision: ChatSessionRevisionSchema,
 });
 /** Safe reason that a session store dependency was unavailable. */
-export const ChatSessionStoreUnavailableReasonSchema = Schema.Literal("load_failed", "write_failed");
+export const ChatSessionStoreUnavailableReasonSchema = Schema.Literals([
+    "load_failed",
+    "write_failed",
+]);
 /** A session store adapter could not load or replace state. */
 export class ChatSessionStoreUnavailable extends Schema.TaggedError()("ChatSessionStoreUnavailable", { reason: ChatSessionStoreUnavailableReasonSchema }) {
 }
@@ -25,10 +28,16 @@ export class ChatSessionStoreUnavailable extends Schema.TaggedError()("ChatSessi
 export class ChatSessionConflict extends Schema.TaggedError()("ChatSessionConflict", { reason: Schema.Literal("concurrent_update") }) {
 }
 /** Safe reason that session input or persisted data was rejected. */
-export const InvalidChatSessionReasonSchema = Schema.Literal("invalid_input", "invalid_snapshot", "invalid_state", "invalid_replacement", "history_limit");
+export const InvalidChatSessionReasonSchema = Schema.Literals([
+    "invalid_input",
+    "invalid_snapshot",
+    "invalid_state",
+    "invalid_replacement",
+    "history_limit",
+]);
 /** Session input or persisted state failed runtime validation. */
 export class InvalidChatSession extends Schema.TaggedError()("InvalidChatSession", { reason: InvalidChatSessionReasonSchema }) {
 }
 /** Effect service for the configured server-owned chat session store. */
-export class ChatSessionStore extends Context.Tag("@popcomputer/structured-chat/ChatSessionStore")() {
+export class ChatSessionStore extends Context.Service()("@popcomputer/structured-chat/ChatSessionStore") {
 }

package/dist/core/stage-name.d.ts

@@ -1,3 +1,3 @@
 import { Schema } from "effect";
 /** Stable machine-facing name for one structured chat stage. */
-export declare const StageNameSchema: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+export declare const StageNameSchema: Schema.Trimmed;

package/dist/core/stage-name.js

@@ -1,3 +1,3 @@
 import { Schema } from "effect";
 /** Stable machine-facing name for one structured chat stage. */
-export const StageNameSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100), Schema.pattern(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/));
+export const StageNameSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100), Schema.isPattern(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/));

package/dist/core/stage.d.ts

@@ -2,11 +2,11 @@ import { Effect, Schema } from "effect";
 import { StructuredChatModel, type ChatModelUnavailable, type UnsupportedModelToolSchema, type UntrustedMessage } from "./model.js";
 import type { ModelGuardError, ModelGuardRequirements, ModelGuardTuple } from "./model-guard.js";
 import { type ToolSet, type ToolSetCall, type ToolSetError, type ToolSetExecution, type ToolSetRequirements, type ToolTuple } from "./tool-set.js";
-import type { CommandDefinitionContract, CommandExecutionContext, InvalidToolCall, InvalidToolProjection, StructuredCommand, ToolCall, ToolExecution, QueryToolDefinitionContract } from "./tool.js";
+import type { CommandDefinitionContract, CommandExecutionContext, InvalidToolCall, InvalidToolProjection, StructuredCommand, ToolCall, ToolExecution, QueryToolDefinitionContract, ToolSchema } from "./tool.js";
 import { type StructuredDefinition } from "./definition.js";
 export { StageNameSchema } from "./stage-name.js";
 /** State transition applied after one tool-stage execution. */
-export declare const ToolStageAfterExecutionSchema: Schema.Literal<["stay", "complete"]>;
+export declare const ToolStageAfterExecutionSchema: Schema.Literals<readonly ["stay", "complete"]>;
 /** State transition applied after one tool-stage execution. */
 export type ToolStageAfterExecution = Schema.Schema.Type<typeof ToolStageAfterExecutionSchema>;
 /** Definition input for one stage-scoped, repeatable tool step. */
@@ -21,8 +21,8 @@ export interface DefineToolStageInput<Name extends string, Tools extends ToolTup
 export interface ToolStageRuntime {
     readonly afterExecution: ToolStageAfterExecution;
     readonly toolNames: ReadonlyArray<string>;
-    readonly planWith: (messages: ReadonlyArray<UntrustedMessage>, additionalTool: QueryToolDefinitionContract) => Effect.Effect<ToolCall<string, Schema.Schema.AnyNoContext>, unknown, unknown>;
-    readonly execute: (call: ToolCall<string, Schema.Schema.AnyNoContext>) => Effect.Effect<unknown, unknown, unknown>;
+    readonly planWith: (messages: ReadonlyArray<UntrustedMessage>, additionalTool: QueryToolDefinitionContract) => Effect.Effect<ToolCall<string, ToolSchema>, unknown, unknown>;
+    readonly execute: (call: ToolCall<string, ToolSchema>) => Effect.Effect<unknown, unknown, unknown>;
     readonly run: (messages: ReadonlyArray<UntrustedMessage>) => Effect.Effect<unknown, unknown, unknown>;
 }
 declare const toolStageRuntime: unique symbol;