@czap/core 0.1.0

package/src/capsules/boundary-evaluate.ts

@@ -0,0 +1,128 @@
+/**
+ * Capsule declaration wrapping `Boundary.evaluate` as a `pureTransform`
+ * instance. Proves the factory kernel against an existing, well-tested
+ * primitive with zero-allocation hot-path discipline.
+ *
+ * Input schema is structural — the run handler aligns the random
+ * thresholds + states arrays into a valid Boundary before evaluating.
+ * This way the harness-driven property tests exercise real boundary
+ * shapes without requiring the schema layer to encode the
+ * (thresholds.length === states.length, ascending, non-empty)
+ * invariants directly.
+ *
+ * @module
+ */
+
+import { Schema } from 'effect';
+import { defineCapsule } from '../assembly.js';
+import { Boundary } from '../boundary.js';
+
+const EvaluateInputSchema = Schema.Struct({
+  // Random arrays — the run handler dedupes states and aligns lengths.
+  // We use Schema.Array (not NonEmptyArray) for compatibility with the
+  // edge case `length === 0`, which we handle by short-circuiting in run.
+  thresholds: Schema.Array(Schema.Number),
+  states: Schema.Array(Schema.String),
+  value: Schema.Number,
+});
+const EvaluateOutputSchema = Schema.Struct({
+  state: Schema.String,
+  matched: Schema.Boolean,
+});
+
+type EvaluateInput = {
+  readonly thresholds: readonly number[];
+  readonly states: readonly string[];
+  readonly value: number;
+};
+type EvaluateOutput = { readonly state: string; readonly matched: boolean };
+
+/**
+ * Build a valid Boundary from arbitrary input and evaluate it. When the
+ * input cannot form a valid boundary (empty states, too few thresholds
+ * after dedupe), we emit `{state: '', matched: false}` so invariants
+ * downstream can short-circuit on `matched`.
+ */
+function _runBoundary(input: EvaluateInput): EvaluateOutput {
+  // Dedupe state names and clamp to a usable count
+  const seenStates = new Set<string>();
+  const uniqueStates: string[] = [];
+  for (const s of input.states) {
+    if (!seenStates.has(s)) {
+      seenStates.add(s);
+      uniqueStates.push(s);
+    }
+  }
+  if (uniqueStates.length === 0) {
+    return { state: '', matched: false };
+  }
+
+  // Build strictly-ascending thresholds. If we don't have enough unique
+  // thresholds for the available states, trim states to fit.
+  const sortedThresholds = [...input.thresholds].sort((a, b) => a - b);
+  const ascending: number[] = [];
+  let prev = Number.NEGATIVE_INFINITY;
+  for (const t of sortedThresholds) {
+    if (Number.isFinite(t) && t > prev) {
+      ascending.push(t);
+      prev = t;
+    }
+  }
+  // Boundary.make requires at least one [threshold, state] pair.
+  if (ascending.length === 0) {
+    // Fabricate a single-anchor boundary at 0 with the first state.
+    const onlyState = uniqueStates[0]!;
+    const b = Boundary.make({
+      input: 'cap.boundary-evaluate',
+      at: [[0, onlyState]] as const,
+    });
+    const state = Boundary.evaluate(b, input.value);
+    return { state, matched: true };
+  }
+
+  const usableLen = Math.min(ascending.length, uniqueStates.length);
+  const pairs: Array<readonly [number, string]> = [];
+  for (let i = 0; i < usableLen; i++) {
+    pairs.push([ascending[i]!, uniqueStates[i]!] as const);
+  }
+  const b = Boundary.make({
+    input: 'cap.boundary-evaluate',
+    at: pairs as never,
+  });
+  const state = Boundary.evaluate(b, input.value);
+  return { state, matched: true };
+}
+
+/**
+ * Declared capsule for `Boundary.evaluate`. Registered in the module-level
+ * catalog at import time; walked by `scripts/capsule-compile.ts` during
+ * the gauntlet's `capsule:compile` phase.
+ */
+export const boundaryEvaluateCapsule = defineCapsule({
+  _kind: 'pureTransform',
+  name: 'core.boundary.evaluate',
+  input: EvaluateInputSchema,
+  output: EvaluateOutputSchema,
+  capabilities: { reads: [], writes: [] },
+  invariants: [
+    {
+      name: 'state-from-input-states-when-matched',
+      check: (input: EvaluateInput, output: EvaluateOutput): boolean => {
+        // When the run handler reports `matched`, the emitted state
+        // must be one of the input.states (after dedupe). When unmatched,
+        // the invariant trivially holds.
+        if (!output.matched) return true;
+        return input.states.includes(output.state);
+      },
+      message: 'emitted state must be one of input.states',
+    },
+    {
+      name: 'unmatched-implies-empty-state',
+      check: (_input: EvaluateInput, output: EvaluateOutput): boolean => output.matched || output.state === '',
+      message: 'unmatched outcomes must use empty-string state',
+    },
+  ],
+  budgets: { p95Ms: 0.1, allocClass: 'zero' },
+  site: ['node', 'browser', 'worker'],
+  run: (input: EvaluateInput): EvaluateOutput => _runBoundary(input),
+});

