selaws 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Selaws contributors
+
+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

@@ -1,3 +1,356 @@
-# Temporary Holding Version
+# Selaws
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Independent semantic primitives for TypeScript with explicit laws.
+
+Selaws gives common domain meanings small, separate owners instead of placing
+them behind one framework abstraction. You can introduce nominal scalar
+identity, establish stable facts, declare admissible transitions, define closed
+variants, model optional values, accumulate independent validation issues, and
+carry recoverable failures without changing ordinary JavaScript control flow.
+
+| Owner | Question it answers | Typical code |
+| --- | --- | --- |
+| Identity | What scalar value is this? | `UserId("user_1")` |
+| Evidence | What stable fact is established about this scalar? | `NonEmpty(userId)` |
+| Protocol | Which labeled transition is admissible? | `OrderProtocol.allows("pending", "pay", "paid")` |
+| Variant | Which closed labeled alternative is this? | `Message.make.write("hello")` |
+| Option | Is a value present? | `Option.fromUndefined(value)` |
+| Validation | Which independent checks have issues? | `Validation.struct([["name", check], ...])` |
+| Result | Did a recoverable computation succeed? | `Result.ok(value)` / `Result.err(error)` |
+
+Each owner has its own laws and focused import path. The package does not add a
+workflow runtime, async carrier, schema decoder, or application state store.
+
+Match is a first-class shared elimination law across the sum-like owners, not a
+separate owner or namespace:
+
+```text
+Option.match
+Result.match
+Validation.match
+VariantFamily.match
+```
+
+Each owning surface supplies the branch universe and payload meaning. Match
+requires total typed handling, invokes exactly one selected handler without a
+library-defined `this` receiver, and preserves ordinary return, throw, and
+Promise completion.
+
+## Install
+
+```sh
+npm install selaws
+```
+
+Selaws is ESM, emits ES2022 JavaScript, has zero runtime dependencies, and
+targets the repository's pinned TypeScript 7 toolchain. Older TypeScript
+compilers are outside the compatibility contract.
+
+## Give scalar values domain identity
+
+```ts
+import { identity } from "selaws/identity";
+
+export const UserId = identity.string("UserId");
+export type UserId = identity.Value<typeof UserId>;
+
+export const OrderId = identity.string("OrderId");
+export type OrderId = identity.Value<typeof OrderId>;
+
+function loadUser(id: UserId) {}
+
+loadUser(UserId("user_1"));
+// loadUser(OrderId("order_1")); // type error
+```
+
+Identity formation returns the original JavaScript primitive. The type records
+which domain identity the scalar carries.
+
+Use a checked identity when formation itself owns a local condition:
+
+```ts
+const Port = identity.number(
+  "Port",
+  (value) =>
+    Number.isInteger(value) &&
+    value >= 0 &&
+    value <= 65_535,
+);
+
+const port = Port(input);
+// Port | undefined
+```
+
+String names provide package-copy-stable named identity. A bound `Symbol`
+provides declaration-owned identity when one declaration must control formation.
+
+## Establish stable facts without replacing identity
+
+```ts
+import { evidence } from "selaws/evidence";
+import type { UserId } from "./user-id.js";
+
+const NonEmpty = evidence.string(
+  "NonEmpty",
+  (value) => value.length > 0,
+);
+
+declare const id: UserId;
+
+const checked = NonEmpty(id);
+
+if (checked !== undefined) {
+  const stillUserId: UserId = checked;
+
+  type NonEmptyUserId =
+    evidence.Proven<typeof NonEmpty, UserId>;
+}
+```
+
+Evidence describes a stable fact about the same immutable scalar. Independent
+facts can accumulate while existing identity remains present.
+
+## Declare transition admissibility
+
+```ts
+import { Protocol, type Next } from "selaws/protocol";
+
+const orderTransitions = [
+  ["pending", "pay", "paid"],
+  ["pending", "cancel", "cancelled"],
+  ["paid", "ship", "shipped"],
+] as const;
+
+const OrderProtocol = Protocol.define(orderTransitions);
+
+type PendingPayNext =
+  Next<typeof orderTransitions, "pending", "pay">;
+// "paid"
+
+OrderProtocol.allows("pending", "pay", "paid"); // true
+OrderProtocol.allows("pending", "pay", "cancelled"); // false
+```
+
+Protocol owns the relation of admissible `[from, label, to]` triples. It does
+not own the current state, choose a target, dispatch an event, perform effects,
+persist state, or provide concurrency control.
+
+The relation may be nondeterministic: one `(from, label)` pair may admit more
+than one target.
+
+## Define a closed labeled data vocabulary
+
+```ts
+import { Variant } from "selaws/variant";
+
+const Message = Variant.define("Message", [
+  ["quit", Variant.unit],
+  ["write", Variant.payload<string>()],
+  ["move", Variant.payload<Readonly<{ x: number; y: number }>>()],
+]);
+
+type Message = Variant.Value<typeof Message>;
+
+const message: Message = Message.make.write("hello");
+
+const size = Message.match(message, {
+  quit: () => 0,
+  write: (text) => text.length,
+  move: ({ x, y }) => x + y,
+});
+```
+
+The finite case-entry tuple is the complete Variant family. `make.<case>`
+preserves the correlation between a tag and its payload. `match` is exhaustive over the
+family in typed TypeScript, so adding a case exposes every family-level match
+that must be updated.
+
+Variant values remain ordinary tagged JavaScript objects:
+
+```ts
+Message.make.quit();
+// { tag: "quit" }
+
+Message.make.write("hello");
+// { tag: "write", value: "hello" }
+```
+
+## Represent reasonless absence with Option
+
+```ts
+import { Option } from "selaws/option";
+
+const nickname = Option.fromUndefined(row.nickname);
+
+const displayName = Option.unwrapOr(
+  nickname,
+  "Anonymous",
+);
+```
+
+Use Option when the whole meaning of the empty branch is “no value”. If absence
+needs a reason, that reason belongs in Result or in a domain-specific Variant.
+
+`some(undefined)` is still present. `Option.fromUndefined(undefined)` is
+absent. The distinction is explicit.
+
+## Accumulate independent issues with Validation
+
+```ts
+import { Validation } from "selaws/validation";
+
+const input = Validation.struct([
+  ["name", validateName(raw.name)],
+  ["email", validateEmail(raw.email)],
+]);
+
+if (!input.valid) {
+  console.log(input.errors);
+  // non-empty issue collection
+}
+```
+
+Validation combines checks that are already independently available. It keeps
+all issues in deterministic input order instead of stopping at the first
+failure.
+
+## Sequence recoverable work with Result
+
+```ts
+import { Result, type Result as ResultValue } from "selaws/result";
+
+const parsePort = (
+  text: string,
+): ResultValue<number, "invalid-port"> => {
+  const value = Number(text);
+
+  return Number.isInteger(value) && value > 0 && value <= 65_535
+    ? Result.ok(value)
+    : Result.err("invalid-port");
+};
+```
+
+Result represents one recoverable success or error. Dependent composition is
+fail-fast:
+
+```ts
+const user = await loadUser(userId);
+
+if (!user.ok) {
+  return user;
+}
+
+return loadAccount(user.value.accountId);
+```
+
+Selaws does not hide that control flow behind a generator or async Result
+runtime.
+
+## Move between owners at explicit boundaries
+
+A common application path is to accumulate independent input issues first, then
+enter dependent Result-based work:
+
+```ts
+const input = Validation.struct([
+  ["userId", validateUserId(raw.userId)],
+  ["email", validateEmail(raw.email)],
+]);
+
+const ready = Result.fromValidation(input);
+
+if (!ready.ok) {
+  return ready;
+}
+
+const user = await loadUser(ready.value.userId);
+
+if (!user.ok) {
+  return user;
+}
+
+return saveUser(user.value, ready.value.email);
+```
+
+A Result error can itself use a Variant-owned domain vocabulary:
+
+```ts
+const LoadUserError = Variant.define("LoadUserError", [
+  ["notFound", Variant.payload<{ id: string }>()],
+  ["storage", Variant.payload<{ cause: unknown }>()],
+]);
+
+type LoadUserError = Variant.Value<typeof LoadUserError>;
+
+type LoadUserResult =
+  ResultValue<User, LoadUserError>;
+```
+
+Result owns recoverable success/failure. Variant owns which error alternative
+exists and which payload belongs to it. Neither owner absorbs the other's law.
+
+## Keep JavaScript completion and Promise visible
+
+Result capture helpers mark explicit boundaries around throwing APIs:
+
+```ts
+import { attempt } from "selaws/result";
+
+const parsed = attempt(
+  () => JSON.parse(text) as unknown,
+  (cause) => ({
+    kind: "invalid-json" as const,
+    cause,
+  }),
+);
+```
+
+`attempt` and `attemptAsync` translate explicit abrupt boundaries into Result
+data. `orThrow` performs the reverse boundary when an Err should become a
+thrown JavaScript value.
+
+Promise remains the async owner:
+
+```ts
+Promise<ResultValue<T, E>>
+Promise<Option<T>>
+Promise<Validation<T, E>>
+```
+
+## Imports
+
+Use focused entry points when one owner dominates a module:
+
+```text
+selaws/identity
+selaws/evidence
+selaws/protocol
+selaws/variant
+selaws/option
+selaws/validation
+selaws/result
+```
+
+Use the root facades when several owners are intentionally composed at one
+application boundary:
+
+```ts
+import {
+  Option,
+  Protocol,
+  Result,
+  Validation,
+  Variant,
+} from "selaws";
+```
+
+Generic helper names such as `map`, `match`, `define`, and `Next` stay on
+focused subpaths so the semantic owner remains visible. Match is shared as a
+law rather than centralized as a dispatcher.
+
+## Documentation
+
+- [Guide](./docs/GUIDE.md) — practical patterns and owner composition.
+- [API](./docs/API.md) — public exports and operation groups.
+- [Semantics](./docs/SEMANTICS.md) — package-wide normative ownership and shared laws.
+- [Laws](./docs/laws/) — normative owner laws and shared laws such as [Match](./docs/laws/match.md).

