@popcomputer/structured-chat 0.1.0 → 0.2.0-rc.0

package/dist/core/json-value.js

@@ -1,3 +1,10 @@
 import { Schema } from "effect";
 /** Runtime parser for recursively JSON-serializable values. */
-export const JsonValueSchema = Schema.suspend(() => Schema.Union(Schema.String, Schema.JsonNumber, Schema.Boolean, Schema.Null, Schema.Array(JsonValueSchema), Schema.Record({ key: Schema.String, value: JsonValueSchema })));
+export const JsonValueSchema = Schema.suspend(() => Schema.Union([
+    Schema.String,
+    Schema.Finite,
+    Schema.Boolean,
+    Schema.Null,
+    Schema.Array(JsonValueSchema),
+    Schema.Record(Schema.String, JsonValueSchema),
+]));

package/dist/core/model-guard.d.ts

@@ -1,9 +1,8 @@
 import { Effect, Schema } from "effect";
 import { type StructuredDefinition } from "./definition.js";
 import type { UntrustedMessage } from "./model.js";
-import type { JsonValue } from "./json-value.js";
 /** Stable machine-facing name for one model-boundary policy guard. */
-export declare const ModelGuardNameSchema: Schema.filter<Schema.filter<typeof Schema.NonEmptyTrimmedString>>;
+export declare const ModelGuardNameSchema: Schema.Trimmed;
 /** Safe context supplied before a structured model request begins. */
 export interface ModelGuardContext {
     readonly messages: ReadonlyArray<UntrustedMessage>;
@@ -12,7 +11,7 @@ export interface ModelGuardContext {
 /** Strictly parsed model proposal supplied before application execution. */
 export interface ModelGuardCall {
     readonly name: string;
-    readonly arguments: JsonValue;
+    readonly arguments: unknown;
 }
 /** Safe context supplied after parsing and before a tool executes. */
 export interface ModelGuardCallContext extends ModelGuardContext {

package/dist/core/model-guard.js

@@ -1,7 +1,7 @@
-import { Effect, Schema, unsafeCoerce } from "effect";
+import { Effect, Function as Fn, Schema } from "effect";
 import { structuredDefinition, } from "./definition.js";
 /** Stable machine-facing name for one model-boundary policy guard. */
-export const ModelGuardNameSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100), Schema.pattern(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/));
+export const ModelGuardNameSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100), Schema.isPattern(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/));
 /** Define Effect-native policy checks around a structured model step. */
 export const defineModelGuard = (definition) => {
     Schema.decodeSync(ModelGuardNameSchema)(definition.name);
@@ -17,7 +17,7 @@ export const defineModelGuard = (definition) => {
 const runtimeModelGuard = (guard) => {
     // SAFETY: ModelGuardDefinitionContract carries the package-owned nominal
     // identity and can only be constructed by defineModelGuard.
-    return unsafeCoerce(guard);
+    return Fn.cast(guard);
 };
 const runGuardPhase = (guards, phase, run) => {
     const execution = Effect.forEach(guards, (guard) => (run(runtimeModelGuard(guard)) ?? Effect.void).pipe(Effect.withSpan("popcomputer.structured_chat.model_guard.check", {
@@ -25,7 +25,7 @@ const runGuardPhase = (guards, phase, run) => {
     })), { concurrency: 1, discard: true });
     // SAFETY: guards run sequentially without recovering failures, so the
     // erased Effect has exactly the conditional error and requirement unions.
-    return execution;
+    return Fn.cast(execution);
 };
 /** @internal */
 export const runModelGuards = (guards, context) => {

package/dist/core/model.d.ts

@@ -4,39 +4,35 @@ import { type ModelGuardError, type ModelGuardRequirements, type ModelGuardTuple
 import type { ToolSet, ToolSetCall, ToolSetError, ToolSetExecution, ToolSetRequirements, ModelToolTuple, ToolCallPlanner, ToolTuple } from "./tool-set.js";
 import type { JsonValue } from "./json-value.js";
 /** Bounded application-authored instruction supplied to a model adapter. */
-export declare const TrustedInstructionSchema: Schema.brand<Schema.filter<typeof Schema.NonEmptyTrimmedString>, "TrustedInstruction">;
+export declare const TrustedInstructionSchema: Schema.brand<Schema.Trimmed, "TrustedInstruction">;
 /** Bounded application-authored instruction supplied to a model adapter. */
 export type TrustedInstruction = Schema.Schema.Type<typeof TrustedInstructionSchema>;
 /** Conversation role accepted as untrusted model context. */
-export declare const ConversationRoleSchema: Schema.Literal<["user", "assistant"]>;
+export declare const ConversationRoleSchema: Schema.Literals<readonly ["user", "assistant"]>;
 /** One bounded conversation message treated as untrusted model context. */
 export declare const UntrustedMessageSchema: Schema.Struct<{
-    role: Schema.Literal<["user", "assistant"]>;
-    content: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
+    readonly role: Schema.Literals<readonly ["user", "assistant"]>;
+    readonly content: Schema.Trimmed;
 }>;
 /** One bounded conversation message treated as untrusted model context. */
 export type UntrustedMessage = Schema.Schema.Type<typeof UntrustedMessageSchema>;
 /** @internal Exact content-character count for bounded message arrays. */
 export declare const countUntrustedMessageCharacters: (messages: ReadonlyArray<UntrustedMessage>) => number;
 /** Safe reason that a configured chat model could not complete a step. */
-export declare const ChatModelUnavailableReasonSchema: Schema.Literal<["request_failed", "timed_out", "response_blocked", "invalid_response"]>;
-declare const ChatModelUnavailable_base: Schema.TaggedErrorClass<ChatModelUnavailable, "ChatModelUnavailable", {
-    readonly _tag: Schema.tag<"ChatModelUnavailable">;
-} & {
-    reason: Schema.Literal<["request_failed", "timed_out", "response_blocked", "invalid_response"]>;
-}>;
+export declare const ChatModelUnavailableReasonSchema: Schema.Literals<readonly ["request_failed", "timed_out", "response_blocked", "invalid_response"]>;
+declare const ChatModelUnavailable_base: Schema.Class<ChatModelUnavailable, Schema.TaggedStruct<"ChatModelUnavailable", {
+    readonly reason: Schema.Literals<readonly ["request_failed", "timed_out", "response_blocked", "invalid_response"]>;
+}>, import("effect/Cause").YieldableError>;
 /** A configured chat model could not complete a structured step. */
 export declare class ChatModelUnavailable extends ChatModelUnavailable_base {
 }
 /** Safe reason that a tool schema cannot use strict provider decoding. */
-export declare const UnsupportedModelToolSchemaReasonSchema: Schema.Literal<["root_not_object", "additional_properties_allowed", "optional_property"]>;
-declare const UnsupportedModelToolSchema_base: Schema.TaggedErrorClass<UnsupportedModelToolSchema, "UnsupportedModelToolSchema", {
-    readonly _tag: Schema.tag<"UnsupportedModelToolSchema">;
-} & {
-    tool: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-    path: Schema.filter<typeof Schema.NonEmptyTrimmedString>;
-    reason: Schema.Literal<["root_not_object", "additional_properties_allowed", "optional_property"]>;
-}>;
+export declare const UnsupportedModelToolSchemaReasonSchema: Schema.Literals<readonly ["root_not_object", "additional_properties_allowed", "optional_property"]>;
+declare const UnsupportedModelToolSchema_base: Schema.Class<UnsupportedModelToolSchema, Schema.TaggedStruct<"UnsupportedModelToolSchema", {
+    readonly tool: Schema.Trimmed;
+    readonly path: Schema.Trimmed;
+    readonly reason: Schema.Literals<readonly ["root_not_object", "additional_properties_allowed", "optional_property"]>;
+}>, import("effect/Cause").YieldableError>;
 /** A model tool schema is incompatible with strict provider decoding. */
 export declare class UnsupportedModelToolSchema extends UnsupportedModelToolSchema_base {
 }
@@ -54,7 +50,7 @@ export interface StructuredChatModelService {
     /** Return one untrusted provider tool call for runtime validation. */
     readonly requestTool: (request: ToolModelRequest) => Effect.Effect<JsonValue, ChatModelUnavailable | UnsupportedModelToolSchema>;
 }
-declare const StructuredChatModel_base: Context.TagClass<StructuredChatModel, "@popcomputer/structured-chat/StructuredChatModel", StructuredChatModelService>;
+declare const StructuredChatModel_base: Context.ServiceClass<StructuredChatModel, "@popcomputer/structured-chat/StructuredChatModel", StructuredChatModelService>;
 /** Effect service for the configured structured chat model adapter. */
 export declare class StructuredChatModel extends StructuredChatModel_base {
 }

package/dist/core/model.js

@@ -1,32 +1,44 @@
 import { Context, Effect, Schema } from "effect";
 import { runModelCallGuards, runModelGuards, } from "./model-guard.js";
 /** Bounded application-authored instruction supplied to a model adapter. */
-export const TrustedInstructionSchema = Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(20_000), Schema.brand("TrustedInstruction"));
+export const TrustedInstructionSchema = Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(20_000)).pipe(Schema.brand("TrustedInstruction"));
 /** Conversation role accepted as untrusted model context. */
-export const ConversationRoleSchema = Schema.Literal("user", "assistant");
+export const ConversationRoleSchema = Schema.Literals([
+    "user",
+    "assistant",
+]);
 /** One bounded conversation message treated as untrusted model context. */
 export const UntrustedMessageSchema = Schema.Struct({
     role: ConversationRoleSchema,
-    content: Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(50_000)),
+    content: Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(50_000)),
 });
 /** @internal Exact content-character count for bounded message arrays. */
 export const countUntrustedMessageCharacters = (messages) => messages.reduce((total, message) => total + message.content.length, 0);
 /** Safe reason that a configured chat model could not complete a step. */
-export const ChatModelUnavailableReasonSchema = Schema.Literal("request_failed", "timed_out", "response_blocked", "invalid_response");
+export const ChatModelUnavailableReasonSchema = Schema.Literals([
+    "request_failed",
+    "timed_out",
+    "response_blocked",
+    "invalid_response",
+]);
 /** A configured chat model could not complete a structured step. */
 export class ChatModelUnavailable extends Schema.TaggedError()("ChatModelUnavailable", { reason: ChatModelUnavailableReasonSchema }) {
 }
 /** Safe reason that a tool schema cannot use strict provider decoding. */
-export const UnsupportedModelToolSchemaReasonSchema = Schema.Literal("root_not_object", "additional_properties_allowed", "optional_property");
+export const UnsupportedModelToolSchemaReasonSchema = Schema.Literals([
+    "root_not_object",
+    "additional_properties_allowed",
+    "optional_property",
+]);
 /** A model tool schema is incompatible with strict provider decoding. */
 export class UnsupportedModelToolSchema extends Schema.TaggedError()("UnsupportedModelToolSchema", {
-    tool: Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(100)),
-    path: Schema.NonEmptyTrimmedString.pipe(Schema.maxLength(2_000)),
+    tool: Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(100)),
+    path: Schema.Trimmed.check(Schema.isNonEmpty(), Schema.isMaxLength(2_000)),
     reason: UnsupportedModelToolSchemaReasonSchema,
 }) {
 }
 /** Effect service for the configured structured chat model adapter. */