package/src/capsules/canonical-cbor.ts

@@ -0,0 +1,60 @@
+/**
+ * Capsule declaration wrapping CanonicalCbor as a `pureTransform`. Anchors
+ * the content-address kernel inside the 7-arm factory so the harness can
+ * audit the encoder alongside boundary evaluation and token buffering.
+ *
+ * @module
+ */
+
+import { Schema } from 'effect';
+import { defineCapsule } from '../assembly.js';
+import { CanonicalCbor } from '../cbor.js';
+
+/**
+ * Declared capsule for `CanonicalCbor.encode`. Registered in the module-level
+ * catalog at import time; walked by the factory compiler.
+ */
+export const canonicalCborCapsule = defineCapsule({
+  _kind: 'pureTransform',
+  name: 'core.canonical-cbor',
+  input: Schema.Unknown,
+  output: Schema.instanceOf(Uint8Array),
+  capabilities: { reads: [], writes: [] },
+  invariants: [
+    {
+      name: 'output-is-uint8array',
+      check: (_input: unknown, output: Uint8Array): boolean => output instanceof Uint8Array,
+      message: 'encoder output must be Uint8Array',
+    },
+    {
+      name: 'key-order-stable',
+      check: (input: unknown, output: Uint8Array): boolean => {
+        // For plain objects, re-encoding a key-permuted shallow copy must
+        // produce identical bytes. Cheap structural check that binds the
+        // capsule's intent (canonical key order) to its observable output.
+        if (input === null || typeof input !== 'object' || Array.isArray(input) || input instanceof Uint8Array) {
+          return true;
+        }
+        const keys = Object.keys(input as Record<string, unknown>);
+        if (keys.length < 2) return true;
+        // Use Object.fromEntries to build the reversed copy so dangerous keys
+        // like '__proto__' become own properties (not prototype assignments).
+        // Mutating `reversed[k] = ...` would set the prototype for k === '__proto__'
+        // and silently produce a different object shape than the input had.
+        const reversed = Object.fromEntries(
+          [...keys].reverse().map((k) => [k, (input as Record<string, unknown>)[k]] as const),
+        );
+        const reencoded = CanonicalCbor.encode(reversed);
+        if (reencoded.length !== output.length) return false;
+        for (let i = 0; i < output.length; i++) {
+          if (reencoded[i] !== output[i]) return false;
+        }
+        return true;
+      },
+      message: 'encoded output must be invariant under key permutation',
+    },
+  ],
+  budgets: { p95Ms: 1, allocClass: 'bounded' },
+  site: ['node', 'browser', 'worker', 'edge'],
+  run: (input: unknown): Uint8Array => CanonicalCbor.encode(input),
+});

package/src/capsules/token-buffer.ts