package/dist/evidence.d.ts

@@ -0,0 +1,45 @@
+import { type NarrowSymbolSet, type Scalar, type SingleName, type SingleSymbol, type Token } from "./internal/scalar.js";
+export type { Scalar } from "./internal/scalar.js";
+type EvidenceMarker = {
+    readonly "~selaws.evidence": true;
+};
+/**
+ * A stable fact established about a scalar value.
+ *
+ * Independent fact tokens occupy independent phantom properties, so evidence
+ * composes while preserving existing identity and evidence on the same scalar.
+ */
+export type Evidence<T extends Scalar, Fact extends symbol> = [Fact] extends [never] ? never : [Fact] extends [NarrowSymbolSet<Fact>] ? T & {
+    readonly [Key in Fact]: EvidenceMarker;
+} : never;
+type Establish<T extends Scalar, Fact extends symbol> = <Value extends T>(value: Value) => Evidence<Value, Fact>;
+/** Defines an owner-scoped formation boundary for one stable fact. */
+export declare function defineFact<T extends Scalar>(): <const Fact extends symbol, Api>(token: Fact & SingleSymbol<Fact>, build: (establish: Establish<T, Fact>) => Api) => Api;
+type NamedEvidence<T extends Scalar, Name extends string> = T & {
+    readonly [Key in `~selaws.evidence:${Name}`]: true;
+};
+type FactEvidence<T extends Scalar, TokenValue extends Token> = TokenValue extends string ? NamedEvidence<T, TokenValue> : TokenValue extends symbol ? Evidence<T, TokenValue> : never;
+type Predicate<T> = (value: T) => boolean;
+interface Fact<T extends Scalar, TokenValue extends Token> {
+    <Value extends T>(value: Value): FactEvidence<Value, TokenValue> | undefined;
+    (value: unknown): FactEvidence<T, TokenValue> | undefined;
+}
+interface FactFactory<T extends Scalar> {
+    <const Name extends string>(name: Name & SingleName<Name>, predicate: Predicate<T>): Fact<T, Name>;
+    <const Key extends symbol>(key: Key & SingleSymbol<Key>, predicate: Predicate<T>): Fact<T, Key>;
+}
+type EvidenceFacade = Readonly<{
+    bigint: FactFactory<bigint>;
+    boolean: FactFactory<boolean>;
+    define: typeof defineFact;
+    number: FactFactory<number>;
+    string: FactFactory<string>;
+    symbol: FactFactory<symbol>;
+}>;
+/** Stable scalar facts with named or declaration-owned evidence. */
+export declare const evidence: EvidenceFacade;
+export declare namespace evidence {
+    /** Applies an evidence declaration's fact type to an existing scalar value. */
+    type Proven<F, Value extends Scalar> = F extends Fact<infer T, infer TokenValue> ? Value extends T ? FactEvidence<Value, TokenValue> : never : never;
+}
+//# sourceMappingURL=evidence.d.ts.map