-export class StructuredChatModel extends Context.Tag("@popcomputer/structured-chat/StructuredChatModel")() {
+export class StructuredChatModel extends Context.Service()("@popcomputer/structured-chat/StructuredChatModel") {
 }
 const invalidOutputRepairInstruction = Schema.decodeSync(TrustedInstructionSchema)("Your previous response did not satisfy the required tool-call contract. Call exactly one listed tool and return only arguments allowed by its JSON Schema.");
 const isRepairableModelOutput = (error) => error._tag === "InvalidToolCall" ||
@@ -36,7 +48,7 @@ const isRepairableModelOutput = (error) => error._tag === "InvalidToolCall" ||
 export const planToolCall = (input) => runModelGuards(input.guards ?? [], {
     messages: input.messages,
     toolNames: input.tools.models.map(({ name }) => name),
-}).pipe(Effect.zipRight(StructuredChatModel), Effect.flatMap((model) => {
+}).pipe(Effect.andThen(StructuredChatModel), Effect.flatMap((model) => {
     const requestParsedCall = (instructions, attempt) => model
         .requestTool({
         instructions,
@@ -68,7 +80,7 @@ export const planToolCall = (input) => runModelGuards(input.guards ?? [], {
                 errorTag: error._tag,
                 errorReason: error.reason,
             };
-        return Effect.logWarning("Retrying structured model output").pipe(Effect.annotateLogs(annotations), Effect.zipRight(requestParsedCall([
+        return Effect.logWarning("Retrying structured model output").pipe(Effect.annotateLogs(annotations), Effect.andThen(requestParsedCall([
             ...input.instructions,
             invalidOutputRepairInstruction,
         ], 2)));

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),