@unthrown/standard-schema 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Benoit Travers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# @unthrown/standard-schema
+
+> [Standard Schema](https://standardschema.dev) interop for
+> [unthrown](https://github.com/btravstack/unthrown)'s `Result`.
+
+📖 **[Documentation](https://btravstack.github.io/unthrown/guide/interop)** ·
+[API Reference](https://btravstack.github.io/unthrown/api/standard-schema/)
+
+```sh
+pnpm add @unthrown/standard-schema
+```
+
+Bridge any [Standard Schema](https://standardschema.dev) validator — **Zod**,
+**Valibot**, **ArkType**, and others — to a `Result`. A schema's validation
+issues become the modeled error `E`, because a failed validation is an
+_anticipated_ outcome, not a defect.
+
+```ts
+import { fromSchema, fromSchemaAsync } from "@unthrown/standard-schema";
+import { z } from "zod";
+
+const parseUser = fromSchema(z.object({ id: z.string() }));
+
+parseUser({ id: "u_1" }).unwrap(); // { id: "u_1" }
+parseUser({ id: 1 }).unwrapErr(); // readonly StandardSchemaV1.Issue[]
+```
+
+- `fromSchema(schema)` — returns a validator `(input) => Result<Output, Issues>`
+  for a **synchronous** schema. If the schema validates asynchronously it throws
+  a `TypeError` (use `fromSchemaAsync`).
+- `fromSchemaAsync(schema)` — returns a validator
+  `(input) => AsyncResult<Output, Issues>` that accepts **sync or async**
+  schemas. A validator that _throws_ (rather than returning issues) becomes a
+  `Defect`; the `AsyncResult` never rejects.
+
+`@standard-schema/spec` is a tiny, types-only dependency — your validator
+library (Zod, Valibot, …) provides the runtime.
+
+## License
+
+[MIT](../../LICENSE) © Benoit TRAVERS

package/dist/index.cjs

@@ -0,0 +1,69 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let unthrown = require("unthrown");
+//#region src/index.ts
+/**
+* Turn a **synchronous** Standard Schema into a validator returning a
+* `Result`.
+*
+* @remarks
+* Validation issues are the modeled error `E` — `Result<Output, SchemaIssues>` —
+* because a failed validation is an *anticipated* outcome, not a Defect. Works
+* with any Standard Schema implementation (Zod, Valibot, ArkType, …).
+*
+* A validator that **throws** (rather than returning issues) becomes a `Defect`
+* — the same boundary behaviour as `fromThrowable`, so an unexpected crash never
+* escapes as a raw exception. If the schema validates **asynchronously**
+* (its `validate` returns a `Promise`), a synchronous `Result` cannot represent
+* the pending work, so this throws a `TypeError` — a deliberate usage error; use
+* {@link fromSchemaAsync} instead.
+*
+* @typeParam S - the schema type.
+* @param schema - a Standard Schema validator.
+* @returns a function mapping an input to `Result<Output, SchemaIssues>`.
+*
+* @example
+* ```ts
+* import { fromSchema } from "@unthrown/standard-schema";
+* const parse = fromSchema(z.string());
+* parse("hi").unwrap(); // "hi"
+* parse(42).unwrapErr(); // the issues array
+* ```
+*/
+function fromSchema(schema) {
+	const validate = (0, unthrown.fromThrowable)((input) => schema["~standard"].validate(input), (cause) => (0, unthrown.Defect)(cause));
+	return (input) => {
+		const settled = validate(input);
+		if (settled.isOk() && settled.value instanceof Promise) throw new TypeError("@unthrown/standard-schema: this schema validates asynchronously — use fromSchemaAsync instead.");
+		return settled.flatMap((result) => {
+			const sync = result;
+			return sync.issues ? (0, unthrown.Err)(sync.issues) : (0, unthrown.Ok)(sync.value);
+		});
+	};
+}
+/**
+* Turn a Standard Schema (sync **or** async) into a validator returning an
+* `AsyncResult`.
+*
+* @remarks
+* The async counterpart of {@link fromSchema}: it awaits the schema's
+* `validate`, so it accepts both synchronous and asynchronous schemas. As with
+* every `AsyncResult`, the returned value never rejects — a validator that
+* *throws* (rather than returning issues) becomes a `Defect`.
+*
+* @typeParam S - the schema type.
+* @param schema - a Standard Schema validator.
+* @returns a function mapping an input to `AsyncResult<Output, SchemaIssues>`.
+*
+* @example
+* ```ts
+* import { fromSchemaAsync } from "@unthrown/standard-schema";
+* const parse = fromSchemaAsync(asyncSchema);
+* (await parse(input)).match({ ok, err, defect });
+* ```
+*/
+function fromSchemaAsync(schema) {
+	return (input) => (0, unthrown.fromSafePromise)(async () => schema["~standard"].validate(input)).flatMap((result) => result.issues ? (0, unthrown.Err)(result.issues) : (0, unthrown.Ok)(result.value));
+}
+//#endregion
+exports.fromSchema = fromSchema;
+exports.fromSchemaAsync = fromSchemaAsync;

package/dist/index.d.cts

@@ -0,0 +1,60 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { AsyncResult, Result } from "unthrown";
+
+//#region src/index.d.ts
+/** The error channel both entry points produce: a schema's validation issues. */
+type SchemaIssues = readonly StandardSchemaV1.Issue[];
+/**
+ * Turn a **synchronous** Standard Schema into a validator returning a
+ * `Result`.
+ *
+ * @remarks
+ * Validation issues are the modeled error `E` — `Result<Output, SchemaIssues>` —
+ * because a failed validation is an *anticipated* outcome, not a Defect. Works
+ * with any Standard Schema implementation (Zod, Valibot, ArkType, …).
+ *
+ * A validator that **throws** (rather than returning issues) becomes a `Defect`
+ * — the same boundary behaviour as `fromThrowable`, so an unexpected crash never
+ * escapes as a raw exception. If the schema validates **asynchronously**
+ * (its `validate` returns a `Promise`), a synchronous `Result` cannot represent
+ * the pending work, so this throws a `TypeError` — a deliberate usage error; use
+ * {@link fromSchemaAsync} instead.
+ *
+ * @typeParam S - the schema type.
+ * @param schema - a Standard Schema validator.
+ * @returns a function mapping an input to `Result<Output, SchemaIssues>`.
+ *
+ * @example
+ * ```ts
+ * import { fromSchema } from "@unthrown/standard-schema";
+ * const parse = fromSchema(z.string());
+ * parse("hi").unwrap(); // "hi"
+ * parse(42).unwrapErr(); // the issues array
+ * ```
+ */
+declare function fromSchema<S extends StandardSchemaV1>(schema: S): (input: unknown) => Result<StandardSchemaV1.InferOutput<S>, SchemaIssues>;
+/**
+ * Turn a Standard Schema (sync **or** async) into a validator returning an
+ * `AsyncResult`.
+ *
+ * @remarks
+ * The async counterpart of {@link fromSchema}: it awaits the schema's
+ * `validate`, so it accepts both synchronous and asynchronous schemas. As with
+ * every `AsyncResult`, the returned value never rejects — a validator that
+ * *throws* (rather than returning issues) becomes a `Defect`.
+ *
+ * @typeParam S - the schema type.
+ * @param schema - a Standard Schema validator.
+ * @returns a function mapping an input to `AsyncResult<Output, SchemaIssues>`.
+ *
+ * @example
+ * ```ts
+ * import { fromSchemaAsync } from "@unthrown/standard-schema";
+ * const parse = fromSchemaAsync(asyncSchema);
+ * (await parse(input)).match({ ok, err, defect });
+ * ```
+ */
+declare function fromSchemaAsync<S extends StandardSchemaV1>(schema: S): (input: unknown) => AsyncResult<StandardSchemaV1.InferOutput<S>, SchemaIssues>;
+//#endregion
+export { SchemaIssues, fromSchema, fromSchemaAsync };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;KAoBY,YAAA,YAAwB,gBAAA,CAAiB,KAAK;AAA1D;;;;AAA0D;AA8B1D;;;;;;;;;;;;;;;;;;;;;;AAE2E;AAhC3E,iBA8BgB,UAAA,WAAqB,gBAAA,EACnC,MAAA,EAAQ,CAAA,IACN,KAAA,cAAmB,MAAA,CAAO,gBAAA,CAAiB,WAAA,CAAY,CAAA,GAAI,YAAA;;;;;;;;;;;;;;;;;;;;;;iBA4C/C,eAAA,WAA0B,gBAAA,EACxC,MAAA,EAAQ,CAAA,IACN,KAAA,cAAmB,WAAA,CAAY,gBAAA,CAAiB,WAAA,CAAY,CAAA,GAAI,YAAA"}

package/dist/index.d.mts

@@ -0,0 +1,60 @@
+import { AsyncResult, Result } from "unthrown";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/index.d.ts
+/** The error channel both entry points produce: a schema's validation issues. */
+type SchemaIssues = readonly StandardSchemaV1.Issue[];
+/**
+ * Turn a **synchronous** Standard Schema into a validator returning a
+ * `Result`.
+ *
+ * @remarks
+ * Validation issues are the modeled error `E` — `Result<Output, SchemaIssues>` —
+ * because a failed validation is an *anticipated* outcome, not a Defect. Works
+ * with any Standard Schema implementation (Zod, Valibot, ArkType, …).
+ *
+ * A validator that **throws** (rather than returning issues) becomes a `Defect`
+ * — the same boundary behaviour as `fromThrowable`, so an unexpected crash never
+ * escapes as a raw exception. If the schema validates **asynchronously**
+ * (its `validate` returns a `Promise`), a synchronous `Result` cannot represent
+ * the pending work, so this throws a `TypeError` — a deliberate usage error; use
+ * {@link fromSchemaAsync} instead.
+ *
+ * @typeParam S - the schema type.
+ * @param schema - a Standard Schema validator.
+ * @returns a function mapping an input to `Result<Output, SchemaIssues>`.
+ *
+ * @example
+ * ```ts
+ * import { fromSchema } from "@unthrown/standard-schema";
+ * const parse = fromSchema(z.string());
+ * parse("hi").unwrap(); // "hi"
+ * parse(42).unwrapErr(); // the issues array
+ * ```
+ */
+declare function fromSchema<S extends StandardSchemaV1>(schema: S): (input: unknown) => Result<StandardSchemaV1.InferOutput<S>, SchemaIssues>;
+/**
+ * Turn a Standard Schema (sync **or** async) into a validator returning an
+ * `AsyncResult`.
+ *
+ * @remarks
+ * The async counterpart of {@link fromSchema}: it awaits the schema's
+ * `validate`, so it accepts both synchronous and asynchronous schemas. As with
+ * every `AsyncResult`, the returned value never rejects — a validator that
+ * *throws* (rather than returning issues) becomes a `Defect`.
+ *
+ * @typeParam S - the schema type.
+ * @param schema - a Standard Schema validator.
+ * @returns a function mapping an input to `AsyncResult<Output, SchemaIssues>`.
+ *
+ * @example
+ * ```ts
+ * import { fromSchemaAsync } from "@unthrown/standard-schema";
+ * const parse = fromSchemaAsync(asyncSchema);
+ * (await parse(input)).match({ ok, err, defect });
+ * ```
+ */
+declare function fromSchemaAsync<S extends StandardSchemaV1>(schema: S): (input: unknown) => AsyncResult<StandardSchemaV1.InferOutput<S>, SchemaIssues>;
+//#endregion
+export { SchemaIssues, fromSchema, fromSchemaAsync };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;KAoBY,YAAA,YAAwB,gBAAA,CAAiB,KAAK;AAA1D;;;;AAA0D;AA8B1D;;;;;;;;;;;;;;;;;;;;;;AAE2E;AAhC3E,iBA8BgB,UAAA,WAAqB,gBAAA,EACnC,MAAA,EAAQ,CAAA,IACN,KAAA,cAAmB,MAAA,CAAO,gBAAA,CAAiB,WAAA,CAAY,CAAA,GAAI,YAAA;;;;;;;;;;;;;;;;;;;;;;iBA4C/C,eAAA,WAA0B,gBAAA,EACxC,MAAA,EAAQ,CAAA,IACN,KAAA,cAAmB,WAAA,CAAY,gBAAA,CAAiB,WAAA,CAAY,CAAA,GAAI,YAAA"}

package/dist/index.mjs

@@ -0,0 +1,69 @@
+import { Defect, Err, Ok, fromSafePromise, fromThrowable } from "unthrown";
+//#region src/index.ts
+/**
+* Turn a **synchronous** Standard Schema into a validator returning a
+* `Result`.
+*
+* @remarks
+* Validation issues are the modeled error `E` — `Result<Output, SchemaIssues>` —
+* because a failed validation is an *anticipated* outcome, not a Defect. Works
+* with any Standard Schema implementation (Zod, Valibot, ArkType, …).
+*
+* A validator that **throws** (rather than returning issues) becomes a `Defect`
+* — the same boundary behaviour as `fromThrowable`, so an unexpected crash never
+* escapes as a raw exception. If the schema validates **asynchronously**
+* (its `validate` returns a `Promise`), a synchronous `Result` cannot represent
+* the pending work, so this throws a `TypeError` — a deliberate usage error; use
+* {@link fromSchemaAsync} instead.
+*
+* @typeParam S - the schema type.
+* @param schema - a Standard Schema validator.
+* @returns a function mapping an input to `Result<Output, SchemaIssues>`.
+*
+* @example
+* ```ts
+* import { fromSchema } from "@unthrown/standard-schema";
+* const parse = fromSchema(z.string());
+* parse("hi").unwrap(); // "hi"
+* parse(42).unwrapErr(); // the issues array
+* ```
+*/
+function fromSchema(schema) {
+	const validate = fromThrowable((input) => schema["~standard"].validate(input), (cause) => Defect(cause));
+	return (input) => {
+		const settled = validate(input);
+		if (settled.isOk() && settled.value instanceof Promise) throw new TypeError("@unthrown/standard-schema: this schema validates asynchronously — use fromSchemaAsync instead.");
+		return settled.flatMap((result) => {
+			const sync = result;
+			return sync.issues ? Err(sync.issues) : Ok(sync.value);
+		});
+	};
+}
+/**
+* Turn a Standard Schema (sync **or** async) into a validator returning an
+* `AsyncResult`.
+*
+* @remarks
+* The async counterpart of {@link fromSchema}: it awaits the schema's
+* `validate`, so it accepts both synchronous and asynchronous schemas. As with
+* every `AsyncResult`, the returned value never rejects — a validator that
+* *throws* (rather than returning issues) becomes a `Defect`.
+*
+* @typeParam S - the schema type.
+* @param schema - a Standard Schema validator.
+* @returns a function mapping an input to `AsyncResult<Output, SchemaIssues>`.
+*
+* @example
+* ```ts
+* import { fromSchemaAsync } from "@unthrown/standard-schema";
+* const parse = fromSchemaAsync(asyncSchema);
+* (await parse(input)).match({ ok, err, defect });
+* ```
+*/
+function fromSchemaAsync(schema) {
+	return (input) => fromSafePromise(async () => schema["~standard"].validate(input)).flatMap((result) => result.issues ? Err(result.issues) : Ok(result.value));
+}
+//#endregion
+export { fromSchema, fromSchemaAsync };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["// @unthrown/standard-schema — bridge any Standard Schema validator (Zod,\n// Valibot, ArkType, …) to a `Result` / `AsyncResult`.\n//\n// A Standard Schema's `validate` returns `{ value }` on success or `{ issues }`\n// on failure. `fromSchema` turns that into a validator returning\n// `Result<Output, readonly Issue[]>`; `fromSchemaAsync` is the async counterpart\n// (and also accepts synchronous schemas). The `issues` array is the modeled `E`\n// — a failed validation is an anticipated outcome, never a Defect.\n//\n//   import { fromSchema } from \"@unthrown/standard-schema\";\n//   import { z } from \"zod\";\n//\n//   const parseUser = fromSchema(z.object({ id: z.string() }));\n//   parseUser(input); // Result<{ id: string }, readonly StandardSchemaV1.Issue[]>\n\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { Defect, Err, fromSafePromise, fromThrowable, Ok } from \"unthrown\";\nimport type { AsyncResult, Result } from \"unthrown\";\n\n/** The error channel both entry points produce: a schema's validation issues. */\nexport type SchemaIssues = readonly StandardSchemaV1.Issue[];\n\n/**\n * Turn a **synchronous** Standard Schema into a validator returning a\n * `Result`.\n *\n * @remarks\n * Validation issues are the modeled error `E` — `Result<Output, SchemaIssues>` —\n * because a failed validation is an *anticipated* outcome, not a Defect. Works\n * with any Standard Schema implementation (Zod, Valibot, ArkType, …).\n *\n * A validator that **throws** (rather than returning issues) becomes a `Defect`\n * — the same boundary behaviour as `fromThrowable`, so an unexpected crash never\n * escapes as a raw exception. If the schema validates **asynchronously**\n * (its `validate` returns a `Promise`), a synchronous `Result` cannot represent\n * the pending work, so this throws a `TypeError` — a deliberate usage error; use\n * {@link fromSchemaAsync} instead.\n *\n * @typeParam S - the schema type.\n * @param schema - a Standard Schema validator.\n * @returns a function mapping an input to `Result<Output, SchemaIssues>`.\n *\n * @example\n * ```ts\n * import { fromSchema } from \"@unthrown/standard-schema\";\n * const parse = fromSchema(z.string());\n * parse(\"hi\").unwrap(); // \"hi\"\n * parse(42).unwrapErr(); // the issues array\n * ```\n */\nexport function fromSchema<S extends StandardSchemaV1>(\n  schema: S,\n): (input: unknown) => Result<StandardSchemaV1.InferOutput<S>, SchemaIssues> {\n  type Output = StandardSchemaV1.InferOutput<S>;\n  // Run `validate` at a boundary so a *throwing* validator lands in the Defect\n  // channel instead of escaping; `qualify` only ever mints a Defect, so E = never.\n  const validate = fromThrowable(\n    (input: unknown) => schema[\"~standard\"].validate(input),\n    (cause) => Defect(cause),\n  );\n  return (input) => {\n    const settled = validate(input);\n    // An async schema can't be represented synchronously — fail loud and early.\n    if (settled.isOk() && settled.value instanceof Promise) {\n      throw new TypeError(\n        \"@unthrown/standard-schema: this schema validates asynchronously — use fromSchemaAsync instead.\",\n      );\n    }\n    return settled.flatMap((result) => {\n      const sync = result as StandardSchemaV1.Result<Output>;\n      return sync.issues ? Err(sync.issues) : Ok(sync.value);\n    });\n  };\n}\n\n/**\n * Turn a Standard Schema (sync **or** async) into a validator returning an\n * `AsyncResult`.\n *\n * @remarks\n * The async counterpart of {@link fromSchema}: it awaits the schema's\n * `validate`, so it accepts both synchronous and asynchronous schemas. As with\n * every `AsyncResult`, the returned value never rejects — a validator that\n * *throws* (rather than returning issues) becomes a `Defect`.\n *\n * @typeParam S - the schema type.\n * @param schema - a Standard Schema validator.\n * @returns a function mapping an input to `AsyncResult<Output, SchemaIssues>`.\n *\n * @example\n * ```ts\n * import { fromSchemaAsync } from \"@unthrown/standard-schema\";\n * const parse = fromSchemaAsync(asyncSchema);\n * (await parse(input)).match({ ok, err, defect });\n * ```\n */\nexport function fromSchemaAsync<S extends StandardSchemaV1>(\n  schema: S,\n): (input: unknown) => AsyncResult<StandardSchemaV1.InferOutput<S>, SchemaIssues> {\n  return (input) =>\n    fromSafePromise(async () => schema[\"~standard\"].validate(input)).flatMap((result) =>\n      result.issues ? Err(result.issues) : Ok(result.value),\n    );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,WACd,QAC2E;CAI3E,MAAM,WAAW,eACd,UAAmB,OAAO,YAAY,CAAC,SAAS,KAAK,IACrD,UAAU,OAAO,KAAK,CACzB;CACA,QAAQ,UAAU;EAChB,MAAM,UAAU,SAAS,KAAK;EAE9B,IAAI,QAAQ,KAAK,KAAK,QAAQ,iBAAiB,SAC7C,MAAM,IAAI,UACR,gGACF;EAEF,OAAO,QAAQ,SAAS,WAAW;GACjC,MAAM,OAAO;GACb,OAAO,KAAK,SAAS,IAAI,KAAK,MAAM,IAAI,GAAG,KAAK,KAAK;EACvD,CAAC;CACH;AACF;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,gBACd,QACgF;CAChF,QAAQ,UACN,gBAAgB,YAAY,OAAO,YAAY,CAAC,SAAS,KAAK,CAAC,CAAC,CAAC,SAAS,WACxE,OAAO,SAAS,IAAI,OAAO,MAAM,IAAI,GAAG,OAAO,KAAK,CACtD;AACJ"}

package/docs/index.md

@@ -0,0 +1,116 @@
+**@unthrown/standard-schema**
+
+***
+
+# @unthrown/standard-schema
+
+## Type Aliases
+
+### SchemaIssues
+
+```ts
+type SchemaIssues = readonly StandardSchemaV1.Issue[];
+```
+
+Defined in: [index.ts:21](https://github.com/btravstack/unthrown/blob/fa4c17ddc81bb2075e8f48dfcc49e5e04d951dd1/packages/standard-schema/src/index.ts#L21)
+
+The error channel both entry points produce: a schema's validation issues.
+
+## Functions
+
+### fromSchema()
+
+```ts
+function fromSchema<S>(schema): (input) => Result<InferOutput<S>, SchemaIssues>;
+```
+
+Defined in: [index.ts:51](https://github.com/btravstack/unthrown/blob/fa4c17ddc81bb2075e8f48dfcc49e5e04d951dd1/packages/standard-schema/src/index.ts#L51)
+
+Turn a **synchronous** Standard Schema into a validator returning a
+`Result`.
+
+#### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `S` *extends* `StandardSchemaV1`&lt;`unknown`, `unknown`&gt; | the schema type. |
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `schema` | `S` | a Standard Schema validator. |
+
+#### Returns
+
+a function mapping an input to `Result<Output, SchemaIssues>`.
+
+(`input`) => `Result`&lt;`InferOutput`&lt;`S`&gt;, [`SchemaIssues`](#schemaissues)&gt;
+
+#### Remarks
+
+Validation issues are the modeled error `E` — `Result<Output, SchemaIssues>` —
+because a failed validation is an *anticipated* outcome, not a Defect. Works
+with any Standard Schema implementation (Zod, Valibot, ArkType, …).
+
+A validator that **throws** (rather than returning issues) becomes a `Defect`
+— the same boundary behaviour as `fromThrowable`, so an unexpected crash never
+escapes as a raw exception. If the schema validates **asynchronously**
+(its `validate` returns a `Promise`), a synchronous `Result` cannot represent
+the pending work, so this throws a `TypeError` — a deliberate usage error; use
+[fromSchemaAsync](#fromschemaasync) instead.
+
+#### Example
+
+```ts
+import { fromSchema } from "@unthrown/standard-schema";
+const parse = fromSchema(z.string());
+parse("hi").unwrap(); // "hi"
+parse(42).unwrapErr(); // the issues array
+```
+
+***
+
+### fromSchemaAsync()
+
+```ts
+function fromSchemaAsync<S>(schema): (input) => AsyncResult<InferOutput<S>, SchemaIssues>;
+```
+
+Defined in: [index.ts:97](https://github.com/btravstack/unthrown/blob/fa4c17ddc81bb2075e8f48dfcc49e5e04d951dd1/packages/standard-schema/src/index.ts#L97)
+
+Turn a Standard Schema (sync **or** async) into a validator returning an
+`AsyncResult`.
+
+#### Type Parameters
+
+| Type Parameter | Description |
+| ------ | ------ |
+| `S` *extends* `StandardSchemaV1`&lt;`unknown`, `unknown`&gt; | the schema type. |
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `schema` | `S` | a Standard Schema validator. |
+
+#### Returns
+
+a function mapping an input to `AsyncResult<Output, SchemaIssues>`.
+
+(`input`) => `AsyncResult`&lt;`InferOutput`&lt;`S`&gt;, [`SchemaIssues`](#schemaissues)&gt;
+
+#### Remarks
+
+The async counterpart of [fromSchema](#fromschema): it awaits the schema's
+`validate`, so it accepts both synchronous and asynchronous schemas. As with
+every `AsyncResult`, the returned value never rejects — a validator that
+*throws* (rather than returning issues) becomes a `Defect`.
+
+#### Example
+
+```ts
+import { fromSchemaAsync } from "@unthrown/standard-schema";
+const parse = fromSchemaAsync(asyncSchema);
+(await parse(input)).match({ ok, err, defect });
+```

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@unthrown/standard-schema",
+  "version": "0.2.1",
+  "description": "Standard Schema (Zod, Valibot, ArkType, …) interop for unthrown",
+  "keywords": [
+    "arktype",
+    "errors-as-values",
+    "result",
+    "standard-schema",
+    "typescript",
+    "unthrown",
+    "valibot",
+    "validation",
+    "zod"
+  ],
+  "homepage": "https://github.com/btravstack/unthrown#readme",
+  "bugs": {
+    "url": "https://github.com/btravstack/unthrown/issues"
+  },
+  "license": "MIT",
+  "author": "Benoit TRAVERS <benoit.travers.fr@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/btravstack/unthrown.git",
+    "directory": "packages/standard-schema"
+  },
+  "files": [
+    "dist",
+    "docs"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "1.1.0",
+    "unthrown": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.13.2",
+    "@vitest/coverage-v8": "4.1.8",
+    "tsdown": "0.22.2",
+    "typedoc": "0.28.19",
+    "typedoc-plugin-markdown": "4.12.0",
+    "typescript": "6.0.3",
+    "vitest": "4.1.8",
+    "@unthrown/tsconfig": "0.1.0",
+    "@unthrown/typedoc": "0.1.0"
+  },
+  "engines": {
+    "node": ">=22.19"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --format cjs,esm --dts --clean",
+    "build:docs": "typedoc",
+    "dev": "tsdown src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}