package/dist/evidence.d.ts.map

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

package/dist/evidence.js

@@ -0,0 +1,22 @@
+import { isBigint, isBoolean, isNumber, isString, isSymbol, } from "./internal/scalar.js";
+/** Defines an owner-scoped formation boundary for one stable fact. */
+export function defineFact() {
+    return function define(token, build) {
+        void token;
+        const establish = (value) => value;
+        return build(establish);
+    };
+}
+const factFactory = (isCarrier) => ((_token, predicate) => (value) => isCarrier(value) && predicate(value)
+    ? value
+    : undefined);
+/** Stable scalar facts with named or declaration-owned evidence. */
+export const evidence = {
+    bigint: factFactory(isBigint),
+    boolean: factFactory(isBoolean),
+    define: defineFact,
+    number: factFactory(isNumber),
+    string: factFactory(isString),
+    symbol: factFactory(isSymbol),
+};
+//# sourceMappingURL=evidence.js.map

package/dist/evidence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence.js","sourceRoot":"","sources":["../src/evidence.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,QAAQ,GAMT,MAAM,sBAAsB,CAAC;AA0B9B,sEAAsE;AACtE,MAAM,UAAU,UAAU;IACxB,OAAO,SAAS,MAAM,CACpB,KAAgC,EAChC,KAA6C;QAE7C,KAAK,KAAK,CAAC;QAEX,MAAM,SAAS,GAAG,CAAkB,KAAY,EAAyB,EAAE,CACzE,KAA8B,CAAC;QAEjC,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC;IAC1B,CAAC,CAAC;AACJ,CAAC;AAkCD,MAAM,WAAW,GAAG,CAClB,SAAyC,EACzB,EAAE,CAClB,CAAC,CAAC,MAAa,EAAE,SAAuB,EAAE,EAAE,CAAC,CAAC,KAAc,EAAE,EAAE,CAC9D,SAAS,CAAC,KAAK,CAAC,IAAI,SAAS,CAAC,KAAK,CAAC;IAClC,CAAC,CAAC,KAAK;IACP,CAAC,CAAC,SAAS,CAA8B,CAAC;AAWhD,oEAAoE;AACpE,MAAM,CAAC,MAAM,QAAQ,GAAmB;IACtC,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC;IAC7B,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC;IAC/B,MAAM,EAAE,UAAU;IAClB,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC;IAC7B,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC;IAC7B,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC;CAC9B,CAAC"}