@@ -0,0 +1,57 @@
+/**
+ * Capsule declaration wrapping TokenBuffer as a stateMachine.
+ * Proves the factory kernel against a stateful LLM-token primitive
+ * with bounded-allocation discipline.
+ *
+ * @module
+ */
+
+import { Schema } from 'effect';
+import { defineCapsule } from '../assembly.js';
+
+const TokenEventSchema = Schema.Union([
+  Schema.Struct({ _tag: Schema.Literal('push'), token: Schema.String }),
+  Schema.Struct({ _tag: Schema.Literal('flush') }),
+  Schema.Struct({ _tag: Schema.Literal('reset') }),
+]);
+
+const PhaseSchema = Schema.Union([Schema.Literal('idle'), Schema.Literal('buffering'), Schema.Literal('draining')]);
+
+const BufferStateSchema = Schema.Struct({
+  phase: PhaseSchema,
+  tokens: Schema.Array(Schema.String),
+  totalBytes: Schema.Number,
+});
+
+/**
+ * Declared capsule for TokenBuffer. Registered in the module-level
+ * catalog at import time; walked by the factory compiler.
+ */
+export const tokenBufferCapsule = defineCapsule({
+  _kind: 'stateMachine',
+  name: 'core.token-buffer',
+  input: TokenEventSchema,
+  output: BufferStateSchema,
+  capabilities: { reads: [], writes: ['buffer.tokens'] },
+  invariants: [
+    {
+      name: 'phase-matches-content',
+      check: (_i, o) => {
+        const out = o as { phase: string; tokens: readonly string[] };
+        return out.tokens.length === 0 ? out.phase !== 'buffering' : true;
+      },
+      message: 'empty buffer cannot be in buffering phase',
+    },
+    {
+      name: 'totalBytes-tracks-tokens',
+      check: (_i, o) => {
+        const out = o as { tokens: readonly string[]; totalBytes: number };
+        const expected = out.tokens.reduce((s, t) => s + t.length, 0);
+        return out.totalBytes === expected;
+      },
+      message: 'totalBytes must equal sum of token byte lengths',
+    },
+  ],
+  budgets: { p95Ms: 0.5, allocClass: 'bounded' },
+  site: ['node', 'browser'],
+});

package/src/capture.ts

@@ -0,0 +1,48 @@
+/**
+ * Capture types -- the contract between frame rendering and video encoding.
+ *
+ * `FrameCapture` is the abstraction that both WebCodecs and Remotion
+ * implement. VideoRenderer produces frames, FrameCapture consumes them.
+ *
+ * @module
+ */
+
+import type { Millis } from './brands.js';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** Encoder-facing configuration: target resolution and frame rate. */
+export interface CaptureConfig {
+  readonly width: number;
+  readonly height: number;
+  readonly fps: number;
+}
+
+/** Single pre-rendered frame handed to a {@link FrameCapture} — frame number, timestamp, and pixel source. */
+export interface CaptureFrame {
+  readonly frame: number;
+  readonly timestamp: number;
+  readonly bitmap: ImageBitmap | OffscreenCanvas;
+}
+
+/**
+ * Minimal encoder contract: `init` to open the encoder, `capture` per frame,
+ * `finalize` to flush and return the encoded blob. Implemented by `@czap/web`
+ * (WebCodecs) and `@czap/remotion` (Remotion capture).
+ */
+export interface FrameCapture {
+  readonly _tag: 'FrameCapture';
+  init(config: CaptureConfig): Promise<void>;
+  capture(frame: CaptureFrame): Promise<void>;
+  finalize(): Promise<CaptureResult>;
+}
+
+/** Encoder output returned from {@link FrameCapture}.`finalize`: the encoded blob plus codec metadata. */
+export interface CaptureResult {
+  readonly blob: Blob;
+  readonly codec: string;
+  readonly frames: number;
+  readonly durationMs: Millis;
+}

package/src/cbor.ts

