@krak-stack/registry 0.1.38 → 0.1.40

package/dist/lib/httpapi-toolkit.js

@@ -1,24 +1,44 @@
 // ../../src/lib/httpapi-toolkit.ts
-import { Effect as Effect3, Layer as Layer3, Schema as Schema3 } from "effect";
+import { Effect as Effect2, Schema as Schema2 } from "effect";
 import { Tool, Toolkit } from "effect/ai";
 
-// ../../src/lib/httpapi-client.ts
-import { Context, Effect, Layer, Schema, SchemaTransformation } from "effect";
-import { HttpClient } from "effect/http";
+// ../../src/lib/httpapi-adapter.ts
 import {
-  HttpApi,
-  HttpApiClient as EffectHttpApiClient,
-  OpenApi
-} from "effect/http-api";
-var executeHttpApiOperation = Effect.fn("HttpApiClient.executeOperation")((options, client) => client.execute({
-  operation: options.operation,
-  input: {
-    body: options.input.body,
-    headers: options.input.headers ?? {},
-    params: options.input.params ?? {},
-    query: options.input.query ?? {}
-  }
-}));
+  Context,
+  Effect,
+  Layer,
+  Option,
+  Schema,
+  SchemaTransformation
+} from "effect";
+import { HttpClient } from "effect/http";
+import { HttpApi, HttpApiClient, OpenApi } from "effect/http-api";
+var HttpApiMethods = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete"
+];
+var HttpApiOperation = Schema.Struct({
+  operationId: Schema.optional(Schema.String),
+  summary: Schema.optional(Schema.String),
+  description: Schema.optional(Schema.String),
+  tags: Schema.optional(Schema.Array(Schema.String)),
+  parameters: Schema.optional(Schema.Array(Schema.Struct({
+    name: Schema.String,
+    in: Schema.Literals(["path", "query", "header", "cookie"]),
+    required: Schema.optional(Schema.Boolean),
+    description: Schema.optional(Schema.String),
+    schema: Schema.optional(Schema.Json)
+  }))),
+  requestBody: Schema.optional(Schema.Struct({
+    required: Schema.optional(Schema.Boolean),
+    content: Schema.optional(Schema.Record(Schema.String, Schema.Struct({
+      schema: Schema.optional(Schema.Json)
+    })))
+  }))
+}).annotate({ identifier: "HttpApiOperation" });
 var UndefinedFromNull = Schema.Null.pipe(Schema.decodeTo(Schema.Undefined, SchemaTransformation.transform({
   decode: () => {
     return;
@@ -40,202 +60,132 @@ var HttpApiOperationResult = Schema.Union([
   HttpApiOperationResultValue,
   Schema.Undefined
 ]).annotate({ identifier: "HttpApiOperationResult" });
-var encodeHttpApiOperationResult = Effect.fn("HttpApiClient.encodeOperationResult")((result) => Schema.encodeUnknownEffect(HttpApiOperationResult)(result).pipe(Effect.map((encoded) => encoded ?? null), Effect.mapError((cause) => new Error("HTTP API result is not serializable", { cause }))));
+var encodeHttpApiOperationResult = Effect.fn("HttpApiAdapter.encodeOperationResult")((result) => Schema.encodeUnknownEffect(HttpApiOperationResult)(result).pipe(Effect.map((encoded) => encoded ?? null), Effect.mapError((cause) => new Error("HTTP API result is not serializable", { cause }))));
+var encodeOperationResult = Effect.fn("HttpApiAdapter.encodeResult")((result, operation) => operation.successSchema ? Schema.encodeUnknownEffect(operation.successSchema)(result).pipe(Effect.flatMap(encodeHttpApiOperationResult), Effect.mapError((cause) => new Error("HTTP API result does not match its success schema", {
+  cause
+}))) : encodeHttpApiOperationResult(result));
 var reflectedSchema = (schema) => Schema.make(schema.ast);
-var operationResultSchemas = (api) => {
-  const schemas = new Map;
-  HttpApi.reflect(api, {
-    onGroup: () => {
-      return;
-    },
-    onEndpoint: ({ endpoint, group, successes }) => {
-      const operationId = Context.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
-      const operationSchemas = Array.from(successes.values()).flat().map(reflectedSchema);
-      if (operationSchemas.length === 1 && operationSchemas[0]) {
-        schemas.set(operationId, operationSchemas[0]);
-      } else if (operationSchemas.length > 1) {
-        schemas.set(operationId, Schema.Union(operationSchemas));
+var sanitizeHttpName = (name) => name.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+var httpApiToolName = (entry) => (entry.operation.operationId || `${entry.method}_${entry.path.replace(/^\/api\//, "").replace(/[/:{}]/g, "_")}`).replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").slice(0, 64);
+var makeCatalogue = (api, methods, include) => Effect.try({
+  try: () => {
+    if (!HttpApi.isHttpApi(api))
+      throw new Error("HttpApiAdapter requires a valid HttpApi");
+    const spec = OpenApi.fromApi(api);
+    const reflected = new Map;
+    HttpApi.reflect(api, {
+      onGroup: () => {
+        return;
+      },
+      onEndpoint: ({ endpoint, group, successes }) => {
+        const operationId = Context.getOrElse(endpoint.annotations, OpenApi.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
+        if (reflected.has(operationId))
+          throw new Error(`Duplicate HTTP API operation ID: ${operationId}`);
+        const fields = {};
+        if (endpoint.params)
+          fields.params = Schema.toType(reflectedSchema(endpoint.params));
+        if (endpoint.query)
+          fields.query = Schema.optionalKey(Schema.toType(reflectedSchema(endpoint.query)));
+        if (endpoint.headers)
+          fields.headers = Schema.optionalKey(Schema.toType(reflectedSchema(endpoint.headers)));
+        const payloads = Array.from(endpoint.payload.values()).flatMap(({ schemas }) => schemas.map(reflectedSchema));
+        if (payloads.length === 1 && payloads[0])
+          fields.body = payloads[0];
+        else if (payloads.length > 1)
+          fields.body = Schema.Union(payloads);
+        const input = Object.keys(fields).length === 0 ? Schema.Record(Schema.String, Schema.Never) : Schema.Struct(fields);
+        const inputSchema = Schema.make(Schema.toCodecJson(input).ast).annotate({
+          identifier: `${sanitizeHttpName(operationId)}ToolInput`
+        });
+        const successSchemas = Array.from(successes.values()).flat().map(reflectedSchema);
+        reflected.set(operationId, {
+          groupIdentifier: group.identifier,
+          endpointIdentifier: endpoint.identifier,
+          topLevel: group.topLevel,
+          inputSchema,
+          successSchema: successSchemas.length === 1 ? successSchemas[0] : successSchemas.length > 1 ? Schema.Union(successSchemas) : undefined
+        });
+      }
+    });
+    const names = new Set;
+    const operations = [];
+    for (const [path, pathItem] of Object.entries(spec.paths)) {
+      for (const method of methods) {
+        const decoded = Schema.decodeUnknownOption(HttpApiOperation)(pathItem[method]);
+        if (Option.isNone(decoded))
+          continue;
+        const entry = { method, path, operation: decoded.value };
+        if (include && !include(entry))
+          continue;
+        const metadata = entry.operation.operationId ? reflected.get(entry.operation.operationId) : undefined;
+        if (!metadata)
+          throw new Error(`Missing endpoint schema for ${entry.operation.operationId}`);
+        const name = httpApiToolName(entry);
+        if (!name || names.has(name))
+          throw new Error(`Duplicate or empty HTTP API tool name: ${name}`);
+        names.add(name);
+        const document = Schema.toJsonSchemaDocument(metadata.inputSchema.annotate({ identifier: undefined }));
+        operations.push({
+          ...entry,
+          ...metadata,
+          name,
+          inputJsonSchema: {
+            ...document.schema,
+            $defs: document.definitions
+          },
+          readOnly: method === "get",
+          destructive: method === "delete",
+          idempotent: method === "get" || method === "put" || method === "delete"
+        });
       }
     }
-  });
-  return schemas;
-};
-var makeHttpApiOperationResultEncoder = (api) => {
-  const schemas = operationResultSchemas(api);
-  return Effect.fn("HttpApiClient.encodeOperationResultWithSchema")((result, operation) => {
-    const operationId = operation.operation.operationId;
-    const schema = operationId ? schemas.get(operationId) : undefined;
-    if (!schema)
-      return encodeHttpApiOperationResult(result);
-    return Schema.encodeUnknownEffect(schema)(result).pipe(Effect.flatMap(encodeHttpApiOperationResult), Effect.mapError((cause) => new Error("HTTP API result does not match its success schema", {
-      cause
-    })));
-  });
-};
+    return { info: spec.info, operations };
+  },
+  catch: (cause) => new Error("Failed to build HTTP API adapter catalogue", { cause })
+});
 var GeneratedOperation = Schema.declare((value) => value instanceof Function).annotate({ identifier: "GeneratedOperation" });
 var GeneratedOperationEffect = Schema.declare((value) => Effect.isEffect(value)).annotate({ identifier: "GeneratedOperationEffect" });
-var makeGeneratedClient = (api, http, baseUrl) => EffectHttpApiClient.makeWith(api, {
-  baseUrl,
-  httpClient: http
-});
-var executeGeneratedOperation = Effect.fn("HttpApiClient.executeGeneratedOperation")(function* (client, { input, operation: entry }) {
-  const operationId = entry.operation.operationId;
-  if (!operationId) {
-    return yield* Effect.fail(new Error(`No generated API client operation for ${entry.method} ${entry.path}`));
-  }
-  const target = Object(client);
-  const groupName = Object.keys(target).filter((name) => operationId.startsWith(`${name}.`)).sort((a, b) => b.length - a.length)[0];
-  const group = groupName ? Object.entries(target).find(([name]) => name === groupName)?.[1] : target;
-  const endpointName = groupName ? operationId.slice(groupName.length + 1) : operationId;
-  const endpointCandidate = group instanceof Function ? undefined : Object.entries(Object(group)).find(([name]) => name === endpointName)?.[1];
-  const endpoint = Schema.decodeUnknownOption(GeneratedOperation)(endpointCandidate);
-  if (endpoint._tag === "None") {
-    return yield* Effect.fail(new Error(`No generated API client operation for ${operationId}`));
-  }
+var executeGeneratedOperation = Effect.fn("HttpApiAdapter.executeGeneratedOperation")(function* (client, { operation, input }) {
+  const group = operation.topLevel ? client : Object.entries(Object(client)).find(([name]) => name === operation.groupIdentifier)?.[1];
+  const candidate = Object.entries(Object(group)).find(([name]) => name === operation.endpointIdentifier)?.[1];
+  const endpoint = Schema.decodeUnknownOption(GeneratedOperation)(candidate);
+  if (Option.isNone(endpoint))
+    return yield* Effect.fail(new Error(`No generated API client operation for ${operation.operation.operationId}`));
   const result = Schema.decodeUnknownOption(GeneratedOperationEffect)(endpoint.value({
-    headers: input.headers,
-    params: input.params,
-    query: input.query,
+    headers: input.headers ?? {},
+    params: input.params ?? {},
+    query: input.query ?? {},
     payload: input.body
   }));
-  if (result._tag === "None") {
-    return yield* Effect.fail(new Error(`Generated API client operation ${operationId} is invalid`));
-  }
+  if (Option.isNone(result))
+    return yield* Effect.fail(new Error(`Generated API client operation ${operation.operation.operationId} is invalid`));
   return yield* result.value;
 });
 
-class ApiClient extends Context.Service()("ApiClient") {
-  static layer = (config) => Layer.effect(this, Effect.gen(function* () {
-    const http = yield* HttpClient.HttpClient;
-    const encodeResult = makeHttpApiOperationResultEncoder(config.api);
-    const client = yield* makeGeneratedClient(config.api, http, config.baseUrl);
-    return {
-      encodeResult: config.encodeResult ?? ((result, operation) => encodeResult(result, operation)),
-      execute: Effect.fn("ApiClient.execute")(function* (options) {
-        return yield* executeGeneratedOperation(client, options);
+class HttpApiAdapter extends Context.Service()("@krak-stack/registry/HttpApiAdapter") {
+  static make = Effect.fn("HttpApiAdapter.make")(function* (config) {
+    const catalogue = yield* makeCatalogue(config.api, config.methods ?? HttpApiMethods, config.include);
+    const httpClient = yield* HttpClient.HttpClient;
+    const client = yield* HttpApiClient.makeWith(config.api, {
+      baseUrl: config.baseUrl,
+      httpClient
+    });
+    return HttpApiAdapter.of({
+      ...catalogue,
+      encodeResult: config.encodeResult ?? encodeOperationResult,
+      execute: Effect.fn("HttpApiAdapter.execute")(function* (options) {
+        const operation = catalogue.operations.find((entry) => entry.method === options.operation.method && entry.path === options.operation.path && entry.operation.operationId === options.operation.operation.operationId);
+        if (!operation) {
+          return yield* Effect.fail(new Error("Operation is not in this HTTP API adapter catalogue"));
+        }
+        return yield* executeGeneratedOperation(client, {
+          operation,
+          input: options.input
+        });
       })
-    };
-  }));
-}
-
-// ../../src/lib/httpapi-helpers.tsx
-import { Context as Context2, Effect as Effect2, Layer as Layer2, Option, Schema as Schema2 } from "effect";
-import { HttpApi as HttpApi2, OpenApi as OpenApi2 } from "effect/http-api";
-var JsonObjectSchema = Schema2.Record(Schema2.String, Schema2.Json).annotate({
-  identifier: "HttpJsonObject",
-  title: "HTTP JSON object",
-  description: "A JSON object passed to an HTTP API operation.",
-  examples: [{ id: "example-id" }]
-});
-var JsonObjectFromString = Schema2.fromJsonString(JsonObjectSchema);
-var JsonValueFromString = Schema2.fromJsonString(Schema2.Json);
-var HttpApiMethods = [
-  "get",
-  "post",
-  "put",
-  "patch",
-  "delete"
-];
-var HttpApiOperationSchema = Schema2.declare((value) => Schema2.is(JsonObjectSchema)(value)).annotate({ identifier: "HttpApiOperation" });
-var decodeHttpApiOperation = Schema2.decodeUnknownOption(HttpApiOperationSchema);
-var toHttpError = (message, error) => new Error(message, { cause: error });
-var sanitizeHttpName = (name) => name.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
-var httpApiToolName = (method, path, operation) => {
-  const fallback = `${method}_${path.replace(/^\/api\//, "").replace(/[/:{}]/g, "_")}`;
-  return (operation.operationId || fallback).replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").slice(0, 64);
-};
-var httpApiOperations = ({
-  spec,
-  methods = HttpApiMethods
-}) => {
-  const operations = [];
-  for (const [path, pathItem] of Object.entries(spec.paths)) {
-    for (const method of methods) {
-      const operation = decodeHttpApiOperation(pathItem[method]);
-      if (Option.isSome(operation))
-        operations.push({ method, path, operation: operation.value });
-    }
-  }
-  return operations;
-};
-var reflectedSchema2 = (schema) => Schema2.make(schema.ast);
-var reflectedOperationInputSchemas = (api) => {
-  const schemas = new Map;
-  HttpApi2.reflect(api, {
-    onGroup: () => {
-      return;
-    },
-    onEndpoint: ({ endpoint, group }) => {
-      const operationId = Context2.getOrElse(endpoint.annotations, OpenApi2.Identifier, () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`);
-      const fields = {};
-      if (endpoint.params)
-        fields.params = Schema2.toType(reflectedSchema2(endpoint.params));
-      if (endpoint.query)
-        fields.query = Schema2.optionalKey(Schema2.toType(reflectedSchema2(endpoint.query)));
-      if (endpoint.headers)
-        fields.headers = Schema2.optionalKey(Schema2.toType(reflectedSchema2(endpoint.headers)));
-      const payloads = Array.from(endpoint.payload.values()).flatMap(({ schemas: schemas2 }) => schemas2.map(reflectedSchema2));
-      if (payloads.length === 1 && payloads[0])
-        fields.body = payloads[0];
-      else if (payloads.length > 1)
-        fields.body = Schema2.Union(payloads);
-      const input = Object.keys(fields).length === 0 ? Schema2.Record(Schema2.String, Schema2.Never) : Schema2.Struct(fields);
-      schemas.set(operationId, Schema2.make(Schema2.toCodecJson(input).ast).annotate({ identifier: `${sanitizeHttpName(operationId)}ToolInput` }));
-    }
+    });
   });
-  return schemas;
-};
-var parseJsonObject = Effect2.fn("Http.parseJsonObject")(function* (value, label) {
-  if (!value)
-    return {};
-  return yield* Schema2.decodeUnknownEffect(JsonObjectFromString)(value).pipe(Effect2.mapError(() => new Error(`${label} must be a JSON object`)));
-});
-var parseJsonValue = Effect2.fn("Http.parseJsonValue")(function* (value, label) {
-  if (!value)
-    return;
-  return yield* Schema2.decodeUnknownEffect(JsonValueFromString)(value).pipe(Effect2.mapError(() => new Error(`${label} must be valid JSON`)));
-});
-
-class HttpApiSpec extends Context2.Service()("HttpApiSpec", {
-  make: (config) => Effect2.try({
-    try: () => {
-      const api = config.api;
-      if (!HttpApi2.isHttpApi(api))
-        throw new Error("HttpApiSpec requires a valid HttpApi");
-      const spec = OpenApi2.fromApi(api);
-      const schemas = reflectedOperationInputSchemas(api);
-      const names = new Set;
-      const operations = httpApiOperations({
-        spec,
-        methods: config.methods
-      }).filter((entry) => config.include?.(entry) ?? true).map((entry) => {
-        const name = httpApiToolName(entry.method, entry.path, entry.operation);
-        if (!name || names.has(name))
-          throw new Error(`Duplicate or empty HTTP API tool name: ${name}`);
-        names.add(name);
-        const inputSchema = entry.operation.operationId ? schemas.get(entry.operation.operationId) : undefined;
-        if (!inputSchema)
-          throw new Error(`Missing endpoint schema for ${entry.operation.operationId}`);
-        const document = Schema2.toJsonSchemaDocument(inputSchema.annotate({ identifier: undefined }));
-        return {
-          ...entry,
-          name,
-          inputSchema,
-          inputJsonSchema: {
-            ...document.schema,
-            $defs: document.definitions
-          },
-          readOnly: entry.method === "get",
-          destructive: entry.method === "delete",
-          idempotent: entry.method === "get" || entry.method === "put" || entry.method === "delete"
-        };
-      });
-      return { info: spec.info, operations };
-    },
-    catch: (error) => toHttpError("Failed to build HTTP API spec", error)
-  })
-}) {
-  static layer = (config) => Layer2.effect(this, this.make(config));
+  static layer = (config) => Layer.effect(this, this.make(config));
 }
 
 // ../../src/lib/httpapi-toolkit.ts
@@ -250,8 +200,8 @@ var makeOperationTool = (entry, config) => {
 
 ${guidance}` : guidance,
     parameters: entry.inputSchema,
-    success: Schema3.Json,
-    failure: Schema3.String,
+    success: Schema2.Json,
+    failure: Schema2.String,
     failureMode: "return",
     needsApproval: config.needsApproval?.(entry) ?? !readOnly
   }).annotate(Tool.Title, operation.summary ?? operation.operationId ?? entry.name).annotate(Tool.Strict, strict).annotate(Tool.Readonly, readOnly).annotate(Tool.Destructive, entry.destructive).annotate(Tool.Idempotent, entry.idempotent).annotate(Tool.OpenWorld, false).annotate(Tool.Meta, {
@@ -261,29 +211,23 @@ ${guidance}` : guidance,
     }
   });
 };
-var makeHttpApiToolkit = Effect3.fn("HttpApiToolkit.make")(function* (config) {
-  const spec = yield* HttpApiSpec;
+var makeHttpApiToolkit = Effect2.fn("HttpApiToolkit.make")(function* (config = {}) {
+  const spec = yield* HttpApiAdapter;
   const entries = spec.operations.map((operation) => ({
     operation,
     tool: makeOperationTool(operation, config)
   }));
   const toolkit = Toolkit.make(...entries.map(({ tool }) => tool));
-  const handlers = toolkit.toLayer(Effect3.map(ApiClient, (client) => Object.fromEntries(entries.map(({ operation: entry, tool }) => [
+  const handlers = toolkit.toLayer(Effect2.map(HttpApiAdapter, (client) => Object.fromEntries(entries.map(({ operation: entry, tool }) => [
     tool.name,
-    (input) => Effect3.gen(function* () {
-      const result = yield* executeHttpApiOperation({ operation: entry, input }, client);
+    (input) => Effect2.gen(function* () {
+      const result = yield* client.execute({ operation: entry, input });
       const encodedResult = yield* client.encodeResult(result, entry);
       return config.transformResult?.(entry, encodedResult) ?? encodedResult;
-    }).pipe(Effect3.mapError((error) => error instanceof Error ? error.message : String(error)))
+    }).pipe(Effect2.mapError((error) => error instanceof Error ? error.message : String(error)))
   ]))));
   return { toolkit, handlers };
 });
-var HttpApiToolkit = Effect3.fn("HttpApiToolkit")(function* (config) {
-  return (yield* makeHttpApiToolkit(config)).toolkit;
-});
-var HttpApiToolkitLayer = (config) => Layer3.unwrap(makeHttpApiToolkit(config).pipe(Effect3.map(({ handlers }) => handlers)));
 export {
-  HttpApiToolkit,
-  HttpApiToolkitLayer,
   makeHttpApiToolkit
 };

package/dist/lib/query.d.ts

@@ -29,8 +29,8 @@ export declare const SortParams: Schema.declare<readonly {
     readonly direction: "asc" | "desc";
 }[]>;
 export declare const Query: Schema.Struct<{
-    readonly page: Schema.decodeTo<Schema.Int, Schema.optionalKey<Schema.Int>, never, never>;
-    readonly pageSize: Schema.decodeTo<Schema.Int, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly page: Schema.decodeTo<Schema.Int, Schema.optional<Schema.Union<readonly [Schema.Number, Schema.NumberFromString]>>, never, never>;
+    readonly pageSize: Schema.decodeTo<Schema.Int, Schema.optional<Schema.Union<readonly [Schema.Number, Schema.NumberFromString]>>, never, never>;
     readonly globalFilter: Schema.optional<Schema.String>;
     readonly sort: Schema.optional<Schema.declare<readonly {
         readonly id: string;
@@ -42,7 +42,34 @@ export declare const Query: Schema.Struct<{
 }>;
 export type QueryType = typeof Query.Type;
 export type QueryEncoded = typeof Query.Encoded;
-export declare const QueryStandard: ReturnType<typeof Schema.toStandardSchemaV1<typeof Query>>;
+export declare const QueryStandard: import("effect/StandardSchema").StandardSchemaV1<{
+    readonly globalFilter?: string | undefined;
+    readonly sort?: readonly {
+        readonly id: string;
+        readonly direction: "asc" | "desc";
+    }[] | undefined;
+    readonly page?: string | number | undefined;
+    readonly pageSize?: string | number | undefined;
+}, {
+    readonly globalFilter?: string | undefined;
+    readonly sort?: readonly {
+        readonly id: string;
+        readonly direction: "asc" | "desc";
+    }[] | undefined;
+    readonly page?: number | undefined;
+    readonly pageSize?: number | undefined;
+}> & Schema.Struct<{
+    readonly globalFilter: Schema.optional<Schema.String>;
+    readonly sort: Schema.optional<Schema.declare<readonly {
+        readonly id: string;
+        readonly direction: "asc" | "desc";
+    }[], readonly {
+        readonly id: string;
+        readonly direction: "asc" | "desc";
+    }[]>>;
+    readonly page: Schema.decodeTo<Schema.optional<Schema.Int>, Schema.decodeTo<Schema.Int, Schema.optional<Schema.Union<readonly [Schema.Number, Schema.NumberFromString]>>, never, never>, never, never>;
+    readonly pageSize: Schema.decodeTo<Schema.optional<Schema.Int>, Schema.decodeTo<Schema.Int, Schema.optional<Schema.Union<readonly [Schema.Number, Schema.NumberFromString]>>, never, never>, never, never>;
+}>;
 export declare const PaginationMeta: Schema.Struct<{
     readonly page: Schema.Int;
     readonly pageSize: Schema.Int;

package/dist/lib/query.js

@@ -81,11 +81,11 @@ var SortParams = Schema.declare(Schema.is(SortParamsArray), {
   toCodecStringTree: () => Schema.link()(SortParamsFromString, SchemaTransformation.passthrough())
 });
 var Query = Schema.Struct({
-  page: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))).pipe(Schema.decodeTo(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)), {
+  page: Schema.optional(Schema.Union([Schema.Number, Schema.NumberFromString]).check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0))).pipe(Schema.decodeTo(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)), {
     decode: SchemaGetter.withDefault(Effect.succeed(0)),
     encode: SchemaGetter.transformOptional(Option.filter((page) => page !== 0))
   })),
-  pageSize: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 100 }))).pipe(Schema.decodeTo(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 100 })), {
+  pageSize: Schema.optional(Schema.Union([Schema.Number, Schema.NumberFromString]).check(Schema.isInt(), Schema.isBetween({ minimum: 1, maximum: 100 }))).pipe(Schema.decodeTo(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 100 })), {
     decode: SchemaGetter.withDefault(Effect.succeed(20)),
     encode: SchemaGetter.transformOptional(Option.filter((pageSize) => pageSize !== 20))
   })),
@@ -107,7 +107,17 @@ var Query = Schema.Struct({
     }
   ]
 });
-var QueryStandard = Schema.toStandardSchemaV1(Query);
+var QueryStandard = Schema.toStandardSchemaV1(Schema.Struct({
+  ...Query.fields,
+  page: Query.fields.page.pipe(Schema.decodeTo(Schema.optional(Schema.Int), {
+    decode: SchemaGetter.transform((page) => page === 0 ? undefined : page),
+    encode: SchemaGetter.transform((page) => page ?? 0)
+  })),
+  pageSize: Query.fields.pageSize.pipe(Schema.decodeTo(Schema.optional(Schema.Int), {
+    decode: SchemaGetter.transform((pageSize) => pageSize === 20 ? undefined : pageSize),
+    encode: SchemaGetter.transform((pageSize) => pageSize ?? 20)
+  }))
+}).annotate({ identifier: "QuerySearch" }));
 var PaginationMeta = Schema.Struct({
   page: Schema.Int,
   pageSize: Schema.Int,

package/dist/lib/webfetch-toolkit.d.ts

@@ -42,4 +42,4 @@ export declare const WebFetchToolkit: Toolkit.Toolkit<{
         readonly failureMode: "return";
     }, never>;
 }>;
-export declare const WebFetchToolkitLayer: (options?: Partial<WebFetchToolkitOptions>) => import("effect/Layer").Layer<Tool.Handler<"webFetch">, never, FileExtractionService | HttpClient.HttpClient>;
+export declare const WebFetchToolkitLayer: (options?: Partial<WebFetchToolkitOptions>) => import("effect/Layer").Layer<Tool.Handler<"webFetch">, Schema.SchemaError, FileExtractionService | HttpClient.HttpClient>;

package/dist/lib/webfetch-toolkit.js

@@ -127,7 +127,7 @@ var defaultWebFetchToolkitOptions = {
   maxResponseBytes: 2 * 1024 * 1024,
   maxContentCharacters: 30000
 };
-var decodeOptions = Schema2.decodeUnknownSync(WebFetchToolkitOptions);
+var decodeOptions = Schema2.decodeUnknownEffect(WebFetchToolkitOptions);
 var isPublicHttpsUrl = Schema2.makeFilter((value) => {
   try {
     const url = new URL(value);
@@ -213,60 +213,58 @@ var WebFetchTool = Tool.make("webFetch", {
   failureMode: "return"
 }).annotate(Tool.Title, "Read web page").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true).annotate(Tool.OpenWorld, true);
 var WebFetchToolkit = Toolkit.make(WebFetchTool);
-var WebFetchToolkitLayer = (options = {}) => {
-  const resolved = decodeOptions({
+var WebFetchToolkitLayer = (options = {}) => WebFetchToolkit.toLayer(Effect2.gen(function* () {
+  const resolved = yield* decodeOptions({
     ...defaultWebFetchToolkitOptions,
     ...options
   });
-  return WebFetchToolkit.toLayer(Effect2.gen(function* () {
-    const http = yield* HttpClient.HttpClient;
-    const extraction = yield* FileExtractionService;
-    return WebFetchToolkit.of({
-      webFetch: Effect2.fn("WebFetchToolkit.webFetch")(function* ({
-        url
-      }) {
-        const request = HttpClientRequest.get(url).pipe(HttpClientRequest.setHeaders({
-          accept: "text/markdown, text/plain;q=0.9, text/html;q=0.8, application/xhtml+xml;q=0.7, application/pdf;q=0.6, application/json;q=0.5",
-          "user-agent": "krak-stack-webfetch/1.0"
-        }));
-        const response = yield* HttpClient.filterStatusOk(http).execute(request).pipe(Effect2.mapError(() => failure("unavailable", "The web page could not be fetched")), Effect2.timeoutOrElse({
-          duration: "20 seconds",
-          orElse: () => Effect2.fail(failure("unavailable", "The web page request timed out"))
-        }));
-        const contentLength = response.headers["content-length"];
-        if (contentLength !== undefined) {
-          const decodedContentLength = decodeContentLength(contentLength);
-          if (Option.isNone(decodedContentLength) || decodedContentLength.value > resolved.maxResponseBytes) {
-            return yield* Effect2.fail(failure("too-large", "The web page exceeds the response size limit"));
-          }
-        }
-        const mediaType = response.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
-        const decodedMediaType = decodeMediaType(mediaType);
-        if (Option.isNone(decodedMediaType)) {
-          return yield* Effect2.fail(failure("unsupported-content", "The web page has an unsupported content type"));
-        }
-        const arrayBuffer = yield* response.arrayBuffer.pipe(Effect2.mapError(() => failure("invalid-response", "The web page body could not be read")));
-        if (arrayBuffer.byteLength > resolved.maxResponseBytes) {
+  const http = yield* HttpClient.HttpClient;
+  const extraction = yield* FileExtractionService;
+  return WebFetchToolkit.of({
+    webFetch: Effect2.fn("WebFetchToolkit.webFetch")(function* ({
+      url
+    }) {
+      const request = HttpClientRequest.get(url).pipe(HttpClientRequest.setHeaders({
+        accept: "text/markdown, text/plain;q=0.9, text/html;q=0.8, application/xhtml+xml;q=0.7, application/pdf;q=0.6, application/json;q=0.5",
+        "user-agent": "krak-stack-webfetch/1.0"
+      }));
+      const response = yield* HttpClient.filterStatusOk(http).execute(request).pipe(Effect2.mapError(() => failure("unavailable", "The web page could not be fetched")), Effect2.timeoutOrElse({
+        duration: "20 seconds",
+        orElse: () => Effect2.fail(failure("unavailable", "The web page request timed out"))
+      }));
+      const contentLength = response.headers["content-length"];
+      if (contentLength !== undefined) {
+        const decodedContentLength = decodeContentLength(contentLength);
+        if (Option.isNone(decodedContentLength) || decodedContentLength.value > resolved.maxResponseBytes) {
           return yield* Effect2.fail(failure("too-large", "The web page exceeds the response size limit"));
         }
-        const parsedUrl = new URL(url);
-        const filename = parsedUrl.pathname.split("/").at(-1) || "page.html";
-        const extracted = yield* extraction.markdown({
-          bytes: new Uint8Array(arrayBuffer),
-          filename,
-          mimeType: decodedMediaType.value
-        }).pipe(Effect2.mapError(() => failure("invalid-response", "The web page did not contain readable content")));
-        const bounded = truncateContent(extracted.content, resolved.maxContentCharacters);
-        return {
-          url,
-          contentType: decodedMediaType.value,
-          content: bounded.content,
-          truncated: extracted.truncated || bounded.truncated
-        };
-      })
-    });
-  }));
-};
+      }
+      const mediaType = response.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
+      const decodedMediaType = decodeMediaType(mediaType);
+      if (Option.isNone(decodedMediaType)) {
+        return yield* Effect2.fail(failure("unsupported-content", "The web page has an unsupported content type"));
+      }
+      const arrayBuffer = yield* response.arrayBuffer.pipe(Effect2.mapError(() => failure("invalid-response", "The web page body could not be read")));
+      if (arrayBuffer.byteLength > resolved.maxResponseBytes) {
+        return yield* Effect2.fail(failure("too-large", "The web page exceeds the response size limit"));
+      }
+      const parsedUrl = new URL(url);
+      const filename = parsedUrl.pathname.split("/").at(-1) || "page.html";
+      const extracted = yield* extraction.markdown({
+        bytes: new Uint8Array(arrayBuffer),
+        filename,
+        mimeType: decodedMediaType.value
+      }).pipe(Effect2.mapError(() => failure("invalid-response", "The web page did not contain readable content")));
+      const bounded = truncateContent(extracted.content, resolved.maxContentCharacters);
+      return {
+        url,
+        contentType: decodedMediaType.value,
+        content: bounded.content,
+        truncated: extracted.truncated || bounded.truncated
+      };
+    })
+  });
+}));
 export {
   WebFetchFailure,
   WebFetchRequest,

package/dist/oxlint/anti-slop/index.js

@@ -349,8 +349,8 @@ function classifyWideningTarget(type, environment) {
   if (alias === undefined)
     return null;
   if ((alias.typeParameters?.params.length ?? 0) > 0) {
-    const substitutions2 = aliasSubstitution(alias, unwrapped, new Map);
-    return substitutions2 !== null && resolvesToDictionary(alias.typeAnnotation, environment, substitutions2, new Set([name])) ? { kind: "generic container" } : null;
+    const substitutions = aliasSubstitution(alias, unwrapped, new Map);
+    return substitutions !== null && resolvesToDictionary(alias.typeAnnotation, environment, substitutions, new Set([name])) ? { kind: "generic container" } : null;
   }
   const substitutions = aliasSubstitution(alias, unwrapped, new Map);
   if (substitutions === null)