package/dist/identity.d.ts

@@ -0,0 +1,52 @@
+import { type Scalar, type SingleName, type SingleSymbol, type Token } from "./internal/scalar.js";
+export type { Scalar } from "./internal/scalar.js";
+type IdentityMarker = {
+    readonly "~selaws.identity": true;
+};
+/**
+ * A scalar carrying one declaration-owned nominal identity.
+ *
+ * The domain token is the phantom property key itself, so identity belongs to
+ * the declaration that owns the token and remains stable across duplicate
+ * Selaws installations.
+ */
+export type Identity<T extends Scalar, Id extends symbol> = [Id] extends [never] ? never : [Id] extends [SingleSymbol<Id>] ? T & {
+    readonly [Key in Id]: IdentityMarker;
+} : never;
+type Mint<T extends Scalar, Id extends symbol> = <Value extends T>(value: Value) => Identity<Value, Id>;
+/** Defines an owner-scoped formation boundary for one nominal identity. */
+export declare function defineIdentity<T extends Scalar>(): <const Id extends symbol, Api>(token: Id & SingleSymbol<Id>, build: (mint: Mint<T, Id>) => Api) => Api;
+type NamedIdentity<T extends Scalar, Name extends string> = T & {
+    readonly [Key in `~selaws.identity:${Name}`]: true;
+};
+type DomainIdentity<T extends Scalar, TokenValue extends Token> = TokenValue extends string ? NamedIdentity<T, TokenValue> : TokenValue extends symbol ? Identity<T, TokenValue> : never;
+type Predicate<T> = (value: T) => boolean;
+interface OpenIdentity<T extends Scalar, TokenValue extends Token> {
+    <Value extends T>(value: Value): DomainIdentity<Value, TokenValue>;
+    (value: unknown): DomainIdentity<T, TokenValue> | undefined;
+}
+interface CheckedIdentity<T extends Scalar, TokenValue extends Token> {
+    <Value extends T>(value: Value): DomainIdentity<Value, TokenValue> | undefined;
+    (value: unknown): DomainIdentity<T, TokenValue> | undefined;
+}
+interface IdentityFactory<T extends Scalar> {
+    <const Name extends string>(name: Name & SingleName<Name>): OpenIdentity<T, Name>;
+    <const Name extends string>(name: Name & SingleName<Name>, predicate: Predicate<T>): CheckedIdentity<T, Name>;
+    <const Key extends symbol>(key: Key & SingleSymbol<Key>): OpenIdentity<T, Key>;
+    <const Key extends symbol>(key: Key & SingleSymbol<Key>, predicate: Predicate<T>): CheckedIdentity<T, Key>;
+}
+type IdentityFacade = Readonly<{
+    bigint: IdentityFactory<bigint>;
+    boolean: IdentityFactory<boolean>;
+    define: typeof defineIdentity;
+    number: IdentityFactory<number>;
+    string: IdentityFactory<string>;
+    symbol: IdentityFactory<symbol>;
+}>;
+/** Scalar identity formation with named or declaration-owned identity. */
+export declare const identity: IdentityFacade;
+export declare namespace identity {
+    /** Extracts the scalar identity value type produced by an identity declaration. */
+    type Value<Domain> = Domain extends OpenIdentity<infer T, infer TokenValue> ? DomainIdentity<T, TokenValue> : Domain extends CheckedIdentity<infer T, infer TokenValue> ? DomainIdentity<T, TokenValue> : never;
+}
+//# sourceMappingURL=identity.d.ts.map