@@ -0,0 +1,199 @@
+/**
+ * Canonical CBOR encoder — RFC 8949 §4.2.1 deterministic encoding.
+ *
+ * Pure encode-only path used to produce stable byte sequences for content
+ * addressing and idempotency hashes. Honors ADR-0003: identical inputs
+ * (including key-permuted plain objects) emit byte-identical Uint8Arrays
+ * across platforms.
+ *
+ * Rules implemented:
+ * - Integers (major 0/1) use shortest form. Range: [MIN_SAFE_INTEGER,
+ *   MAX_SAFE_INTEGER]. Negative `n` encodes as `-1 - n` per spec.
+ * - Numbers that are not safe integers encode as float64 (major 7, simple 27).
+ * - Strings encode as UTF-8 with major 3 length prefix.
+ * - Uint8Array encodes as major 2 (byte string) with length prefix.
+ * - Arrays encode definite-length (major 4).
+ * - Plain objects encode as definite-length maps (major 5). Keys are
+ *   sorted by their **encoded byte order** (lex on UTF-8 bytes for the
+ *   string-keyed case) before emission. `undefined` properties are skipped.
+ * - `false`/`true`/`null` emit simple values 20/21/22. `undefined` is
+ *   coerced to null (22) for JSON parity; plain-object properties whose
+ *   value is `undefined` are skipped entirely.
+ *
+ * @module
+ */
+
+const MAJOR_UNSIGNED = 0 << 5;
+const MAJOR_NEGATIVE = 1 << 5;
+const MAJOR_BYTES = 2 << 5;
+const MAJOR_STRING = 3 << 5;
+const MAJOR_ARRAY = 4 << 5;
+const MAJOR_MAP = 5 << 5;
+const MAJOR_SIMPLE = 7 << 5;
+
+const SIMPLE_FALSE = 20;
+const SIMPLE_TRUE = 21;
+const SIMPLE_NULL = 22;
+const SIMPLE_FLOAT64 = 27;
+
+const textEncoder = new TextEncoder();
+
+/** Internal: encode an unsigned integer head with the given major type. */
+function encodeHead(major: number, value: number): Uint8Array {
+  if (value < 0 || !Number.isFinite(value)) {
+    throw new RangeError(`CanonicalCbor: head argument must be a non-negative finite integer, got ${value}`);
+  }
+  if (value < 24) {
+    return new Uint8Array([major | value]);
+  }
+  if (value < 0x100) {
+    return new Uint8Array([major | 24, value]);
+  }
+  if (value < 0x10000) {
+    return new Uint8Array([major | 25, (value >>> 8) & 0xff, value & 0xff]);
+  }
+  if (value < 0x100000000) {
+    return new Uint8Array([
+      major | 26,
+      (value >>> 24) & 0xff,
+      (value >>> 16) & 0xff,
+      (value >>> 8) & 0xff,
+      value & 0xff,
+    ]);
+  }
+  // 8-byte unsigned integer head; safe up to 2^53 - 1.
+  const high = Math.floor(value / 0x100000000);
+  const low = value >>> 0;
+  return new Uint8Array([
+    major | 27,
+    (high >>> 24) & 0xff,
+    (high >>> 16) & 0xff,
+    (high >>> 8) & 0xff,
+    high & 0xff,
+    (low >>> 24) & 0xff,
+    (low >>> 16) & 0xff,
+    (low >>> 8) & 0xff,
+    low & 0xff,
+  ]);
+}
+
+function concat(parts: readonly Uint8Array[]): Uint8Array {
+  let total = 0;
+  for (const p of parts) total += p.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const p of parts) {
+    out.set(p, offset);
+    offset += p.length;
+  }
+  return out;
+}
+
+function encodeInteger(value: number): Uint8Array {
+  if (value >= 0) {
+    return encodeHead(MAJOR_UNSIGNED, value);
+  }
+  // -1 - n form. For value = -1 → 0; value = -100 → 99; etc.
+  return encodeHead(MAJOR_NEGATIVE, -1 - value);
+}
+
+function encodeFloat64(value: number): Uint8Array {
+  const buf = new ArrayBuffer(8);
+  new DataView(buf).setFloat64(0, value, false /* big-endian */);
+  const out = new Uint8Array(9);
+  out[0] = MAJOR_SIMPLE | SIMPLE_FLOAT64;
+  out.set(new Uint8Array(buf), 1);
+  return out;
+}
+
+function encodeNumber(value: number): Uint8Array {
+  if (
+    Number.isInteger(value) &&
+    value >= Number.MIN_SAFE_INTEGER &&
+    value <= Number.MAX_SAFE_INTEGER
+  ) {
+    return encodeInteger(value);
+  }
+  return encodeFloat64(value);
+}
+
+function encodeString(value: string): Uint8Array {
+  const utf8 = textEncoder.encode(value);
+  return concat([encodeHead(MAJOR_STRING, utf8.length), utf8]);
+}
+
+function encodeBytes(value: Uint8Array): Uint8Array {
+  return concat([encodeHead(MAJOR_BYTES, value.length), value]);
+}
+
+function encodeArray(value: readonly unknown[]): Uint8Array {
+  const parts: Uint8Array[] = [encodeHead(MAJOR_ARRAY, value.length)];
+  for (const item of value) {
+    parts.push(_encode(item));
+  }
+  return concat(parts);
+}
+
+function compareBytes(a: Uint8Array, b: Uint8Array): number {
+  const len = Math.min(a.length, b.length);
+  for (let i = 0; i < len; i++) {
+    const av = a[i]!;
+    const bv = b[i]!;
+    if (av !== bv) return av - bv;
+  }
+  return a.length - b.length;
+}
+
+function encodeObject(value: Record<string, unknown>): Uint8Array {
+  // Skip undefined values to match JSON semantics.
+  const keys = Object.keys(value).filter((k) => value[k] !== undefined);
+  const pairs: { keyBytes: Uint8Array; valueBytes: Uint8Array }[] = [];
+  for (const key of keys) {
+    pairs.push({
+      keyBytes: encodeString(key),
+      valueBytes: _encode(value[key]),
+    });
+  }
+  // RFC 8949 §4.2.1: sort by encoded-key byte sequence, lexicographically.
+  pairs.sort((p, q) => compareBytes(p.keyBytes, q.keyBytes));
+
+  const parts: Uint8Array[] = [encodeHead(MAJOR_MAP, pairs.length)];
+  for (const pair of pairs) {
+    parts.push(pair.keyBytes);
+    parts.push(pair.valueBytes);
+  }
+  return concat(parts);
+}
+
+const _encode = (value: unknown): Uint8Array => {
+  if (value === null || value === undefined) {
+    return new Uint8Array([MAJOR_SIMPLE | SIMPLE_NULL]);
+  }
+  if (typeof value === 'boolean') {
+    return new Uint8Array([MAJOR_SIMPLE | (value ? SIMPLE_TRUE : SIMPLE_FALSE)]);
+  }
+  if (typeof value === 'number') {
+    return encodeNumber(value);
+  }
+  if (typeof value === 'string') {
+    return encodeString(value);
+  }
+  if (value instanceof Uint8Array) {
+    return encodeBytes(value);
+  }
+  if (Array.isArray(value)) {
+    return encodeArray(value);
+  }
+  if (typeof value === 'object') {
+    return encodeObject(value as Record<string, unknown>);
+  }
+  throw new TypeError(`CanonicalCbor: unsupported value type ${typeof value}`);
+};
+
+/** Canonical CBOR encoder namespace (ADR-0001 pattern). */
+export const CanonicalCbor = { encode: _encode } as const;
+
+export declare namespace CanonicalCbor {
+  /** Output type — raw CBOR bytes per RFC 8949 §4.2.1. */
+  export type Encoded = Uint8Array;
+}

