typesea 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## 0.1.0
+
+- Added the initial zero-dependency TypeSea runtime narrowing API.
+- Added interpreted, compiled, and AOT validation paths with parity coverage.
+- Added Sea-of-Nodes graph introspection and optimizer validation.
+- Added JSON Schema export, tRPC, Fastify, and React Hook Form adapters.
+- Added release gates, package surface checks, and benchmark smoke coverage.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Feralthedogg
+
+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,320 @@
+# TypeSea
+
+[![CI](https://github.com/Feralthedogg/TypeSea/actions/workflows/ci.yml/badge.svg)](https://github.com/Feralthedogg/TypeSea/actions/workflows/ci.yml)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+![TypeScript](https://img.shields.io/badge/language-TypeScript-informational)
+![Dependencies](https://img.shields.io/badge/runtime%20deps-zero-brightgreen)
+![Module](https://img.shields.io/badge/module-ESM--only-orange)
+![Node](https://img.shields.io/badge/node-%3E%3D20.19-yellowgreen)
+
+**TypeSea** is a **zero-runtime-dependency TypeScript runtime narrowing library**
+built around **immutable guards**, optimized **Sea-of-Nodes validation plans**,
+runtime compilation, and AOT source generation.
+
+> Goal: not "probably valid", but **provably parity-tested validation** that
+> never executes user code, never throws on expected failures, and never leaks
+> mutable state across a public boundary.
+
+> [!IMPORTANT]
+> TypeSea is designed for **hostile boundary data**: property reads go through
+> descriptors so **user getters never execute**, `__proto__`/`constructor` keys
+> are handled with null-prototype lookups, user regexes are cloned and
+> `lastIndex`-reset, and cyclic inputs validate finitely. Expected failures
+> return frozen `Result` values — `any`, `try`, and `catch` are banned from the
+> entire codebase and enforced by policy gates.
+
+---
+
+## Why
+
+Many validation libraries fall short when you care about:
+
+- **untrusted input that fights back** (getters with side effects, prototype
+  pollution keys, forged schema objects, revoked proxies)
+- **identical verdicts across execution strategies** (runtime plan vs compiled
+  vs AOT-generated validators)
+- **diagnostics without exceptions** (`Result` values instead of `throw`)
+- **immutability at every public boundary**
+
+TypeSea focuses on:
+
+- **no user-code execution during validation**
+- **runtime plan / compiled / AOT parity, enforced by a seeded generative fuzzer**
+- **injection-safe code generation** (side tables, never string interpolation)
+- **explicit presence semantics** (`optional` vs `undefinedable`)
+
+---
+
+## Key Properties
+
+- **Zero dependencies**: no runtime, peer, optional, or bundled dependencies —
+  mechanically enforced by package policy before every release.
+- **Three engines, one semantics**: `is()`/`check()` execute a cached validation
+  plan, `compile()` emits runtime predicates from optimized IR, and
+  `emitAotModule()` emits standalone validator source. The runtime plan owns
+  both the graph and a schema-specialized kernel, so the graph is the source of
+  truth for generated validators without forcing ordinary `is()` through a
+  per-node interpreter. Parity is fuzz-tested with sparse arrays, accessor
+  properties, symbol keys, and non-enumerable extras included.
+- **Frozen public surface**: guards, schemas, graphs, diagnostics, and JSON
+  Schema payloads are frozen before they cross an API boundary.
+- **Lossless-only export**: JSON Schema and AOT export succeed only when no
+  semantics would be lost; runtime-only contracts return typed issues instead
+  of silently weakening the schema.
+
+> [!NOTE]
+> TypeSea is **ESM-only**: the package ships `"type": "module"` with no
+> CommonJS build. Node.js `>= 20.19` can also load it via `require(esm)`
+> through the `default` export condition.
+
+---
+
+## Quick Start
+
+```ts
+import { compile, t, toJsonSchema, type Infer } from "typesea";
+
+const User = t.strictObject({
+  id: t.string.uuid(),
+  age: t.number.int().gte(0),
+  role: t.union(t.literal("admin"), t.literal("user"))
+});
+
+type User = Infer<typeof User>;
+
+// 1) Boolean narrowing — avoids diagnostic allocation on success
+if (User.is(input)) {
+  input.id; // narrowed
+}
+
+// 2) Immutable diagnostics — frozen Result, never throws on expected failure
+const checked = User.check(input);
+if (!checked.ok) {
+  console.log(checked.error); // frozen issue list with paths
+}
+
+// 3) Hot path — generated validator code
+const FastUser = compile(User, { name: "isUser" });
+
+// 4) Interop — lossless-only JSON Schema export
+const schema = toJsonSchema(User);
+```
+
+Use `is()` for the allocation-light boolean path. Use `check()` when callers
+need immutable diagnostics. Use `compile()` or `emitAotModule()` when a stable
+schema is hot enough to deserve generated validator code.
+
+> [!CAUTION]
+> `compile()` builds the validator with `new Function`, which throws under a
+> Content-Security-Policy that forbids `unsafe-eval`. In CSP-restricted
+> environments, generate validator source ahead of time with
+> `emitAotModule()` instead.
+
+---
+
+## Presence Semantics
+
+Object presence is explicit — two different wrappers express two different
+contracts:
+
+| Wrapper | Key may be absent | Value may be `undefined` | Inferred type |
+| --- | --- | --- | --- |
+| `t.optional(inner)` | yes | no | `key?: T` |
+| `t.undefinedable(inner)` | no | yes | `key: T \| undefined` |
+| `t.nullable(inner)` | — | value may be `null` | `key: T \| null` |
+
+> [!NOTE]
+> Presence survives wrapper composition: `t.nullable(t.optional(x))` still
+> means "the key may be absent" — inference and runtime agree on this under
+> `exactOptionalPropertyTypes`.
+
+---
+
+## Execution Model
+
+TypeSea keeps the public schema tree for builder validation and diagnostics,
+then lowers each schema identity into a cached validation plan. The plan owns an
+optimized Sea-of-Nodes graph and a schema-specialized predicate kernel.
+`Guard.is()` uses the kernel to avoid per-node interpreter dispatch, while
+`compile()` and `emitAotModule()` emit predicates from the optimized graph.
+`check()` first asks the same plan for the verdict; failed values then replay
+the schema-aware diagnostic collector to produce issue paths and codes.
+
+```text
+builder -> frozen schema -> lower -> Sea-of-Nodes IR -> optimize
+optimize -> ValidationPlan { graph, schema kernel }
+schema kernel -> Guard.is() / check() preflight
+graph -> compile() predicate / emitAotModule() predicate / Guard.graph()
+failed check() -> schema-aware diagnostic collector
+```
+
+> [!IMPORTANT]
+> Generated validators keep **user-controlled values out of source text**:
+> literals, regexps, object keys, keysets, and dynamic schema fallbacks live in
+> **side tables** referenced by numeric index. Hostile property names cannot
+> escape into generated code — this is pinned by dedicated injection-audit
+> tests.
+
+---
+
+## Performance Snapshot
+
+Last local release smoke on 2026-07-04 KST, using
+`npm run release:check` on the benchmark strict-object contract. These are
+operations per second on one machine, not release guarantees.
+
+| Valid object path | hz |
+| --- | ---: |
+| TypeSea interpreted `is()` | 496,270 |
+| TypeSea compiled `is()` | 4,237,892 |
+| Zod `safeParse` | 1,363,792 |
+| Valibot `safeParse` | 1,384,892 |
+| Ajv compiled | 4,312,174 |
+
+| Invalid object path | hz |
+| --- | ---: |
+| TypeSea interpreted `is()` | 3,422,416 |
+| TypeSea compiled `is()` | 27,125,445 |
+| Zod `safeParse` | 83,501 |
+| Valibot `safeParse` | 902,616 |
+| Ajv compiled | 28,953,501 |
+
+The compiled path stays close to Ajv while retaining TypeSea semantics:
+descriptor-based property reads, symbol/non-enumerable strict-key rejection,
+presence semantics, immutable diagnostics, and TypeScript guard inference.
+
+---
+
+## API Reference
+
+All public entry points are exported from the package root; builders are also
+grouped under the `t` table.
+
+### Builders
+
+| Area | Entry points |
+| --- | --- |
+| Scalar guards | `t.unknown`, `t.never`, `t.string`, `t.number`, `t.bigint`, `t.symbol`, `t.boolean` |
+| Literal and containers | `t.literal`, `t.array`, `t.tuple`, `t.record` |
+| Objects | `t.object`, `t.strictObject`, `extend`, `pick`, `omit`, `partial` |
+| Composition | `t.union`, `t.discriminatedUnion`, `t.intersect`, `guard.intersect` |
+| Presence wrappers | `t.optional`, `t.undefinedable`, `t.nullable` |
+| Dynamic contracts | `t.lazy`, `t.refine` |
+
+### Decoders
+
+| Area | Entry points |
+| --- | --- |
+| Sync decoders | `t.decoder`, `t.transform`, `t.pipe`, `t.coerce` |
+| Async decoders | `t.asyncDecoder`, `t.asyncRefine`, `t.asyncTransform`, `t.asyncPipe` |
+
+### Execution & Export
+
+| Area | Entry points |
+| --- | --- |
+| Guard methods | `guard.is()`, `guard.check()`, `guard.graph()` |
+| Generated validators | `compile`, `emitAotModule` |
+| JSON Schema | `toJsonSchema` |
+
+### Messages & Adapters
+
+| Area | Entry points |
+| --- | --- |
+| Messages / i18n | `formatIssue`, `formatIssues`, `withMessages`, `defineMessages` |
+| tRPC | `toTrpcParser`, `toAsyncTrpcParser` |
+| Fastify | `toFastifyRouteSchema`, `toFastifyValidatorCompiler` |
+| React Hook Form | `toReactHookFormResolver` |
+
+> [!TIP]
+> Match the inference alias to the source kind: `Infer<>` for guards,
+> `InferDecoder<>` for decoders, `InferAsyncDecoder<>` for async decoders.
+> Applying `Infer<>` to a decoder resolves to `never` — if a downstream type
+> suddenly collapses, this is the first thing to check.
+
+---
+
+## Edge Semantics
+
+Deliberate, documented, and pinned by tests:
+
+| Input | Behavior |
+| --- | --- |
+| `NaN`, `Infinity` | rejected by `t.number` (finite numbers only); `t.literal(NaN)` matches `NaN` |
+| `-0` vs `0` | literals match via `Object.is`; diagnostics format `-0` distinctly |
+| Getter-backed properties | never executed; treated as missing/invalid data |
+| `__proto__`, `constructor` keys | validated as plain own keys, no pollution |
+| Sparse array holes | read as `undefined` without executing accessors |
+| Strict object extras | rejected via `Reflect.ownKeys` — including symbol keys and non-enumerable properties |
+| Global-flag regexes | cloned at construction; `lastIndex` reset before every test |
+| UUID | accepts RFC 9562 versions 1–8 plus the nil UUID |
+| Cyclic input values | validate finitely via (value × schema) active-pair tracking |
+| Nesting depth | capped at 256 recursive frames; deeper input fails instead of overflowing the stack |
+
+---
+
+## Best Practices & Pitfalls
+
+> [!WARNING]
+> **Recursive guards need an explicit type annotation.** TypeScript cannot
+> infer a self-referential initializer (TS7022):
+>
+> ```ts
+> interface ListNode {
+>   readonly value: string;
+>   readonly next?: ListNode;
+> }
+>
+> const Node: Guard<ListNode> = t.lazy((): Guard<ListNode> =>
+>   t.object({ value: t.string, next: t.optional(Node) })
+> );
+> ```
+
+- **Boundary data enters as `unknown`.** Do not pre-narrow with `as` — the
+  builder API is typed so that narrowing happens through validation.
+- **Recursive contracts go through `t.lazy`.** Direct schema object cycles are
+  rejected at construction.
+- **Choose the engine by schema lifetime.** One-off schemas: runtime plan.
+  Stable hot schemas: `compile()`. CSP environments or build-time generation:
+  `emitAotModule()`.
+- **Decoders do not embed in object shapes.** Compose transformations with
+  `t.pipe` around a validated shape instead of mixing decoders into `t.object`
+  entries.
+
+---
+
+## Verification
+
+Every gate that CI runs is a local npm script:
+
+```sh
+npm run check           # policy, docs, typecheck, lint, tests, build, dist, API snapshot, pack
+npm run check:consumer  # tarball install + runtime/type smoke in a temp project
+npm run bench -- --run  # benchmark smoke
+npm run pack:dry        # package contents dry run
+npm run release:check   # the full pre-publish gate (everything above)
+```
+
+`npm run release:check` runs the same gate expected before publishing:
+typecheck, lint, tests, build, docs smoke, dist policy, public API snapshot,
+package contents, consumer install, benchmark smoke, and pack dry run.
+CI executes it on Node 20.19, 22, and 24; releases publish with npm provenance.
+
+> [!NOTE]
+> Benchmark comparison packages (Zod, Valibot, Ajv) are dev dependencies only —
+> package policy rejects them from every runtime dependency field. The
+> benchmark suite reports both boolean-path and diagnostic-path
+> (`check()` vs `safeParse`) comparisons, so numbers stay apples-to-apples.
+
+---
+
+## Documentation
+
+- [Documentation site](https://feralthedogg.github.io/TypeSea/)
+- [API reference](docs/api.md)
+- [Engine notes](docs/engine-notes.md)
+
+---
+
+## License
+
+MIT License. See [LICENSE](./LICENSE).

package/dist/adapters/index.d.ts

@@ -0,0 +1,152 @@
+import { type AsyncDecodeSource, type InferAsyncDecoder } from "../async/index.js";
+import { type DecodeSource, type InferDecoder } from "../decoder/index.js";
+import { TypeSeaAssertionError, type Guard, type Presence } from "../guard/index.js";
+import { type IssueMessageOptions } from "../message/index.js";
+import type { Result } from "../result/index.js";
+import { type JsonSchema, type JsonSchemaDialect, type JsonSchemaExportIssue } from "../json-schema/index.js";
+/**
+ * @brief sync adapter source.
+ */
+export type SyncAdapterSource = DecodeSource;
+/**
+ * @brief infer sync adapter.
+ */
+export type InferSyncAdapter<TSource> = InferDecoder<TSource>;
+/**
+ * @brief infer adapter.
+ */
+export type InferAdapter<TSource> = InferAsyncDecoder<TSource>;
+/**
+ * @brief trpc parser.
+ */
+export interface TrpcParser<TValue> {
+    readonly parse: (value: unknown) => TValue;
+}
+/**
+ * @brief async trpc parser.
+ */
+export interface AsyncTrpcParser<TValue> {
+    readonly parseAsync: (value: unknown) => Promise<TValue>;
+}
+/**
+ * @brief fastify route schema.
+ */
+export interface FastifyRouteSchema {
+    readonly body?: JsonSchema;
+    readonly querystring?: JsonSchema;
+    readonly params?: JsonSchema;
+    readonly headers?: JsonSchema;
+    readonly response?: Readonly<Record<string, JsonSchema>>;
+}
+/**
+ * @brief fastify http part.
+ */
+export type FastifyHttpPart = "body" | "querystring" | "params" | "headers";
+/**
+ * @brief fastify route schema options.
+ */
+export interface FastifyRouteSchemaOptions {
+    readonly part: FastifyHttpPart;
+    /**
+     * @brief schema id.
+     * @details Forwards a concrete `$schema` marker to the JSON Schema exporter.
+     * @invariant When omitted, TypeSea emits its conservative default dialect marker.
+     */
+    readonly schemaId?: string;
+    /**
+     * @brief dialect.
+     * @details Selects the JSON Schema keyword set used by generated route schemas.
+     * @invariant Tuple schemas remain validator-visible for the selected dialect.
+     */
+    readonly dialect?: JsonSchemaDialect;
+}
+/**
+ * @brief fastify validator route.
+ */
+export interface FastifyValidatorRoute {
+    readonly schema: unknown;
+    readonly method: string | undefined;
+    readonly url: string | undefined;
+    readonly httpPart: string | undefined;
+}
+/**
+ * @brief fastify validation result.
+ */
+export type FastifyValidationResult = {
+    readonly value: unknown;
+} | {
+    readonly error: TypeSeaAssertionError;
+};
+/**
+ * @brief fastify validator.
+ */
+export type FastifyValidator = (value: unknown) => FastifyValidationResult;
+/**
+ * @brief fastify validator compiler.
+ */
+export type FastifyValidatorCompiler = (route: FastifyValidatorRoute) => FastifyValidator;
+/**
+ * @brief fastify validator compiler source map.
+ * @details Maps one Fastify payload channel to the TypeSea source that owns that channel.
+ * @invariant Only supported Fastify HTTP parts are consulted by the compiler.
+ */
+export type FastifyValidatorCompilerSourceMap = Readonly<Partial<Record<FastifyHttpPart, SyncAdapterSource>>>;
+/**
+ * @brief fastify validator compiler source.
+ * @details Accepts the historical single-source form or an explicit route-part map.
+ * @invariant A mapped source is selected by `route.httpPart` before validation.
+ */
+export type FastifyValidatorCompilerSource = SyncAdapterSource | FastifyValidatorCompilerSourceMap;
+/**
+ * @brief react hook form field error.
+ */
+export interface ReactHookFormFieldError {
+    readonly type: string;
+    readonly message: string;
+}
+/**
+ * @brief react hook form errors.
+ * @details Defines the nested field-error tree React Hook Form traverses by path segment.
+ * @invariant Branches are frozen objects and leaves are frozen `ReactHookFormFieldError` values.
+ */
+export interface ReactHookFormErrors {
+    readonly [key: string]: ReactHookFormFieldError | ReactHookFormErrors;
+}
+/**
+ * @brief react hook form resolver result.
+ */
+export interface ReactHookFormResolverResult<TValue> {
+    readonly values: TValue | Readonly<Record<string, never>>;
+    readonly errors: ReactHookFormErrors;
+}
+/**
+ * @brief react hook form resolver.
+ */
+export type ReactHookFormResolver<TValue> = (values: unknown, context: unknown, options: unknown) => Promise<ReactHookFormResolverResult<TValue>>;
+/**
+ * @brief react hook form resolver options.
+ */
+export interface ReactHookFormResolverOptions {
+    readonly messages: Partial<IssueMessageOptions> | undefined;
+}
+/**
+ * @brief to trpc parser.
+ */
+export declare function toTrpcParser<TSource extends SyncAdapterSource>(source: TSource): TrpcParser<InferSyncAdapter<TSource>>;
+/**
+ * @brief to async trpc parser.
+ */
+export declare function toAsyncTrpcParser<TSource extends AsyncDecodeSource>(source: TSource): AsyncTrpcParser<InferAdapter<TSource>>;
+/**
+ * @brief to fastify route schema.
+ */
+export declare function toFastifyRouteSchema(guard: Guard<unknown, Presence>, options?: Partial<FastifyRouteSchemaOptions>): Result<FastifyRouteSchema, readonly JsonSchemaExportIssue[]>;
+/**
+ * @brief to fastify validator compiler.
+ */
+export declare function toFastifyValidatorCompiler(source: FastifyValidatorCompilerSource): FastifyValidatorCompiler;
+/**
+ * @brief to react hook form resolver.
+ */
+export declare function toReactHookFormResolver<TSource extends AsyncDecodeSource>(source: TSource, options?: Partial<ReactHookFormResolverOptions>): ReactHookFormResolver<InferAdapter<TSource>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"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"}