package/dist/identity.d.ts.map

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

package/dist/identity.js

@@ -0,0 +1,22 @@
+import { isBigint, isBoolean, isNumber, isString, isSymbol, } from "./internal/scalar.js";
+/** Defines an owner-scoped formation boundary for one nominal identity. */
+export function defineIdentity() {
+    return function define(token, build) {
+        void token;
+        const mint = (value) => value;
+        return build(mint);
+    };
+}
+const identityFactory = (isCarrier) => ((_token, predicate) => (value) => isCarrier(value) && (predicate === undefined || predicate(value))
+    ? value
+    : undefined);
+/** Scalar identity formation with named or declaration-owned identity. */
+export const identity = {
+    bigint: identityFactory(isBigint),
+    boolean: identityFactory(isBoolean),
+    define: defineIdentity,
+    number: identityFactory(isNumber),
+    string: identityFactory(isString),
+    symbol: identityFactory(isSymbol),
+};
+//# sourceMappingURL=identity.js.map

package/dist/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.js","sourceRoot":"","sources":["../src/identity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,QAAQ,GAKT,MAAM,sBAAsB,CAAC;AA2B9B,2EAA2E;AAC3E,MAAM,UAAU,cAAc;IAC5B,OAAO,SAAS,MAAM,CACpB,KAA4B,EAC5B,KAAiC;QAEjC,KAAK,KAAK,CAAC;QAEX,MAAM,IAAI,GAAG,CAAkB,KAAY,EAAuB,EAAE,CAClE,KAA4B,CAAC;QAE/B,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC;IACrB,CAAC,CAAC;AACJ,CAAC;AA2CD,MAAM,eAAe,GAAG,CACtB,SAAyC,EACrB,EAAE,CACtB,CAAC,CAAC,MAAa,EAAE,SAAwB,EAAE,EAAE,CAAC,CAAC,KAAc,EAAE,EAAE,CAC/D,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC;IAC/D,CAAC,CAAC,KAAK;IACP,CAAC,CAAC,SAAS,CAAkC,CAAC;AAWpD,0EAA0E;AAC1E,MAAM,CAAC,MAAM,QAAQ,GAAmB;IACtC,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC;IACjC,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC;IACnC,MAAM,EAAE,cAAc;IACtB,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC;IACjC,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC;IACjC,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC;CAClC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import { Option as OptionFacade } from "./option.js";
+import { Protocol as ProtocolFacade } from "./protocol.js";
+import { Result as ResultFacade } from "./result/core.js";
+import { Validation as ValidationFacade } from "./validation.js";
+import { Variant as VariantFacade } from "./variant.js";
+export { type Evidence, evidence } from "./evidence.js";
+export { type Identity, identity, type Scalar } from "./identity.js";
+/** Root-entry Protocol carrier paired with the Protocol facade value. */
+export type Protocol<Transitions extends readonly import("./protocol.js").Transition[]> = import("./protocol.js").Protocol<Transitions>;
+/** Root-entry Protocol facade. */
+export declare const Protocol: typeof ProtocolFacade;
+/** Root-entry Variant carrier paired with the Variant facade value. */
+export type Variant<Family> = import("./variant.js").Variant<Family>;
+/** Root-entry Variant facade. */
+export declare const Variant: typeof VariantFacade;
+export declare namespace Variant {
+    /** Extracts the closed value union produced by one Variant family. */
+    type Value<Family> = import("./variant.js").Variant<Family>;
+}
+export type { None, OptionValue, Some } from "./option.js";
+/** Root-entry Option carrier paired with the Option facade value. */
+export type Option<T> = import("./option.js").Option<T>;
+/** Root-entry Option facade. */
+export declare const Option: typeof OptionFacade;
+export type { Invalid, Valid, ValidationError, ValidationIssues, ValidationValue, } from "./validation.js";
+/** Root-entry Validation carrier paired with the Validation facade value. */
+export type Validation<T, E> = import("./validation.js").Validation<T, E>;
+/** Root-entry Validation facade. */
+export declare const Validation: typeof ValidationFacade;
+export type { AsyncResult, Err, Ok, ResultError, ResultValue, } from "./result/core.js";
+/** Root-entry Result carrier paired with the Result facade value. */
+export type Result<T, E> = import("./result/core.js").Result<T, E>;
+/** Root-entry Result facade. */
+export declare const Result: typeof ResultFacade;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,YAAY,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,QAAQ,IAAI,cAAc,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,MAAM,IAAI,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EAAE,UAAU,IAAI,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,cAAc,CAAC;AAExD,OAAO,EAAE,KAAK,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,KAAK,QAAQ,EAAE,QAAQ,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAErE,yEAAyE;AACzE,MAAM,MAAM,QAAQ,CAClB,WAAW,SAAS,SAAS,OAAO,eAAe,EAAE,UAAU,EAAE,IAC/D,OAAO,eAAe,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;AAClD,kCAAkC;AAClC,eAAO,MAAM,QAAQ,EAAE,OAAO,cAA+B,CAAC;AAE9D,uEAAuE;AACvE,MAAM,MAAM,OAAO,CAAC,MAAM,IAAI,OAAO,cAAc,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;AACrE,iCAAiC;AACjC,eAAO,MAAM,OAAO,EAAE,OAAO,aAA6B,CAAC;AAC3D,yBAAiB,OAAO,CAAC;IACvB,sEAAsE;IACtE,KAAY,KAAK,CAAC,MAAM,IAAI,OAAO,cAAc,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;CACpE;AAED,YAAY,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAC3D,qEAAqE;AACrE,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,OAAO,aAAa,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;AACxD,gCAAgC;AAChC,eAAO,MAAM,MAAM,EAAE,OAAO,YAA2B,CAAC;AAExD,YAAY,EACV,OAAO,EACP,KAAK,EACL,eAAe,EACf,gBAAgB,EAChB,eAAe,GAChB,MAAM,iBAAiB,CAAC;AACzB,6EAA6E;AAC7E,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,IAAI,OAAO,iBAAiB,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAC1E,oCAAoC;AACpC,eAAO,MAAM,UAAU,EAAE,OAAO,gBAAmC,CAAC;AAEpE,YAAY,EACV,WAAW,EACX,GAAG,EACH,EAAE,EACF,WAAW,EACX,WAAW,GACZ,MAAM,kBAAkB,CAAC;AAC1B,qEAAqE;AACrE,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,OAAO,kBAAkB,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACnE,gCAAgC;AAChC,eAAO,MAAM,MAAM,EAAE,OAAO,YAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+import { Option as OptionFacade } from "./option.js";
+import { Protocol as ProtocolFacade } from "./protocol.js";
+import { Result as ResultFacade } from "./result/core.js";
+import { Validation as ValidationFacade } from "./validation.js";
+import { Variant as VariantFacade } from "./variant.js";
+export { evidence } from "./evidence.js";
+export { identity } from "./identity.js";
+/** Root-entry Protocol facade. */
+export const Protocol = ProtocolFacade;
+/** Root-entry Variant facade. */
+export const Variant = VariantFacade;
+/** Root-entry Option facade. */
+export const Option = OptionFacade;
+/** Root-entry Validation facade. */
+export const Validation = ValidationFacade;
+/** Root-entry Result facade. */
+export const Result = ResultFacade;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,IAAI,YAAY,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,QAAQ,IAAI,cAAc,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,MAAM,IAAI,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EAAE,UAAU,IAAI,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,cAAc,CAAC;AAExD,OAAO,EAAiB,QAAQ,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAiB,QAAQ,EAAe,MAAM,eAAe,CAAC;AAMrE,kCAAkC;AAClC,MAAM,CAAC,MAAM,QAAQ,GAA0B,cAAc,CAAC;AAI9D,iCAAiC;AACjC,MAAM,CAAC,MAAM,OAAO,GAAyB,aAAa,CAAC;AAS3D,gCAAgC;AAChC,MAAM,CAAC,MAAM,MAAM,GAAwB,YAAY,CAAC;AAWxD,oCAAoC;AACpC,MAAM,CAAC,MAAM,UAAU,GAA4B,gBAAgB,CAAC;AAWpE,gCAAgC;AAChC,MAAM,CAAC,MAAM,MAAM,GAAwB,YAAY,CAAC"}