package/src/cell.ts

@@ -0,0 +1,130 @@
+/**
+ * Cell<T> -- writable reactive primitive.
+ *
+ * @module
+ */
+
+import type { Scope } from 'effect';
+import { Effect, Stream, SubscriptionRef, Semaphore } from 'effect';
+import { tupleMap } from './tuple.js';
+
+interface CellShape<T> {
+  readonly _tag: 'Cell';
+  readonly ref: SubscriptionRef.SubscriptionRef<T>;
+  readonly changes: Stream.Stream<T>;
+  readonly get: Effect.Effect<T>;
+  set(value: T): Effect.Effect<void>;
+  update(f: (current: T) => T): Effect.Effect<void>;
+}
+
+const _make = <T>(initial: T): Effect.Effect<CellShape<T>> =>
+  Effect.gen(function* () {
+    const ref = yield* SubscriptionRef.make(initial);
+
+    return {
+      _tag: 'Cell' as const,
+      ref,
+      changes: SubscriptionRef.changes(ref),
+      get: SubscriptionRef.get(ref),
+      set: (value: T) => SubscriptionRef.set(ref, value),
+      update: (f: (current: T) => T) => SubscriptionRef.update(ref, f),
+    };
+  });
+
+const _fromStream = <T>(initial: T, source: Stream.Stream<T>): Effect.Effect<CellShape<T>, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    const cell = yield* _make(initial);
+
+    yield* Effect.forkScoped(Stream.runForEach(source, (value) => cell.set(value)));
+
+    return cell;
+  });
+
+/**
+ * Read all values from a tuple of cells, preserving the tuple type `T`.
+ *
+ * Sanctioned single cast site for Cell combinators. Two type-system gaps force
+ * this containment:
+ *   1. `tupleMap`'s callback signature collapses to `U = Effect<T[number]>`,
+ *      losing the per-element `Effect<T[K]>` relationship.
+ *   2. `Effect.all`'s tuple overload returns a mapped-tuple result
+ *      `{ -readonly [K in keyof ...]: _A }` that TypeScript cannot fold back
+ *      to the input tuple type `T` (`T` could be instantiated with an
+ *      arbitrary subtype per the structural contravariance rules).
+ *
+ * The runtime behavior is provably correct: `tupleMap` is total and order-
+ * preserving, `Effect.all` with an array input preserves positional order and
+ * arity, so the resulting values are `T` by construction.
+ */
+export const readAllCellValues = <T extends readonly unknown[]>(
+  cells: { readonly [K in keyof T]: CellShape<T[K]> },
+): Effect.Effect<T> => {
+  const gets = tupleMap(cells, (cell) => cell.get);
+  return Effect.all(gets, { concurrency: 'unbounded' }) as unknown as Effect.Effect<T>;
+};
+
+const _all = <const T extends readonly unknown[]>(
+  cells: { readonly [K in keyof T]: CellShape<T[K]> },
+): Effect.Effect<CellShape<T>, never, Scope.Scope> => {
+  const readAll = readAllCellValues(cells);
+
+  return Effect.gen(function* () {
+    const values = yield* readAll;
+    const combined = yield* _make(values);
+    const sem = Semaphore.makeUnsafe(1);
+
+    yield* Effect.forkScoped(
+      Effect.gen(function* () {
+        const changeStreams = tupleMap(cells, (cell) => cell.changes);
+        const updates = changeStreams.map((changes) =>
+          Stream.runForEach(changes, () =>
+            Semaphore.withPermits(
+              sem,
+              1,
+            )(
+              Effect.gen(function* () {
+                const newValues = yield* readAll;
+                yield* combined.set(newValues);
+              }),
+            ),
+          ),
+        );
+        yield* Effect.all(updates, { concurrency: 'unbounded' });
+      }),
+    );
+
+    return combined;
+  });
+};
+
+const _map = <T, U>(cell: CellShape<T>, fn: (value: T) => U): Effect.Effect<CellShape<U>, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    const initialValue = yield* cell.get;
+    const mappedInitial = fn(initialValue);
+    const mapped = yield* _make(mappedInitial);
+
+    yield* Effect.forkScoped(Stream.runForEach(cell.changes, (value) => mapped.set(fn(value))));
+
+    return mapped;
+  });
+
+/**
+ * Cell — mutable reactive primitive backed by `SubscriptionRef`.
+ * The workhorse of czap's reactive graph: `get` for a snapshot, `set` to
+ * push, `changes` for the stream of subsequent values.
+ */
+export const Cell = {
+  /** Build a cell with an initial value. */
+  make: _make,
+  /** Seed a cell with an initial value and mirror every stream emission into it. */
+  fromStream: _fromStream,
+  /** Tuple-combine cells into a single cell of their current values. */
+  all: _all,
+  /** Scoped `map` — derive a new cell by applying `fn` to every emission. */
+  map: _map,
+};
+
+export declare namespace Cell {
+  /** Structural shape of a {@link Cell}: `_tag`, `get`, `set`, `changes`. */
+  export type Shape<T> = CellShape<T>;
+}