package/dist/internal/callback.d.ts

@@ -0,0 +1,13 @@
+type Same<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => (T extends B ? 1 : 2) ? (<T>() => T extends B ? 1 : 2) extends <T>() => (T extends A ? 1 : 2) ? true : false : false;
+type UnknownCallback = (this: void, ...args: never[]) => unknown;
+type OverloadUnion<Callback, Partial = unknown, Previous = never, Repeated extends boolean = false, Accumulated = never> = Callback extends (this: infer This, ...args: infer Args) => infer Result ? ((this: This, ...args: Args) => Result) extends infer Current ? Same<Current, Previous> extends true ? Repeated extends true ? Accumulated | UnknownCallback : Partial extends Callback ? Accumulated : OverloadUnion<Partial & Callback, Partial & Current, Current, true, Accumulated | Current> : Partial extends Callback ? Accumulated : OverloadUnion<Partial & Callback, Partial & Current, Current, false, Accumulated | Current> : Accumulated : Accumulated;
+/**
+ * Extracts a conservative union of callable return types.
+ *
+ * TypeScript exposes overloads as intersections. Generic callable reflection
+ * can repeat one instantiated signature indefinitely; repeated reflection
+ * widens to unknown instead of exhausting compiler instantiation depth.
+ */
+export type CallbackResult<Callback> = OverloadUnion<Callback> extends infer One ? One extends (...args: never[]) => infer Result ? Result : never : never;
+export {};
+//# sourceMappingURL=callback.d.ts.map

package/dist/internal/callback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callback.d.ts","sourceRoot":"","sources":["../../src/internal/callback.ts"],"names":[],"mappings":"AAAA,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,IACZ,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,QAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA,GAC/D,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,QAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA,GACjE,IAAI,GACJ,KAAK,GACP,KAAK,CAAC;AAEZ,KAAK,eAAe,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC;AAEjE,KAAK,aAAa,CAChB,QAAQ,EACR,OAAO,GAAG,OAAO,EACjB,QAAQ,GAAG,KAAK,EAChB,QAAQ,SAAS,OAAO,GAAG,KAAK,EAChC,WAAW,GAAG,KAAK,IACjB,QAAQ,SAAS,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,GAAG,IAAI,EAAE,MAAM,IAAI,KAAK,MAAM,MAAM,GACxE,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC,SAAS,MAAM,OAAO,GAC3D,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,SAAS,IAAI,GAClC,QAAQ,SAAS,IAAI,GACnB,WAAW,GAAG,eAAe,GAC7B,OAAO,SAAS,QAAQ,GACtB,WAAW,GACX,aAAa,CACX,OAAO,GAAG,QAAQ,EAClB,OAAO,GAAG,OAAO,EACjB,OAAO,EACP,IAAI,EACJ,WAAW,GAAG,OAAO,CACtB,GACL,OAAO,SAAS,QAAQ,GACtB,WAAW,GACX,aAAa,CACX,OAAO,GAAG,QAAQ,EAClB,OAAO,GAAG,OAAO,EACjB,OAAO,EACP,KAAK,EACL,WAAW,GAAG,OAAO,CACtB,GACL,WAAW,GACb,WAAW,CAAC;AAEhB;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,CAAC,QAAQ,IACjC,aAAa,CAAC,QAAQ,CAAC,SAAS,MAAM,GAAG,GACrC,GAAG,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,MAAM,MAAM,GAC5C,MAAM,GACN,KAAK,GACP,KAAK,CAAC"}