package/src/codec.ts

@@ -0,0 +1,39 @@
+/**
+ * Codec -- Effect Schema codec builder.
+ *
+ * Wraps Effect Schema into a typed codec with encode/decode methods.
+ *
+ * @module
+ */
+
+import type { Effect } from 'effect';
+import { Schema } from 'effect';
+
+interface CodecShape<A, I = A> {
+  readonly schema: Schema.Codec<A, I>;
+  encode(value: A): Effect.Effect<I, Schema.SchemaError>;
+  decode(input: I): Effect.Effect<A, Schema.SchemaError>;
+}
+
+function _make<A, I>(schema: Schema.Codec<A, I>): CodecShape<A, I> {
+  return {
+    schema,
+    encode: (value: A) => Schema.encodeEffect(schema)(value),
+    decode: (input: I) => Schema.decodeEffect(schema)(input),
+  };
+}
+
+/**
+ * Codec — typed encode/decode wrapper over `effect`'s `Schema.Codec`.
+ * Gives a single call site for schema-driven validation so consumers don't
+ * import `Schema.encodeEffect`/`decodeEffect` directly.
+ */
+export const Codec = {
+  /** Wrap a `Schema.Codec` in the {@link Codec.Shape} facade. */
+  make: _make,
+};
+
+export declare namespace Codec {
+  /** Structural shape of a codec: underlying schema plus `encode` / `decode` Effects. */
+  export type Shape<A, I = A> = CodecShape<A, I>;
+}