package/dist/internal/callback.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=callback.js.map

package/dist/internal/callback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"callback.js","sourceRoot":"","sources":["../../src/internal/callback.ts"],"names":[],"mappings":""}

package/dist/internal/promise-like.d.ts

@@ -0,0 +1,8 @@
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type BroadFunction = FunctionConstructor["prototype"];
+type HasCallableThen<T> = T extends object ? "then" extends keyof T ? Extract<T["then"], BroadFunction> extends never ? false : true : false : false;
+export type NotPromiseLike<T> = IsAny<T> extends true ? T : true extends (T extends unknown ? HasCallableThen<T> : never) ? never : T;
+export declare const isPromiseLike: (value: unknown) => value is PromiseLike<unknown>;
+export declare const assertNotPromiseLike: (value: unknown, message: string) => void;
+export {};
+//# sourceMappingURL=promise-like.d.ts.map

package/dist/internal/promise-like.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-like.d.ts","sourceRoot":"","sources":["../../src/internal/promise-like.ts"],"names":[],"mappings":"AAAA,KAAK,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC;AAE/C,KAAK,aAAa,GAAG,mBAAmB,CAAC,WAAW,CAAC,CAAC;AAEtD,KAAK,eAAe,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GACtC,MAAM,SAAS,MAAM,CAAC,GACpB,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC,SAAS,KAAK,GAC7C,KAAK,GACL,IAAI,GACN,KAAK,GACP,KAAK,CAAC;AAEV,MAAM,MAAM,cAAc,CAAC,CAAC,IAC1B,KAAK,CAAC,CAAC,CAAC,SAAS,IAAI,GACjB,CAAC,GACD,IAAI,SAAS,CAAC,CAAC,SAAS,OAAO,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,GAC3D,KAAK,GACL,CAAC,CAAC;AAEV,eAAO,MAAM,aAAa,UAAW,OAAO,KAAG,KAAK,IAAI,WAAW,CAAC,OAAO,CAM1E,CAAC;AAEF,eAAO,MAAM,oBAAoB,UAAW,OAAO,WAAW,MAAM,KAAG,IAItE,CAAC"}