Effektive documentation - validation report
Draft 0.1, language core version 0, October 15, 2026.

Delivered content
Two linked HTML documents contain 18 reference sections and nine book chapters.
The documents contain 65 code blocks, 30 Effect-TS tabs, and seven exercises.
Each Effektive example has an Effect-TS tab with a manual translation.
Five .eff files provide canonical source examples.
The site also includes typed-ir.ts and the manual log.ir.json fixture.
The fixture retains log.lft as its source identity.
The IR wire marker remains light-functional-ir, version 1.

Completed document checks
The static HTML check passes for both documents.
The check covers balanced elements, unique identifiers, and 115 local links.
All local document anchors and artifact links resolve.
Prose sentences contain at most 25 whitespace-separated words.
Prose paragraphs contain at most six sentences.
The documents contain no em dashes.
Canonical source snippets match their supplied .eff files where the reference names a complete example.
The source examples contain no return statements or property-arrow service signatures.
The reusable Users module contains no provider acquisition or application entry function.

Completed TypeScript checks
TypeScript 7.0.2 checks typed-ir.ts and the manual fixture under strict settings.
The settings also enable exactOptionalPropertyTypes and noUncheckedIndexedAccess.
All 30 Effect-TS tabs pass these strict settings against Effect 4.0.5.
The three other contract explorer translations in site.js also pass.
Each translation is checked together with the declarations it requires.
Provider examples declare UsersLive and AppLive as Layer values in typecheck/preludes.
An invalid example uses @ts-expect-error, so the check proves that Effect-TS rejects it.
No provider implementation runs during the check.

Completed manual fixture checks
The fixture check passes for four effect sets and seven source spans.
The check resolves one reference and one perform node.
The check validates the log contract, method argument, result, execution mode, and effects.
The check also validates source slices, exported identities, and sorted unique effect sets.
These checks cover this fixture, not every possible IR payload.

Review scope
The reference and book received a review of types, effects, providers, modules, and lowering rules.
The final reference requires resolved identities in error tags, service keys, and brand tokens.
Short keys in isolated book comparisons do not define a backend encoding policy.
Official Effect v4 documentation supports the target API choices.

Draft 0.2 checks, October 17, 2026
Draft 0.2 adds the rule on primitive types, nominal records, and numeric brand operators.
The strict TypeScript check passes for 29 units, with 0 Effektive blocks that lack an Effect-TS tab.
The effektive-lang parser at commit fc00ef7 parses the 32 Effektive blocks of both pages and the five example files.
No block has a primitive type outside a type or error declaration.
The two fragments for pipelines and deferred control are not modules, so they do not parse alone.

Draft 0.2 compiler checks
The effektive-lang compiler builds each other figure together with the figures it requires.
Each figure gives 0 diagnostics, except the invalid example, which gives failure-contract/001 as documented.
The five example files equal fixtures/examples in effektive-lang.
The draft 0.1 sections above describe the earlier edition; their counts were not measured again.

Limits
This package contains no Effektive parser, checker, transpiler, interpreter, or runtime.
All source examples, target comparisons, and the IR fixture are manually authored.
No check executes Effektive source or proves translation equivalence.
Strict target checking proves static compatibility for the checked target examples and declared provider interface.
Static HTML checks do not establish visual rendering or printed pagination.
No browser rendering check ran for these documents.

Commands
python3 work/check_effektive.py
python3 work/check-deliverables.py
tsc --strict --exactOptionalPropertyTypes --noUncheckedIndexedAccess --noEmit outputs/typed-ir.ts work/typecheck-fixture.ts
deno task typecheck

The work directory contains validation scripts and intermediate data in this workspace.
deno task typecheck runs typecheck/check.ts from the repository.

Draft 0.3 specification, October 17, 2026
Language core version 1 specifies references, races, scoped fibers, borrowed handles,
buffered and merged streams, retry schedules, pure codecs, source Layers, and a typed
file service host adapter. The specification requires light-functional-ir version 2.
The effektive-lang compiler implements the listed core 1 extensions and emits IR version 2.
The core 1 example is an illustrative source/target pair; the compiler also
accepts its Effektive source. The strict target check covers its Effect-TS tab.
Historical counts and compiler checks above apply to their named drafts only.

IR version 2 migration
The effektive-lang compiler and independent validator emit and accept version 2.
Version 1 input now produces validation/008. Canonical compiler fixtures and this
site's linked model and log fixture use version 2. The full compiler check passed.

Buffered and merged streams
The compiler accepts bufferStream with a positive safe integer capacity and
mergeStreams with compatible element types. Its validator recomputes active and
deferred channels and rejects an invalid capacity. The emitter uses Stream.buffer
with the suspend strategy and Stream.merge. A runtime test checks deferred
production and per-source order.
The subsequent sections record the remaining core 1 implementation slices.

Races
The compiler accepts race of two compatible Effect values. The validator
recomputes its deferred failure and requirement unions. The emitter calls
Effect.race. A runtime test confirms the losing fiber is interrupted and its
cleanup completes before the result returns. At this milestone, the combined
Ref and race figure still awaited makeRef support.

References
The compiler now accepts Ref<A>, makeRef, getRef, setRef, and updateRef.
The type is invariant in A. The update callback must be pure and return a
compatible A. A runtime test verifies atomic updates under bounded traversal.
The combined Ref and race figure is now implemented source syntax.

FileSystem host adapter
The compiler fixture host-adapter-files declares a Files.read service and
FileReadError. Its TypeScript host provider uses effect/FileSystem and the
Node platform layer. The adapter checks paths and maps package failures to
the declared error. A CLI build with --validate --tsc and a runtime read,
missing-file case, and invalid-path case pass. Other package adapters remain
outside the implemented subset.

Source Layers
The compiler accepts Layer<Services,E,R>, layer(Service, acquire), and
mergeLayers. It checks that an acquisition returns exactly the declared
methods, preserves acquisition failures and requirements, and rejects
overlapping services. provide accepts source Layer expressions. Runtime tests
cover merged providers and an acquisition that needs another service.

Custom retry schedules
The compiler accepts RetrySchedule<E>, retrySchedule with a pure callback,
and retry(job, { schedule: policy }). The independent validator checks the
nominal error input, attempt type, optional millisecond delay, and deferred
failure channels. The emitter uses Schedule.fromStepWithMetadata. A runtime
test confirms one-based attempts, zero-delay retries, and propagation of the
last typed failure when the callback returns None.

Pure source codecs
The compiler accepts Codec<Decoded,Encoded>, codec, decode, and encode.
Both transformations must be pure, and both types must support derived
schemas. Generated code checks inputs and transformed outputs with Effect
Schema and returns None for invalid values. A strict target check and runtime
test cover both directions and an invalid input.

Scoped fibers
The compiler accepts Fiber<A,E>, withFiber, joinFiber, and interruptFiber.
withFiber starts a supervised child from an Effect value and restricts its
handle to direct join or interrupt calls in an inline callback. The child's
service requirements activate when it starts; its failures enter the parent
contract when joined. A runtime test checks explicit interruption and
finalizer completion.

Borrowed opaque handles
A host interface may declare an opaque type and borrow-qualified service
parameters. withResource can acquire that handle. Its use and release callbacks
may pass it directly to qualified host methods or source helpers whose own
borrowed parameters are checked for escape. The checker and independent IR
validator reject returning, capturing, storing, and ordinary argument passing.
A strict host build and runtime test cover acquisition, use, and release.

Draft 0.4 unbounded traversal, October 18, 2026
The spec accepts only the literal option { concurrency: "unbounded" } or a
positive safe integer bound. The compiler checks and independently validates
that option, then passes it to Effect.forEach. No IR wire shape changed, so
light-functional-ir remains at version 2. The runtime regression covers all
jobs starting, input-order results, typed failure, explicit interruption,
scoped finalizers, empty input, and traversal of first-class Effect values.
General heterogeneous Effect.all collection remains outside this slice.

Draft 0.5 heterogeneous Effect collection, October 18, 2026
The source builtin all accepts tuples, records, and arrays whose members are
Effect values. It preserves each result position or key and unions the latent
failure and service sets. A heterogeneous bracket literal needs a contextual
tuple type. The compiler independently validates the builtin type and literal
concurrency option, then emits Effect.all. Target checks and runtime tests
cover tuple and record results, concurrent startup, sibling interruption,
and scoped finalizer completion. The IR wire shape remains version 2.

Draft 0.6 scoped fibers, October 18, 2026
The source builtins scoped and forkScoped add a local scope for first-class
Effect jobs. forkScoped requires an internal Scope capability and accepts only
jobs without typed failures. scoped removes that requirement and closes the
scope after success, failure, defect, or interruption. The compiler checks
and independently validates the requirement channel. A strict target check
and runtime test confirm that a child outlives its spawning fiber while the
local scope remains open and is interrupted when it closes. Raw Scope values
and explicit Scope.close remain deferred. The IR wire shape remains version 2.

Draft 0.7 stream zipping, October 18, 2026
The source builtin zipStreams pairs two Stream values, including those with
different element types. The result carries a tuple element and both streams'
deferred failure and requirement channels. The checker and independent IR
validator enforce that signature. Strict target and runtime tests confirm
deferred production, ordered pairs, shorter-input termination, and peer
interruption with finalizer completion after failure. The IR wire shape
remains version 2.

Draft 0.8 stream concatenation, October 18, 2026
The source builtin concatStreams joins two Stream values sequentially. Its
element type is the union of both inputs' element types, and its deferred
failure and service channels are combined. The checker and independent IR
validator enforce this signature. Strict target and runtime tests confirm
deferred production, left-before-right order, and that a left failure skips
the right stream. The IR wire shape remains version 2.

Draft 0.9 stream flat mapping, October 18, 2026
The source builtin flatMapStreams accepts an outer Stream and an inline pure
callback returning an inner Stream. The checker and independent IR validator
combine the outer and inner deferred failure and requirement channels while
keeping construction pure. Strict target and runtime tests confirm ordered
inner pulls, failure cutoff, and active-inner cleanup on interruption.
Concurrent flatMap and switch behavior remain deferred. The IR wire shape
remains version 2.

Draft 0.10 collection partitioning, October 18, 2026
The source builtin partitionAll accepts a homogeneous array of Effect values
and returns successes and typed failures in separate input-order arrays. The
checker removes typed failures from the active channel while retaining job
requirements. The independent IR validator checks the result shape and
literal concurrency bound. A strict target check and runtime test confirm
that every job runs, both result arrays retain input order, and the bound is
observed. The IR wire shape remains version 2.

Draft 0.11 aggregate validation, October 18, 2026
The source builtin validateAll runs every Effect job in a homogeneous array.
All successes return in input order. On failure, a pure callback wraps every
typed error in one nominal error for the caller's failure contract. The
checker and independent IR validator enforce the callback and concurrency
bound. A strict target check and runtime test cover the success path and
multiple failures under bounded concurrency. The IR wire shape remains
version 2.

Draft 0.12 result collecting, October 18, 2026
The source builtin allResults runs Effect tuples, records, and homogeneous
arrays in Effect.all result mode. It retains each success or typed failure at
its input position as a tagged record union, with no typed failure channel
for the collection. The checker and independent IR validator enforce shape,
service requirements, and the literal concurrency bound. A strict target
check and runtime test cover all three shapes and continued sibling work
after a typed failure. The IR wire shape remains version 2.

Draft 0.13 bounded stream taking, October 18, 2026
The source builtin takeStream takes a Stream and a pure Int count. It retains
the source's deferred element, failure, and service channels. The checker and
independent IR validator enforce these rules. A strict target and runtime
test confirms no pulls for nonpositive counts, a bounded prefix for a
positive count, failure cutoff, and completion of started pull finalizers.
The IR wire shape remains version 2.

Draft 0.14 predicate stream taking, October 18, 2026
The source builtin takeWhileStream takes a Stream and an inline pure boolean
predicate. It retains the source's deferred element, failure, and service
channels. The checker and independent IR validator enforce the signature.
A strict target and runtime test confirms deferred construction, omission of
the first rejected element, no later pulls, typed failure before the boundary,
and completion of started pull finalizers. The IR wire shape remains version 2.

Draft 0.15 inclusive stream taking, October 18, 2026
The source builtin takeUntilStream takes a Stream and an inline pure boolean
predicate. It retains the source's deferred element, failure, and service
channels. The checker and independent IR validator enforce the signature.
A strict target and runtime test confirms deferred construction, inclusion
of the first matching element, full output without a match, no later pulls
after a match, typed failure before a match, and completion of started pull
finalizers. The IR wire shape remains version 2.

Draft 0.16 stream prefix discard, October 18, 2026
The source builtin dropStream takes a Stream and a pure Int count. It retains
the source's deferred element, failure, and service channels. The checker and
independent IR validator enforce the count type and construction purity. A
strict target and runtime test confirms deferred construction, unchanged
output for nonpositive counts, prefix discard, exhaustion before the count,
typed failure in a discarded prefix, and completion of started pull
finalizers. The IR wire shape remains version 2.

Draft 0.17 predicate stream prefix discard, October 18, 2026
The source builtin dropWhileStream takes a Stream and an inline pure boolean
predicate. It retains the source's deferred element, failure, and service
channels. The checker and independent IR validator enforce the signature.
A strict target and runtime test confirms deferred construction, inclusion
of the first false element and later values even when they satisfy the
predicate, empty output when every element satisfies it, typed failure in
the discarded prefix, and completion of started pull finalizers. The IR
wire shape remains version 2.

Draft 0.18 stream filtering, October 18, 2026
The source builtin filterStream takes a Stream and an inline pure boolean
predicate. It retains the source's deferred element, failure, and service
channels. The checker and independent IR validator enforce the signature.
A strict target and runtime test confirms deferred construction, per-element
selection in source order, empty output without matches, typed failure after
rejected elements, and completion of started pull finalizers. The IR wire
shape remains version 2.

Draft 0.19 pure stream mapping, October 18, 2026
The source builtin mapStream takes a Stream and an inline pure one-argument
transform. It infers a new element type while retaining the source's deferred
failure and service channels. The checker and independent IR validator enforce
the callback and result type. A strict target and runtime test confirms
deferred construction, ordered values of a new type, source failure after
earlier mapped values, and completion of started pull finalizers. The IR
wire shape remains version 2.

Draft 0.20 stateful stream scanning, October 18, 2026
The source builtin scanStream takes a Stream, a pure seed, and an inline pure
two-argument update callback. It emits the seed before pulling, then emits
each updated state in source order. The checker and independent IR validator
enforce the state type and preserve deferred failure and service channels.
Strict target and runtime tests confirm a lazy seed function, fresh scan state
per consumption, empty-source output, typed source failure after prior states,
and completion of started pull finalizers. The IR wire shape remains version 2.

Draft 0.21 stateful stream mapping, October 18, 2026
The source builtin mapAccumStream takes a Stream, a pure seed, and an inline
pure two-argument callback with an explicit [State, Output[]] result type.
The checker and independent IR validator enforce the tuple state and output
types and preserve the source's deferred failure and service channels.
Strict target and runtime tests confirm a lazy seed function, zero, one, and
many ordered outputs per input, fresh state per consumption, no seed output,
source failure after prior outputs, and completion of started pull finalizers.
The IR wire shape remains version 2.

Draft 0.22 terminal stream folding, October 18, 2026
The source builtin foldStream takes a Stream, a pure seed, and an inline pure
two-argument update callback. It returns the final state as an effectful
expression. The checker and independent IR validator enforce the update type
and move deferred source failures and requirements into the active contract.
Strict target and runtime tests confirm a lazy seed function, repeated
execution from fresh state, the seed result for an empty source, typed source
failure, and completion of started pull finalizers. The IR wire shape remains
version 2.

Draft 0.23 effectful terminal stream folding, October 18, 2026
The source builtin foldEffectStream takes a Stream, a pure seed, and an inline
update callback that may fail or require services. The checker and independent
IR validator enforce the state type and union source and callback failures
and requirements in the active effect contract. Strict target and runtime
tests confirm lazy construction, sequential updates, fresh state, pure
callback lifting, empty-source seed output, distinct source and callback
failures, stopping later pulls, and completion of started pull finalizers.
The IR wire shape remains version 2.

Draft 0.24 terminal stream collection, October 18, 2026
The source builtin collectStream takes a Stream and returns its elements in
source order as an effectful array result. The checker and independent IR
validator move the source's deferred failures and service requirements into
the active contract. Strict target and runtime tests confirm deferred
construction, fresh arrays on repeated execution, empty-source output, typed
source failure without a partial result, and completion of started pull
finalizers. The IR wire shape remains version 2.

Draft 0.25 terminal first-element stream consumption, October 18, 2026
The source builtin headStream takes a Stream and returns its first element
as an effectful Option result. The checker and independent IR validator move
the source's deferred failures and service requirements into the active
contract. Strict target and runtime tests confirm deferred construction,
repeated execution, Some for the first element, None for an empty source,
stopping before later pulls, typed source failure before the first element,
and completion of started pull finalizers. The IR wire shape remains version 2.

Draft 0.26 terminal last-element stream consumption, October 18, 2026
The source builtin lastStream takes a Stream and returns its final element
as an effectful Option result after source completion. The checker and
independent IR validator move the source's deferred failures and service
requirements into the active contract. Strict target and runtime tests
confirm deferred construction, repeated execution, Some for the final
element, None for an empty source, complete pulling, typed source failure
after earlier elements, and completion of started pull finalizers. The IR
wire shape remains version 2.

Draft 0.27 terminal stream draining, October 18, 2026
The source builtin drainStream takes a Stream and runs it to completion,
discarding emitted values and returning void. The checker and independent
IR validator move the source's deferred failures and service requirements
into the active contract. Strict target and runtime tests confirm deferred
construction, repeated execution, full pulling with discarded values, void
output, empty-source output, typed source failure after earlier pulls, and
completion of started pull finalizers. The IR wire shape remains version 2.

Draft 0.28 concurrent stream mapping, October 18, 2026
mapEffect and flatMapStreams accept a third literal concurrency record with
a positive safe integer bound or "unbounded". The checker and independent IR
validator enforce the bound. The emitted target uses the corresponding
Stream.mapEffect and Stream.flatMap options. Strict target and runtime tests
confirm bounded active work, ordered mapEffect output, concurrent inner
streams, failure interruption, and completion of active finalizers. The
original two-argument sequential forms remain supported. The IR wire shape
remains version 2.

Draft 0.29 effectful stream predicates, October 18, 2026
filterEffectStream, takeWhileEffectStream, takeUntilEffectStream, and
dropWhileEffectStream accept inline boolean callbacks that may fail or use
services. The checker and independent IR validator combine source and
predicate channels in the deferred Stream type. Strict target and runtime
tests confirm filtering, inclusive and exclusive stopping, cessation of
predicate calls after the drop prefix, empty input, repeated consumption,
typed predicate failure, and completion of pull finalizers. The IR wire
shape remains version 2.

Draft 0.30 latest-inner stream switching, October 18, 2026
switchMapStreams accepts a source Stream and an inline pure callback that
constructs an inner Stream. The checker and independent IR validator combine
outer and inner deferred channels. Strict target and runtime tests confirm
deferred construction, interruption of superseded inners, latest-inner output,
source failure propagation, and completion of active finalizers. The IR wire
shape remains version 2.

Draft 0.31 typed stream recovery, October 18, 2026
catchStream accepts a source Stream and an inline pure error callback that
constructs a replacement Stream. The checker and independent IR validator
remove handled source failures and retain replacement failures and both
service sets. Strict target and runtime tests confirm deferred construction,
earlier values retained before recovery, repeated consumption, replacement
failure propagation, and completion of started pull finalizers. The compiler
gate passed: 1067 fast tests and 82 slow tests. The IR wire shape remains
version 2.

Draft 0.32 scheduled stream retry, October 18, 2026
retryStream accepts a source Stream and a compatible RetrySchedule value.
The checker and independent IR validator retain source channels and reject
incompatible nominal failure types. Strict target and runtime tests confirm
deferred construction, replay of prior values after retry, schedule reset
after the first new output, repeated consumption, and completion of pull
finalizers. The compiler gate passed with 83 slow tests. The IR wire shape
remains version 2.

Draft 0.33 temporal stream controls, October 18, 2026
debounceStream accepts a nonnegative literal delay. throttleStream accepts
positive literal token units and duration with shape or enforce strategy.
The checker and independent IR validator retain source channels and reject
invalid settings. Strict target and runtime tests confirm deferred
construction, burst coalescing, enforced drops, shaped delivery, typed source
failure, and pull finalizers. A source checker test accepts compositions for
runForEach, runCount, tap, and runForEachWhile without new prelude forms. The
compiler gate passed with 84 slow tests. The IR wire shape remains version 2.

Draft 0.34 explicit shared scopes, October 18, 2026
CloseableScope and makeScope/provideScope/addScopeFinalizer/closeScope supply
manual shared authority across root executions and source modules. The checker
and independent validator retain argument-construction channels, discharge only
latent Scope requirements during provision, and preserve borrow/data-only rules.
Strict target and runtime tests cover aliases, cached close completion and defect
replay, interruption, late registration, registration-time service capture,
argument order, child-owned provider lifetime, and host-wrapper compatibility.
Close supplies Exit.void; arbitrary close Exits remain deferred. The compiler
gate passed: 1080 fast tests and 89 slow tests. All 17 Scope audit probes pass.
The site passes its 11 tests and 30 strict illustrative units. The IR wire shape
remains version 2.

Draft 0.35 Sink leftovers and synchronous transduction, October 18, 2026
Sink appends a fifth leftover argument, defaulting to never without changing
existing positions, default IR payloads, or interface hashes. takeSink requires
an expected input type and a positive integer literal count. transduceStream
replays leftovers compatible with sink input and retains source/sink deferred
channels separately from construction effects. runStream discards any leftovers.
Checker and independent validator tests cover variance, imports, recursion,
invalid counts, forged annotations, and active/deferred channel mutations.
Four strict target/runtime tests verify chunk replay, repeated state, final
partial/empty results, zero-progress host sinks, service provision, failures,
defects, yielding cleanup, interruption, and the existing typed host boundary.
The compiler gate passed: 1088 fast tests and 93 slow tests. All 17 focused
Sink/Stream/Schedule audit probes pass, including nine Sink contract tests.
The site passes 11 tests and 30 strict illustrative units. The IR wire shape
remains version 2. Async aggregation and broader package imports remain deferred.

Draft 0.36 live keyed grouping, October 18, 2026
mapGroups fuses one keyed producer with concurrent callbacks whose group Stream
is borrowed for at most one direct terminal use. The key is a pure primitive
class or primitive brand. Positive literal bufferSize bounds each group queue;
it does not cap the number of keys or consumers. The callback returns data
only, and only its Scope requirement is discharged. Source requirements remain
deferred. The checker and independent IR validator enforce these rules,
including forged binding, key, capacity, result, and channel mutations.
Four strict target/runtime tests cover fresh routing, per-key order, closed-key
discard, online later-key results, backpressure, provider rebinding, scoped
workers, source and consumer failure, interruption, and awaited cleanup.
The target prototype has nine passing probes. The IR wire shape remains
version 2. The compiler gate passed with 1,095 fast tests and 97 slow tests;
all 17 focused grouping and Stream/Schedule probes pass. The site passes its
11 tests and 30 strict illustrative units. Async aggregation and broader
package imports remain deferred.

Draft 0.37 untimed async aggregation, October 18, 2026
aggregateStream(source, sink) emits Stream.aggregate with the target's
capacity-zero producer/sink handoff. Source elements and replayed Sink
leftovers must fit Sink input. Source and Sink failures and requirements remain
deferred; construction effects remain active. The checker, independent IR
validator, and typed emitter preserve the channels without casts. Strict
compiled-source tests cover single-chunk completion, repeated runs over several
chunk sizes, provider rebinding, source and Sink failure, blocked demand,
zero-progress host Sinks, and awaited pending-pull interruption. Rechunking
can alter output partitions under the target's Schedule.forever handoff, so
multi-chunk results are compared directly with the pinned target. The IR wire
shape remains version 2. The compiler gate passed with 1,098 fast tests and 99
slow tests; all 11 aggregation target probes and the source probe pass. The site
passes 11 tests and 30 strict illustrative units. Timed aggregation and general
Schedule values remain deferred; broader package interoperability remains
deferred by user request.

Draft 0.38 general Schedule values and timed aggregation, October 18, 2026
Schedule<O,I,E,R> records output, contravariant input, typed failure, and
service requirements. ScheduleInput, ScheduleMetadata, and ScheduleDecision
are structural source types. scheduleFromStep allocates state per execution
and preserves a distinct normal Done output; scheduleRecurs, scheduleSpaced,
and scheduleMap supply the first constructor and modifier set.
aggregateWithinStream requires source and leftovers to fit Sink input and
Option<SinkOutput> to fit Schedule input. Schedule failure and service
channels remain deferred in its Stream output. The checker, independent IR
validator, and emitter implement the rule with a typed Stream.aggregateWithin
call. Strict compiled-source tests cover repeated state, effectful factory
and map callbacks, completion failure, virtual-time partial flushing,
schedule stop before another upstream pull, and awaited source cleanup.
The IR wire shape remains version 2. The compiler gate passed with 1,100 fast
and 100 slow tests. Native max/min/concat composition, other Schedule
consumers, Schema composition, and package interoperability remain separate
work; package interoperability is deferred by user request.

Draft 0.39 binary Schedule composition, October 18, 2026
scheduleMax and scheduleMin run two comparable-input policies and output the
selected delay in milliseconds, including zero on normal completion.
scheduleConcat starts the right policy on the input that completed the left
and unions their output types. The result input is the narrower comparable
input; incomparable inputs remain outside the source subset until the language
defines general intersections. Both operands' typed failures and services
remain deferred, while argument construction effects remain active.
The checker, independent validator, and typed emitter cover all three forms.
Two pinned target tests verify normal completion and phase input. A compiled
source test verifies delay sequences, phase outputs, repeated fresh execution,
construction deferral, failure from either policy, and awaited upstream
cleanup during failed aggregation. The IR wire shape
remains version 2. The compiler gate passed with 1,102 fast and 101 slow tests.
The site passes 11 tests and 30 strict illustrative units.

Draft 0.40 Schema composition and guarded recursive records, October 18, 2026
Schema<D,E,RD,RE> keeps decode and encode service requirements separate.
Identity, array, required-record, Option transformation, and guarded-recursive
constructors build reusable Schema values without running a parser. The two
runners fail with reserved SchemaError and require only their direction's
services. A single data record may refer to itself beneath arrays; the emitter
uses Schema.suspend for each self reference. Direct and mutual cycles remain
invalid. The checker and independent validator enforce callback directions,
failure channels, self guards, and recorded requirements. A strict compiled
source test covers nested decode and encode, issue paths, error recovery,
defects, interruption, construction deferral, and repeated runs. The IR wire
shape remains version 2. The compiler gate passed with 1,102 fast and 104
slow tests. Optional and union Schema builders and source-authored issue trees
remain separate design work. Package interoperability stays deferred.

Draft 0.41 exact optional Schema fields, tagged unions, and issue trees, October 18, 2026
SchemaOptional<D,E,RD,RE> marks an exact optional struct field. schemaUnion
accepts record branches with one distinct literal tag that is unchanged in
both directions. schemaInvalid, schemaAt, and schemaBoth build source issue
trees; schemaTransform callbacks may fail only with SchemaIssue, and runners
continue to fail with SchemaError. A single recursive alias can now terminate
through an omitted optional key or a terminal tagged variant. The checker,
independent validator, and typed emitter enforce the selected rules. Seven
pinned target tests and a compiled source witness cover missing, present,
and undefined fields, branch effects, separate services, authored decode and
encode issues, finite recursion, repeated execution, defects, and interruption.
Negative source probes and independent IR mutations reject malformed branches,
forged optionality, and unguarded recursion. The IR wire shape remains version 2.
The compiler gate passed with 1,102 fast and 106 slow tests. The site passes
11 tests and 30 strict illustrative units. General union backtracking and
optional-field transformations remain separate work. Package interoperability
stays deferred.

Draft 0.42 optional Schema transformations and defaults, October 19, 2026
SchemaEncodedOptional<D,E,RD,RE> marks a required decoded field whose encoded
key is exact optional. schemaOptionFromOptionalKey maps absent keys to a
required None and omits None on encode. schemaDefaultKey calls a pure
zero-argument decoded default on each missing-key decode and emits the field on
encode. schemaOptionalTransform maps Option values between two exact optional
field descriptors with pure inline directional callbacks. The checker and
independent validator track decoded and encoded optionality separately and
reject descriptors as runners, mismatched callbacks, and effectful defaults or
optional getters. Seven target tests, a compiled runtime witness, negative
source probes, and IR mutations cover the selected slice. The IR wire shape
remains version 2. General required-to-optional getters, effectful getters and
defaults, alternate encoding strategies, and general union backtracking need
separate rules. Package interoperability stays deferred.

Draft 0.43 effectful optional Schema callbacks, October 19, 2026
schemaOptionalTransform accepts effectful inline directional Option getters
whose only typed failure, if any, is SchemaIssue. Decode and encode
callback services stay in their respective directions. schemaDefaultKey
accepts an effectful zero-argument decoded default with decode-only services
and either SchemaIssue or SchemaError as its sole typed failure. An authored
SchemaIssue is wrapped as SchemaError at the emitted default boundary; an
existing SchemaError passes through. Five pinned target tests, strict
compiled source execution, negative source probes, and independent IR
mutations cover missing and present keys, repeated defaults, separate
services, issue paths, defects, and interruption. The IR wire shape remains
version 2. Required-to-optional transformations and general union
backtracking remain separate work. Package interoperability stays deferred.

Draft 0.43 code showcase, October 19, 2026
The mini book now pairs Effektive and Effect-TS code for scoped child work,
scheduled stream batches, and effectful optional Schema getters and defaults.
The full effektive-examples/core1.eff source has zero compiler diagnostics,
zero independent IR diagnostics, and strict checks of emitted TypeScript
against effect@4.0.5. The site's 33 illustrative Effect-TS units pass strict
checks, with no Effektive panel missing a translation. The site's 11 tests
pass. These checks do not establish runtime equivalence for the illustrative
tabs; the compiler runtime fixtures and target probes cover the selected
behaviors separately.

Draft 0.44 guarded required-to-optional Schema fields, October 19, 2026
SchemaDecodedOptional<D,E,RD,RE> marks a struct field with an exact optional
decoded key and a required encoded key. schemaOptionalFromRequired accepts
pure or effectful inline directional getters that can fail only with
SchemaIssue. It guards missing encoded keys before calling the source getter.
Three pinned target tests expose the raw Effect 4.0.5 type/runtime mismatch
and verify the guarded behavior and directional services. Two source-boundary
tests and a compiled runtime/IR witness cover omission, restoration, exact
undefined rejection, issue paths, callback requirements, defects, and
interruption. The IR wire shape stays version 2. General Schema union
backtracking remains the next bounded gap; package interoperability stays
deferred.

Draft 0.44 code showcase, October 19, 2026
The Core 1 mini book adds a fourth Effektive/Effect-TS pair for a required
encoded name that can decode to an absent field. The full
public/effektive-examples/core1.eff source builds with zero compiler and
independent validator diagnostics and strict emitted TypeScript checking.
The site's 34 illustrative Effect-TS units pass strict type checking with
zero Effektive panels missing a translation. The site's 11 tests pass.
Illustrative tabs are manually authored; selected runtime behavior has
separate pinned target and compiled source witnesses.

Draft 0.45 general Schema unions, October 19, 2026
schemaUnion now accepts an inline list of at least two ordinary Schemas,
including unlike types, overlapping records, duplicate types, and transformed
branches. It retains source branch order and derives each direction's data
and service requirements independently. Four pinned target tests and a strict
compiled source witness cover primitive branches, overlapping-record order,
transformed encoded/decoded types, decode and encode fallback after a typed
Schema issue, separate services, defects, and interruption. Source boundaries
reject malformed input and field descriptors. Independent IR mutations reject
forged branch types. Recursive callbacks retain the tagged-terminal guard:
source and IR probes reject a union that immediately tries its own self Schema.
The existing version 2 union IR operation needs no new shape. The compiler
check passed with 1,102 fast tests and 114 slow tests. Nullable optional keys
remain the next bounded Schema gap; package interoperability stays deferred.

Draft 0.45 code showcase, October 19, 2026
The fifth Core 1 pair shows unlike scalar branches and a service-backed name
transformation that can fall through to a plain string branch. The full
public/effektive-examples/core1.eff source builds with zero compiler and
independent validator diagnostics and strict emitted TypeScript checking.
All 35 illustrative Effect-TS units pass strict checking, with zero Effektive
panels missing a translation. The site's 11 tests pass. Illustrative tabs
remain manually authored and have separate runtime evidence for the selected
behaviors.

Draft 0.46 nullable optional fields and null data, October 19, 2026
The source singleton null value and type support nullable data aliases,
finite literal matches, and comparisons with null. Primitive-position rules
still apply through aliases such as type Nil = null. Inference retains the
singleton. Null data is distinct from unit, arithmetic operands, and grouping
keys. The backend emits Schema.Null, because Effect 4.0.5's literal Schema
constructors do not accept null.

Existing optional-key composition preserves a present null. The new
schemaNullToMissingKey constructor accepts an ordinary Schema whose decoded
and encoded sides exclude null. Its exact optional decoded field excludes
null; its encoded field admits null and maps it to an absent key. Missing
keys stay absent and explicit undefined fails. Directional services stay in
the static type, while missing or null inputs skip the nonnullable branch.
Option-from-optional-key retains None versus Some(null), and a missing-key
default does not run for a present null. Four pinned target tests, source
boundaries, strict compiled execution, and IR mutations cover these rules.
The version 2 IR adds a null expression leaf and the null-to-missing-key
Schema operation; the original literal with value null remains the unit
marker. The compiler check passed with 1,105 fast tests and 116 slow tests.

Draft 0.46 code showcase, October 19, 2026
The sixth Core 1 pair shows preserving null and treating it as an absent key,
with distinct source values for a missing field and a present null. The full
public/effektive-examples/core1.eff source builds with zero compiler and
independent validator diagnostics and strict emitted TypeScript checking.
All 36 illustrative Effect-TS units pass strict checking, with zero Effektive
panels missing a translation. The site's 11 tests pass. Alternate default
encoding strategies are next; broader package interoperability stays deferred.

Draft 0.47 default encoding strategies, October 19, 2026
schemaDefaultKey accepts an optional third inline record with one literal
encodingStrategy field: "passthrough" or "omit". The two-argument form stays
passthrough. Both strategies retain required decoded and exact optional
encoded fields and the same directional service requirements. Missing-key
decoding and default callback failure rules are unchanged. Omit drops every
valid value, including non-default and nullable values, skips the wrapped
encoder and its services, and never evaluates or compares with a default on
encode. Present decoded values still validate. Static encoder requirements
remain conservative, matching Effect 4.0.5.

Four pinned target tests, source acceptance and rejection tests, strict
compiled execution, and independent IR mutations cover omission, explicit
and implicit passthrough, repeated defaults, skipped encoder calls, retained
validation, authored issues, and defects. Unknown strategies and erased
static encoder requirements fail independent validation. The existing
version 2 default-key Schema operation accepts two or three argument
expressions; no new type or field descriptor is needed. The compiler check
passed with 1,107 fast tests and 118 slow tests.

Draft 0.47 code showcase, October 19, 2026
The seventh Core 1 pair shows unconditional omission versus passthrough for a
defaulted name. The full public/effektive-examples/core1.eff source builds
with zero compiler and independent validator diagnostics and strict emitted
TypeScript checking. All 37 illustrative Effect-TS units pass strict checking,
with zero Effektive panels missing a translation. The site's 11 tests pass.
Defaults for missing-or-null keys are next; broader package interoperability
stays deferred.

Draft 0.48 defaults for missing or null keys, October 19, 2026
schemaDefaultNullKey accepts a nonnullable ordinary Schema, an inline decoded
default callback, and the existing optional literal encodingStrategy record.
It returns a required nonnullable decoded field and an exact optional encoded
field that admits null. Each missing-or-null decode runs a fresh default;
present values run the wrapped decoder instead. Explicit undefined and invalid
values fail without running the default. Passthrough runs the encoder; omit
drops every valid value while retaining static encoder requirements. Neither
strategy evaluates the default on encode. Services and callback failures follow
the existing directional default rule, including SchemaIssue and SchemaError
paths, defects, and awaited interruption cleanup.

Five Effect 4.0.5 target probes, source boundary checks, independent IR mutations,
and a strict compiled runtime witness cover the selected contract. A raw target
unit probe additionally confirms that the getter preserves Some(undefined)
rather than treating it as absent; unit remains outside source Schema data.
Version 2 IR adds the default-null-key Schema operation with two or three
arguments and uses the existing encoded-only optional descriptor. The full
compiler check passed with 1,110 fast tests and 119 slow tests on Deno 2.9.7.

Draft 0.48 code showcase, October 19, 2026
The eighth Core 1 pair shows missing and null names receiving the same required
decoded default. The full public/effektive-examples/core1.eff source builds with
zero compiler and independent validator diagnostics and strict emitted
TypeScript checking. All 38 illustrative Effect-TS units pass strict checking,
with zero Effektive panels missing a translation. The site's 11 tests pass.
Encoded-value defaults are next; broader package interoperability stays deferred.

Draft 0.49 encoded-value defaults, October 19, 2026
schemaDefaultEncodedKey accepts an ordinary Schema, an inline zero-argument
encoded-value callback, and the existing literal encodingStrategy options.
The decoded field remains required and the encoded field becomes exact optional.
Missing-key decoding generates E, validates it, and runs the wrapped decoder to
produce D. Present values skip the default, including null where E admits null.
Invalid present values and explicit undefined fail without running the default.
Default services join decode requirements; callbacks may have no typed failure,
exactly SchemaIssue, or exactly SchemaError. Encoding uses only encoder services.

Under omit, encoded defaults still run the encoder and validate its E before
discarding the successful result. Encoder failures, defects and interruption
cleanup remain observable. Decoded-default omission skips that encoder instead;
this distinction selects the new reusable field constructor. Passthrough writes
the encoded result. Neither encoding strategy evaluates the default.

Six pinned Effect 4.0.5 target tests, source acceptance and rejection cases,
independent IR mutations, and strict compiled execution cover fresh defaults,
wrapped decoding, exact presence, nullable values, refined E validation,
directional services, issue paths, omitted encoder work, and awaited cleanup
in default generation, decoding and encoding. Version 2 IR adds the
default-encoded-key operation with two or three arguments and no new type.
The existing TypeScript descriptor leaves its intermediate encoding unknown
while preserving precise public decoded and encoded types and service channels.
The full compiler check passes with 1,113 fast tests and 120 slow tests on
Deno 2.9.7.

Draft 0.49 code showcase, October 19, 2026
The ninth Core 1 pair shows an encoded text default passing through a
service-backed integer decoder, and explains why omission still calls the
encoder. The full public/effektive-examples/core1.eff source builds with zero
compiler and independent validator diagnostics and strict emitted TypeScript
checking. All 39 illustrative Effect-TS units pass strict checking, with zero
Effektive panels missing a translation. The site's 11 tests pass. Schema
construction defaults are next; broader package interoperability stays deferred.

Draft 0.50 type-side construction and explicit defaults, October 19, 2026
schemaMake validates a complete decoded D through Schema.makeEffect and fails
with structured SchemaIssue. It runs neither wire decoder nor encoder and
requires neither RD nor RE; active effects needed to evaluate its Schema and
input arguments still propagate in source order. Field descriptors, incomplete
records, encoded-only values and unknown inputs are rejected. Ordinary source
factories supply their own optional input types and fill defaults before making
a complete D, preserving the original decoded and wire field contracts.

SchemaIssue catches and error matches use predicate dispatch for Effect's
multi-variant issue family. Nested factories can catch a child issue and attach
the parent path with schemaAt. A mixed catch clause cannot recatch errors raised
by one of its own handlers. Version 2 IR adds the schema-make runner with schema
and input children; no Schema type parameter or field-presence flag is added.

Six pinned target tests distinguish construction from decoding and encoding,
compare selected explicit default factories, preserve structured issue paths,
and record nested make-input shapes and raw constructor replay aliasing.
Three fast tests and one strict compiled runtime witness cover source contracts,
independent IR mutations, nested factory paths, wire-service independence,
active argument effects and order, defects, and mixed issue catches and matches.
The full compiler gate passes with 1,116 fast tests and 121 slow tests on
Deno 2.9.7.

Draft 0.50 code showcase, October 19, 2026
The tenth Core 1 pair fills a missing score in a source factory, then validates
the complete decoded record with schemaMake. The full core1.eff source builds
with zero compiler and independent validator diagnostics and strict emitted
TypeScript checking. All 40 illustrative Effect-TS units pass strict checking,
with zero missing translations. The site's 11 tests pass. Native constructor
metadata and a make-input shape distinct from both D and E remain open, including
raw replay identity; the explicit factory does not promise that aliasing.
General constructor metadata and make-input propagation are next. Broader
package interoperability remains deferred by user instruction.

Draft 0.51 constructor metadata and make-input propagation, October 19, 2026
Schema adds a fifth parameter M defaulting to D. M records constructor input
independently of decoded D and encoded E. SchemaConstructorDefault and the
schemaConstructorDefault builder attach an inline zero-argument default that
returns M, uses no services, and may fail only with SchemaIssue. The containing
struct makes that field optional in M while D, E and both wire service directions
stay unchanged. Known default flags and changed make-input shapes are invariant
and cannot be silently erased by an older Schema annotation.

Make input propagates through nonrecursive structs, arrays, ordered unions,
optional keys, and transformation targets. Nested defaults can supply partial
make records and validate with complete field paths. schemaMake accepts M and
constructs D without wire services. Defaults are deferred, run freshly on each
use, and retain failure, defect, cancellation and cleanup behavior. Raw host
makeEffect replay preserves the target's shared result identity. Source function
evaluation rules are unchanged. Changed M is explicitly rejected by recursive
Schema builders and optional adapters whose constructor behavior remains unprobed.

Version 2 IR adds optional makeInput and constructorDefault Schema properties
and the constructor-default operation. Missing makeInput means D. Alias/import
handling, type depth checks and independent validation include the new axis.
Emission uses public Schema.make to restore checked make views, then native
withConstructorDefault; it uses no casts or private target APIs.

Four target tests and a strict compiled witness cover nested defaults, arrays,
unions, optional fields, transformation targets, cross-module composition,
static D/E/M separation, Ref-capturing defaults, raw replay identity, constructor
failure paths, and awaited cancellation cleanup. Source and independent IR tests
reject erasure, duplicate defaults, bad callbacks, services, descriptor runners,
unsupported adapters, and forged metadata. The full compiler gate passes with
1,119 fast tests and 122 slow tests on Deno 2.9.7.

Draft 0.51 code showcase, October 19, 2026
The eleventh Core 1 pair shows reusable constructor defaults, nested partial
make input and array propagation. The full core1.eff source builds with zero
compiler and independent validator diagnostics and strict emitted TypeScript
checking. All 41 illustrative Effect-TS units pass strict checking, with zero
missing translations. The site's 11 tests pass. Constructor metadata through
optional adapters is next, followed by recursive make-input propagation.
Broader package interoperability remains deferred by user instruction.

Draft 0.52 optional-adapter constructor inputs, October 19, 2026
All existing optional Schema adapters now accept distinct constructor make inputs.
Null-as-missing and decoding-default adapters retain wrapped M. Optional
transformations, including required-encoded fields, use the decoded target's M.
Source make inputs do not enter that target shape. D/E, directional wire services,
callback contracts, and encoding strategies retain their existing meanings.

Decoding defaults leave constructor fields required and do not execute during
schemaMake. Present partial nested inputs run their constructor defaults instead.
Decoded/encoded fallback callbacks still return complete D/E. Null-as-missing
remains a wire policy. Option fields explicitly require complete Option<D>,
without nested constructor defaults, and remain required during construction.
The independent validator recomputes each adapter's M; emission restores changed
make views through public Schema.make, with no new IR operations or casts.

Three pinned target tests cover default strategies, nested construction, skipped
wire callbacks, and Option's complete-data boundary. Source and independent IR
tests reject erased and forged M, missing constructor fields, partial Option
contents, and partial wire defaults. Strict compiled execution covers every
adapter, imported descriptors, target selection, nested issue paths, and wire
effect traces. The compiler gate passes with 1,122 fast tests and 123 slow tests
on Deno 2.9.7.

Draft 0.52 code showcase, October 19, 2026
The twelfth Core 1 pair contrasts a wire default with a nested constructor
default and shows null-as-missing retaining a partial make input. The full
core1.eff source builds with zero compiler and independent validator diagnostics
and strict emitted TypeScript checking. All 42 illustrative Effect-TS units pass
strict checking, with zero missing translations. The site's 11 tests pass after
regenerating asset links for the existing package version. Recursive make-input
propagation is next. Broader package interoperability remains deferred by user
instruction.

Draft 0.53 recursive constructor inputs, October 19, 2026
schemaRecursive now retains a distinct recursive make input M in its expected
Schema, callback signature, and every guarded self reference. D/E remain equal.
M is data-only and follows its own existing finite-data guard. Structs, arrays,
optional keys, terminal tagged unions, and constructor-default wrappers compose
that input. Constructor wrappers preserve a guard; they do not create one.
Default callbacks cannot capture or invoke self. Capture checks follow binding
identities, so an unrelated local named self remains valid. Self-free checked
Schema leaves may include inline transformations.

Nested partial input constructs complete decoded trees, chains and tagged values.
Defaults run freshly for each missing field without wire services. Wire decode
and encode keep complete data and their directional services. Recursive issue
paths include fields and array indices; defects retain their channel, and
interruption awaits nested default cleanup. The existing typed Schema.suspend
and composite make views retain M without new IR operations, casts, or emitter
helpers. Finite data guards do not prove termination of user default effects or
defaults that continue generating more constructor input.

Three pinned target probes cover all three guards, fresh defaults, complete
wire data, nested validation and interruption cleanup. Source and independent IR
checks reject make-input erasure, wrong self signatures, missing metadata,
unguarded recursion, invalid nested values, and default callbacks that capture
self. Strict compiled execution adds imported arrays and outer defaults, wire
service traces, default failures, defects, and awaited nested cleanup. The full
compiler gate passes with 1,125 fast tests and 124 slow tests on Deno 2.9.7.

Draft 0.53 code showcase, October 19, 2026
The thirteenth Core 1 pair constructs a recursive tree from partial inputs at
multiple levels. The full core1.eff source builds with zero compiler and
independent validator diagnostics and strict emitted TypeScript checking.
All 43 illustrative Effect-TS units pass strict checking, with zero missing
translations. The site's 11 tests pass. Distinct recursive decoded and encoded
representations are the next investigation. Broader package interoperability,
item 9, remains deferred by user instruction.

Draft 0.54 separate recursive wire types, October 19, 2026
schemaRecursive now accepts distinct decoded D and encoded E while retaining
independent make input M and directional RD/RE. Each recursive data alias follows
its existing guard. The pure inline builder and every self reference retain the
same full Schema signature, and the body must fit all axes. Only the old D=E
restriction is removed; identity schema() still requires D=E and no services.

Recursive wire fields may differ in value type and exact optional presence.
Array, optional-key and tagged forms are supported. Tagged recursion retains
matching literal discriminators on both sides and a self-free terminal branch.
Decode returns D using RD, encode consumes D and returns E using RE, and make
consumes decoded-side M without either wire service direction. Wire defaults
still do not supply constructor keys. Nested wire failures keep field and array
index paths in both directions; defects stay defects, and interruption awaits
nested decoder or encoder cleanup. The existing version 2 Schema and typed
Schema.suspend preserve all axes without new IR operations or emitter helpers.

Three pinned target probes cover the separate D/E/M shapes, optional wire
presence, all three guards, roundtrips, failures and nested cleanup. Source and
independent IR checks reject erased or forged encoded types, incorrect self
signatures, invalid nested wire or make data, forged directional services, and
identity derivation for distinct D/E. Strict compiled execution adds imported
arrays, constructor defaults, repeated runs, separate service traces, nested
wire failures and defects, and awaited cleanup in both wire directions. The
compiler gate passes with 1,128 fast tests and 125 slow tests on Deno 2.9.7.

Draft 0.54 code showcase, October 19, 2026
The fourteenth Core 1 pair keeps numeric decoded trees, text wire trees, and
partial numeric make input separate through every self reference. The full
core1.eff source builds with zero compiler and independent validator diagnostics
and strict emitted TypeScript checking. All 44 illustrative Effect-TS units pass
strict checking, with zero missing translations. The site's 11 tests pass.
Constructor-default composition with field descriptors is next. Broader package
interoperability, item 9, remains deferred by user instruction.

Draft 0.55 constructor defaults on field descriptors, October 19, 2026
schemaConstructorDefault now decorates SchemaOptional, SchemaEncodedOptional,
and SchemaDecodedOptional fields while retaining D/E/M, presence flags and
wire service channels. The explicit combined types are
SchemaOptionalConstructorDefault, SchemaEncodedOptionalConstructorDefault and
SchemaDecodedOptionalConstructorDefault, each with the existing five arguments.
All flags remain invariant through annotations and imports. The containing
struct makes the key optional in M; D and E keep their original presence.

The inline zero-argument callback returns wrapped M, has no services and may
fail only with SchemaIssue. Nested defaults may return partial M; Option fields
still require complete Option<D> contents. Missing or raw undefined make input
runs a fresh callback, while present values skip it and null stays present.
Source types still reject explicit undefined. Wire defaults and getters skip
construction; constructor defaults skip decode and encode. Encoding strategies,
service requirements, issue paths, defects and awaited cleanup are unchanged.
Apply field adapters first and constructor defaults last. Duplicate defaults,
descriptor runners and subsequent adapters remain errors.

Version 2 IR permits constructorDefault alongside one of the three mutually
exclusive presence flags, with no new fields or operations. Public emitted types
use native Schema.withConstructorDefault around the restored no-default view,
matching the wrapper without requiring its input adapter's helper properties.
Emission uses public Schema.make and withConstructorDefault without casts or
private APIs. The editor grammar recognizes the three combined type names.

Four pinned target probes cover every selected adapter, nested partial inputs,
unchanged presence, independent wire defaults, Option contents, failure paths
and awaited cleanup. Source and independent IR checks reject erased or forged
flags, duplicate defaults, descriptor runners, subsequent adapters, callback
services and partial Option defaults. Strict compiled execution adds imported
descriptors, all three presence forms, separate wire traces and encoding omission,
fresh callbacks, failures, defects and awaited cleanup. The compiler gate passes
with 1,131 fast tests and 126 slow tests on Deno 2.9.7.

Draft 0.55 code showcase, October 19, 2026
The fifteenth Core 1 pair supplies 4 during construction and 8 when decoding a
missing wire field, and shows an optional decoded field retaining its presence
rule after gaining a constructor default. The full core1.eff source builds with
zero compiler and independent validator diagnostics and strict emitted TypeScript
checking. All 45 illustrative Effect-TS units pass strict checking, with zero
missing translations. The site's 11 tests pass. Applying field adapters after
constructor defaults is next. Broader package interoperability, item 9, remains
deferred by user instruction.

Draft 0.56 field adapters after constructor defaults, October 19, 2026
Unary presence and wire-default builders now accept SchemaConstructorDefault
while retaining their existing input-presence restrictions. schemaOptionalKey,
schemaNullToMissingKey, schemaDefaultKey, schemaDefaultNullKey and
schemaDefaultEncodedKey retain the input's root default and M. Optional bridges
also accept decorated optional positions, and the required source of
schemaOptionalFromRequired may carry a constructor default. Both bridges select
only the decoded target's default and M; source defaults do not become result
defaults. Wire getters and constructor defaults remain independent.

schemaOptionFromOptionalKey explicitly resets the root default and produces
required Option<D> constructor input, with complete D inside Some. A missing
constructor key fails after that reset. A new Option-valued default can then be
attached; a second default remains an error after an adapter that retained it.
Assignment flags stay invariant. Incompatible input presence, descriptor runners,
arrays, unions and arbitrary self-bearing adapter paths remain rejected.

No syntax, type names, IR fields or operations are added. The checker and
independent validator recompute retained, target-selected and reset flags.
Emitted field types use structural Schema.Codec views with checked make input,
decoded and encoded optionality, and constructor-default metadata. Public
Schema.make restores the view from each composed AST without relying on any
particular adapter's helper properties. It evaluates each Schema argument once
and uses no casts, private APIs or extra runtime helpers. Native callback timing,
service directions, encoding strategies, failure paths, defects and awaited
cleanup are retained.

Three pinned target probes cover retained unary defaults, wire independence and
encoding strategies, target-only bridge defaults, and Option reset and renewed
defaults. Source and linked IR mutations reject false flags, lost retained
defaults, duplicate defaults, incompatible presence and incomplete Option data.
Strict compiled execution adds imported target defaults, nested partial M,
precise public flags, wire traces, omission, fresh defaults, failures, defects and
awaited cleanup. The compiler gate passes with 1,134 fast tests and 127 slow tests
on Deno 2.9.7.

Draft 0.56 code showcase, October 19, 2026
The sixteenth Core 1 pair applies a wire-default adapter after a constructor
default and contrasts that retained default with Option adaptation's explicit
reset. The full core1.eff source builds with zero compiler and independent
validator diagnostics and strict emitted TypeScript checking. All 46 illustrative
Effect-TS units pass strict checking, with zero missing translations. The site's
11 tests pass. Guarded recursive self use through field adapters is next. Broader
package interoperability, item 9, remains deferred by user instruction.

Draft 0.57 guarded recursive field adapters, October 19, 2026
schemaRecursive now follows guarded self through schemaDefaultKey,
schemaDefaultNullKey, schemaDefaultEncodedKey, schemaOptionalTransform and
schemaOptionalFromRequired. Defaults traverse their wrapped Schema only.
Bridges traverse their source and target Schema arguments. Default callbacks,
both directional getters, and options cannot capture self. Capture checks use
binding identity and reject discarded captures. Source calls must resolve to
actual builtins; a shadowed name does not prove a structural guard.

schemaNullToMissingKey supplies an optional-key guard. Unions beneath an
established array, optional-key or terminal-tagged data guard retain that guard
through every member. This permits exact optional nullable recursive wire links.
Unguarded nested unions still fail. Each D/E/M alias keeps an independent guard,
and root unions still need distinct literal tags and a self-free terminal branch.
Recursive Option data, arbitrary self-bearing ordinary transformations, mutual
recursion and arbitrary AST construction remain outside this slice.

No syntax, type names, IR properties or emission paths are added. Independent
validation preserves named recursive identity before unfolding a matching union
member. Imported recursive aliases use the same guard rules and stay distinct.
Construction retains target M and defaults, skips wire getters, and needs no
wire services. Decode and encode retain directional services, encoding
strategies, nested paths, defects and awaited cleanup.

Three pinned Effect 4.0.5 probes cover recursive wire defaults, nullable links
and optional bridges. Source and independent IR boundaries reject callback
captures, wrong axes, unsupported self paths and unguarded aliases. Strict
compiled execution covers every new adapter, nullable imports, distinct recursive
aliases, nested partial M, target-only bridge construction, required wire guards,
wire services, encoded omission with retained encoder work, repeated defaults,
failures, defects and awaited cleanup on interruption. The compiler gate passes
with 1,137 fast tests and 128 slow tests on Deno 2.9.7.

Draft 0.57 code showcase, October 19, 2026
The seventeenth Core 1 pair carries a recursive array through constructor and
wire-default adapters. Construction fills nested partial input with constructor
defaults. Wire decoding uses a separate decoded default and requires score.
The full core1.eff source builds with zero compiler and independent validator
diagnostics and strict emitted TypeScript checking. All 47 illustrative
Effect-TS units pass strict checking, with zero missing translations. The site's
11 tests pass. Recursive Option data is next. Broader package interoperability,
item 9, remains deferred by user instruction.


Accepted application acceptance rule, October 19, 2026
The user accepted an application-based stopping rule after draft 0.57. Three
complete applications must compile with precise contracts and pass failure,
cancellation, and cleanup checks: a service workflow, a scheduled worker, and
a stream processor. Application orchestration stays in Effektive. Typed host
adapters may supply drivers and the runtime entry point. All three application
gates are pending; existing operator tests and adapter probes do not complete them.

The scheduled worker baseline and general Schedule consumers lead the next
investigation. New features require a demonstrated application blocker after
checking equivalent existing source compositions. Time control and user generics
are subsequent candidates, not mandatory additions. This decision supersedes
the earlier statement that recursive Option data is next. Further Schema
expansion has no automatic priority. Broader package interoperability, item 9,
remains deferred. This decision changes no language form, runtime behavior,
compiler implementation, or checked code example.

The compiler documentation commit passes deno task check on Deno 2.9.7:
1,137 fast tests and 128 slow tests. The site passes 11 tests and strict checking
of all 47 illustrative Effect-TS units, with zero missing translations. These
checks preserve the existing implementation baseline; application gates remain
pending.


Scheduled-worker application gate, October 19, 2026
The scheduled worker now passes the accepted application gate with existing
Effektive forms. Source owns policy validation, repetition, transient retry
selection, progress and per-attempt resource release. The driver supplies
recording in-memory job operations and primitive waits. The runtime entry point
supplies whole-worker interruption for shutdown. No new language form, builtin,
IR operation or compiler behavior is selected.

Policy fields are safe nonnegative integers. Validation precedes even the
zero-job branch. runs counts successful jobs; retries counts additional attempts
per job. The first job starts immediately. Each acquired attempt finishes release
before a retry or a repetition delay starts. A single nominal JobFailure retains
a Transient or Fatal kind field; source retries only Transient. Each job receives
a fresh retry budget. Replaying the same returned Effect resets progress.

The source checks enforce result, failure and service contracts and retain
separate diagnostics for opaque general Schedule retry and repetition consumers.
Those API gaps remain open. A concrete source-authored policy is sufficient for
this application. The native reference comparison covers the selected fixed
policy, timing and results, not all opaque Schedule behavior.

Nine compiled runtime checks cover matching virtual-time job starts at 0, 5, 25
and 30 milliseconds, Effect replay, zero work, validation precedence, zero
retries, exhaustion, permanent failure, acquisition failure, execution and release
defects, and cancellation during work, repetition waits and native retry waits.
A blocked release holds interruption pending and prevents a later attempt.
Assertions that inspect blocked release always open their release gate, including
on assertion failure. The native clock observer forwards time reads and replaces
sleep with a synchronized pending operation for the retry cancellation check.

The compiler gate passes with 1,140 fast tests and 129 slow tests on Deno 2.9.7.
The site passes 11 tests and strict checking of all 47 existing illustrative
Effect-TS units, with zero missing translations. A fresh copy of the downloadable
application builds with zero diagnostics, passes independent IR and strict
emitted TypeScript checks, passes its nine runtime cases, and runs its entry
point to completion. Its explicit checks.ts file runs after compilation.

One of the three application gates is complete. The service workflow and stream
processor remain pending; the service workflow baseline is next. The driver
performs no external I/O, so this establishes no external integration coverage.
Gap item 9 remains deferred by user instruction. The language edition stays
at draft 0.57 because this application adds no source forms.


Service workflow application gate, October 19, 2026
The service workflow now passes the accepted application gate with existing
Effektive forms. Source validates unknown input, applies business rules,
obtains a catalog price, calculates a bounded integer total and selects
transient storage retries. Its exported contract retains SchemaError,
InvalidOrder, CatalogFailure and StoreFailure, plus Catalog.price and
Runtime.database requirements. The registered provider discharges Store.save.

The typed StoreLive adapter owns one atomic save through the pinned native
SqlClient transaction wrapper. It uses a parameterized insert and validates
receipt rows before commit. Statement-local classification makes only
retryable body failures Transient. Provider, lease, BEGIN and COMMIT failures
remain Permanent, including misleading COMMIT operation metadata. Cause.map
inside catchCause preserves cleanup defects alongside typed failures; such
mixed causes prevent retry.

Fourteen compiled runtime cases cover successful commit, input and price
rejection, transient retry, exhaustion, permanent failure, provider and lease
failure, BEGIN failure, invalid receipt rows, COMMIT failure, execution and
cleanup defects, and cancellation. Virtual-time attempts occur at 0, 5 and 15
milliseconds. Replaying the same Effect starts a fresh workflow and retry budget
at 100, 105 and 115. Catalog and provider acquisition occur once per workflow.
Each failed attempt rolls back and releases before another lease.

Body interruption waits for blocked rollback or release and commits no staged
rows. Cancellation during either retry delay prevents a later transaction.
Interruption after COMMIT starts waits for commit and release; a committed row
can remain. The application does not promise rollback for every cancellation
or exactly-once submission.

The compiler gate passes deno task check on Deno 2.9.7: 1,142 fast tests and
130 slow tests. The application harness checks linked IR, strict emitted
TypeScript and registered host assertions, runs fourteen runtime cases and
executes the standalone entry point. Negative source checks reject every
erased failure channel, retained service requirement and incorrect result.
Type-only imports in the recording drivers and native worker reference also
satisfy the repository lint gate without changing behavior.

The site passes eleven tests and strict checking of all 47 illustrative
Effect-TS units, with zero missing translations. A fresh copy of the public
service project builds two modules with zero diagnostics using --validate
--tsc, passes all fourteen checks.ts cases and runs main.ts. The entry point
returns the expected receipt, stores one committed row and leaves no active
connection. Published source, configuration and host files match the fixture;
runtime_test.ts is published as checks.ts and runs explicitly after compilation.

Two of three application gates are complete. The stream processor remains
pending and is next. The recording driver performs no external I/O and
recognizes one insert shape. Its simulated COMMIT error precedes committed-state
mutation, so that case proves no retry, not actual ambiguous-commit behavior.
These checks establish no external database integration or source transaction
callbacks. Gap item 9 remains deferred. The language edition stays at draft
0.57 because this application adds no source form.


Stream processor application gate, October 19, 2026
The stream processor now passes the accepted application gate with existing
Effektive forms. Source owns nested session brackets, live input pulls,
buffering, ordered concurrent mapping, selected fallbacks, batching and terminal
consumption. The recording driver supplies primitive operations only.
The source contract retains InputFailure, TransformFailure and OutputFailure,
plus all seven declared service operations. Source checks independently reject
erased failures, erased requirements and an incorrect result contract.

Thirteen compiled runtime cases cover deferred construction, ordered full and
partial batches, empty input, exact batch multiples, Effect replay, live arrivals,
out-of-order transformation completion, backpressure, recovery, failure,
acquisition errors, defects and awaited cancellation cleanup. Forced completion
order [2,1] preserves output order with at most two active transformations.
Normal input produces batches [1,2], [3,4] and [5]. Source suppresses native
transduction's empty terminal batch. Replaying the same Effect resets source
progress and opens fresh sessions.

The input buffer has capacity two and suspends production under backpressure.
With the first output blocked, scheduler quiescence leaves pull indices zero
through six. Repeated quiescence makes no further pull. Resumed demand consumes
all one hundred input items and reaches end-of-input. This pinned trace
includes work in progress and establishes no global memory bound.

Recoverable transformation failures become marked original-value fallbacks.
Recovery does not retry writes or restart input. Fatal transformations and
output failures cancel pending peer work before closing sessions. A later
input failure propagates while preserving earlier writes. Native transduction
can emit a partial batch before propagating its saved upstream failure.
The application promises no rollback or exactly-once delivery.

Input opens before output; output closes before input. Cancellation of pending
input or output waits for pipeline work and both session finalizers. The
checks block each finalizer separately and verify that interruption stays
pending. Gate release protects the entire shutdown handshake before either
child fiber starts. A separate temporary injected handshake defect returns
promptly instead of waiting forever on its blocked finalizer.
Execution and session cleanup defects remain defects, and remaining session
finalizers are attempted.

Item recovery follows the pinned native catchTags behavior. A direct mixed-cause
comparison confirms that a matching typed reason can hide an accompanying
defect from an arbitrary transformation cause. The normal primitive
transformation cleanup cannot fail. Session finalizers run outside item recovery.
These checks do not establish arbitrary mixed-cause preservation.

The compiler passes deno task check on Deno 2.9.7: 1,144 fast tests and 131
slow tests. The application harness validates linked IR, strictly checks emitted
TypeScript, runs thirteen runtime cases and executes the entry point.
The website passes eleven tests and strict checking of all 47 illustrative
Effect-TS units, with zero missing translations. A fresh downloadable project
builds two modules with zero diagnostics using --validate --tsc, passes all
thirteen checks.ts cases and runs main.ts with the expected three batches and
no active session. Its seven published application files match the fixture;
runtime_test.ts is published as checks.ts and runs explicitly after compilation.

All three accepted application gates are complete using existing language
forms. The language stopping rule is satisfied; no further automatic API
addition is selected. Editor, packaging, performance and external integration
acceptance remain separate work. The recording drivers perform no external I/O.
Broader package interoperability, item 9, remains deferred by user instruction.
The language edition stays at draft 0.57 because this application adds no form.


Remaining and deferred gap record, October 19, 2026
The gap audit now consolidates current open API and language boundaries,
item 9's explicit user deferral, runtime evidence limits and separate release
acceptance. The specification mirrors that record and the mini book links to it.
The accepted application target remains complete. This record selects no
implementation work, priority or schedule. A new blocker does not revoke
the user's explicit deferral of broader package interoperability.

The record distinguishes native mixed-cause recovery, transaction cancellation,
partial batches and buffering limits from absent source APIs. Editor, packaging,
performance and external integration acceptance remain separate work.
Historical validation entries retain their original dates and scope.

This documentation change adds no language form or compiler behavior.
The language edition remains draft 0.57. The compiler passes deno task check
on Deno 2.9.7: 1,144 fast tests and 131 slow tests. Documentation link audits
pass in both repositories. The website passes eleven tests and all 47 strict
illustrative Effect-TS checks, with zero missing translations.


Compiler hardening and application checks, October 20, 2026
The specification now explains how known literal fields select contextual
record-union constructors. Record matches require a wildcard when a selected
tag is absent, optional or open-ended. A binding keeps every member whose tag
can equal the literal at runtime, including primitive brand bases and unknown
tags. Nominal assignment and unknown compatibility retain their existing rules.
The new paired example constructs the second same-shape union member and
matches an open record union without discarding a possible Text payload.

The serialization requirements explicitly include sorted, unique Schema
decodeRequirements and encodeRequirements. Both the compiler serializer and
independent validator enforce these sets.

The downloadable worker and service checks now open cleanup gates around the
whole parent handshake and include injected assertion failures. Their deadline
harnesses also release gates before joining children. The worker has ten runtime
checks; the service workflow has fifteen. The stream suite now asserts the
exact pinned blocked-output pull trace [0, 1, 2, 3, 4, 5, 6], matching the
existing explanation, instead of a weaker range and a debugging print.
All three public checks.ts files match the compiler runtime_test.ts fixtures.

On Deno 2.9.7, the website passes deno task test (eleven tests) and deno task
typecheck (48 strict illustrative Effect-TS units, no missing translations).
The new Effektive example builds with --validate --tsc: one module and zero
diagnostics. Fresh copies of all three downloadable projects build with those
same options, pass their checks.ts suites (10 worker, 15 service, 13 stream)
and run main.ts to completion. The Markdown link audit passes.

The compiler also passes deno task check on Deno 2.9.7: formatting, lint,
type checking, 1,687 fast tests and 151 slow tests. This website update changes
no compiler code. Existing external integration and release-acceptance limits
remain in force. These corrections add no source forms, so the language
edition remains draft 0.57.

Chrome checks at widths 1280 and 390 confirm that both tabs of the new example
show one selected panel. The page has no horizontal overflow or uncaught
JavaScript exceptions. The local HTML link and anchor check passes 227 targets.


Extreme identifier formatting, October 20, 2026
The compiler resolves the six recorded exceptions for very long identifiers:
error type arguments, struct fields, function names, member accesses, service
bindings and parameter annotations. Related checks include optional fields,
brand and Schema constructors, zero-argument arrows and nested member reads.

A permanent regression checks 274 generated modules at wrapping boundaries.
Deno 2.9.7 leaves their emitted TypeScript unchanged. The modules pass strict
TypeScript checking and runtime checks. The test verifies source tokens after
new line breaks and confirms that an effectful member base runs exactly once.
A separate probe passes 567 comparisons for identifier lengths 30 through 110.
The width at which a line breaks depends on the surrounding code as well as
the identifier length.

The emitter retains source identifiers and records mappings during layout.
It does not run an external formatter. Later document groups are measured
again after every line break. The existing reduce fixture checks the combined
layout of a function type and callback. This change adds no source form.

The full compiler check passes on Deno 2.9.7: formatting, lint, type checking,
1,676 fast tests and 152 slow tests. The website passes eleven server tests
and all 48 strict illustrative Effect-TS check units, with no missing
translations. The website Markdown link audit passes.

Draft 0.58 language surface pruning, October 20, 2026
The compiler removes seven prelude names and keeps every behavior. The pure
stream predicates takeWhileStream, takeUntilStream, dropWhileStream and
filterStream, and the pure mapStream, are removed. The effect forms
takeWhileEffectStream, takeUntilEffectStream, dropWhileEffectStream,
filterEffectStream and mapEffect accept a callback that is pure with empty
failure and requirement sets. With such a callback, the checker records the
pure operation, so the general form compiles to Stream.takeWhile,
Stream.takeUntil, Stream.dropWhile, Stream.filter and Stream.map. A pure
predicate keeps the stream type, so a stream alias survives. A concurrency
option keeps mapEffect as Stream.mapEffect. A removed name gives the ordinary
unknown-name diagnostic.

schemaDefaultNullKey and schemaDefaultEncodedKey are merged into
schemaDefaultKey. Its options record gains the on option, which is the literal
"missing", "null" or "encoded" and defaults to "missing". A call without on
keeps its meaning. The checker reads on first and then applies the rules of the
selected operation. Lowering maps on to the existing IR operation and rebuilds
the options record without on. The three adapters schemaOptionalFromRequired,
schemaNullToMissingKey and schemaOptionFromOptionalKey keep their names. The
earlier entries of this file describe the removed names and stay as history.

No IR shape, fact kind, validator rule or emitter row changes. A script compiles
each changed test source and fixture in its old form with the compiler before
the change, and in its new form with the compiler after the change. For 52
sources and probes, the emitted TypeScript, the serialized IR without spans, the
interface and its hash, and the hover text are identical. Those include the six
changed schema fixtures, the four predicates over a stream alias, mapStream
against the new pure mapEffect, and mapEffect with a concurrency option. One
difference is intended: a pure mapEffect without options now emits Stream.map,
as mapStream did, and no longer emits Stream.mapEffect. The committed golden
files do not change.

The compiler passes deno task check on Deno 2.9.7: formatting, lint, type
checking, 1,676 fast tests and 151 slow tests. The Core 1 showcase source builds
with --validate --tsc: six modules and zero diagnostics, and its emitted
TypeScript is byte-identical to the build with the old names. The edition
advances to draft 0.58 because this change removes source forms.


October 21, 2026: correctness, editor and local release checks

The compiler implements the FX correctness plan and ER editor/release plan.
Target-check subprocesses use the permitted PATH Deno executable. Emitted
records, schemas and nominal errors preserve prototype-sensitive own fields.
Watch target checking responds to local host and configuration changes without
claiming that unchanged Effektive modules were rechecked. No source form or
package-interoperability deferral changes.

Editor references, prepare-rename and validated versioned rename, scoped
completion, full semantic tokens and checked-effect contract quick fixes are
automated. Local release artifacts contain a standalone CLI and a complete
VSIX with its bundled server and locked client runtime. Portable installation
checks verify reproducible archives and offline empty-cache startup outside a
checkout. The final VSIX passed an isolated installed VS Code run covering the
new providers, generated output, save, error recovery and a new-process restart.
The final local archive matches the installed archive byte for byte.

The service-workflow source still owns orchestration. Seven separate integration
checks use actual loopback HTTP and a temporary file-backed SQLite database,
covering persistence, rejected input, malformed and unsuccessful HTTP, permanent
database failure, rollback, synchronized cancellation and connection close.
These checks establish neither distributed transactions, ambiguous-commit
recovery nor exactly-once delivery. The public fixture copies match the compiler
fixture. They build with --validate --tsc, then pass all seven integration checks.

The full benchmark command is deno task bench --full m1 m3 m4. The compiler
repository retains the raw JSON, complete report and analysis in
docs/release-measurements-2026-10-21.json,
docs/release-measurements-2026-10-21.txt and docs/release-measurements.md.
On Deno 2.9.7, macOS arm64, 14 logical cores, unpinned single-thread servers,
all four large synthetic diagnostic cases meet the existing 100 ms p90 budget.
The slowest is alias edit: 73.923 ms p90, 200 timed samples pooled from paired
servers, with a 22.2 percent row noise floor. This is a local measurement, not
a performance comparison or a guarantee for other machines.

Two medium-project sessions each completed 10,000 distinct edits across three
concurrently open documents. Type-table size went from 174 to 176 on each.
Step-end RSS peaks were 216.4 and 228.0 MiB; final RSS was 200.1 and 205.3 MiB.
Raw heap and type-table samples are retained alongside RSS. Step-end sampling
cannot observe within-step peaks, and these finite runs establish no memory
bound. M3 records one parsed module per edit, one checked module for body
edits, and 26 for large header, alias and mode changes, with no lowering or
emission in those editor updates.

The final playground build passed automated browser and screenshot review at
375, 720 and 1280 CSS pixels, including keyboard navigation, type and syntax
error recovery, retained stale output and read-only generated text. Browser
behavior and artifact hashes are recorded in the compiler release evidence.
The user's manual editor and playground acceptance remains pending. Nothing
was published by these local checks.

Verification: the compiler's deno task check passes formatting, lint, strict
type checking, 1,786 fast tests and 174 slow tests. This website's deno task test
passes 11 tests and deno task typecheck checks 48 strict snippet units. Asset
query stamps match the site's existing version 0.5.10. The specification stays
at draft 0.58 because these changes add no source forms.


October 21, 2026: bounded architectural cleanup

The compiler's R15a and C10 refactor moves shared syntax queries into a module
that depends only on the lexer and lossless tree. Lowering no longer imports
syntax helpers from the expression checker. The builtin-change checklist in
the compiler repository's docs/builtin-changes.md completes A6.

The entry/result portion of R13 CHK-13 now uses tagged function and constant
entries paired with their matching body-check results. Two signature casts and
positional result pairing are removed. The SCC solver and shared mode map keep
their existing behavior; the mode-map remainder and the other R13 state work
remain open. R15b is outside this batch. No source form, public core export,
IR shape, independent-validator policy or language stopping rule changes.

Both source units pass the compiler's deno task check: formatting, lint, type
checking, 1,786 fast tests and 174 slow tests. TypeScript also rejects both
deliberately mismatched entry/result pairs in a separate type check.

Each unit's behavior comparison has 8,218 identical records, zero missing and
zero new. Instrumented cold children received write access only to the capture
record file in both exported revisions; repository test inputs, assertions and
permissions stay unchanged. The capture solution and evidence ledger in the
compiler repository document this verification-only overlay. Website checks
pass 11 tests and 48 strict snippet units.


October 21, 2026: Schedule family cleanup

The R15b pilot moves four source-checker handlers for seven general Schedule
builtins into check_builtins/schedule.ts. An eight-member BuiltinContext gives
them the existing checker operations directly. Prelude dispatch, arity and
pipeline rules, lowering facts and independent validation keep their owners.

The body checker shrinks from 6,929 to 6,750 raw lines. Imports and contracts
add 42 filtered lines across the three affected files; the branch count stays
the same. All four handler bodies have identical tokens after changing the
receiver from this to the context parameter. The remaining R15b families stay
open. This changes no source form, public core export or application boundary.

Verification: the compiler's deno task check passes formatting, lint, strict
type checking, 1,816 fast tests and 176 slow tests. The behavior comparison
against bdf81d0 has 8,970 records on each side, zero missing and zero new, using
the same documented capture-only record-file permission overlay in both trees.
Website checks pass 11 tests and 48 strict snippet units.


October 21, 2026: Codec and Ref family cleanup

The next two R15b units move Codec and Ref checking into separate family
modules. Codec adds only isError and widen to BuiltinContext; Ref reuses that
same ten-member interface. Prelude dispatch, argument evaluation, lowering
facts, data-only rules and independent validation keep their existing owners.
Codec transformations keep their purity and input/output type checks, and Ref
operations retain their effect mode and pure update callbacks.

Across the two units the body checker shrinks from 6,750 to 6,627 raw lines.
Imports and contracts add 17 filtered lines overall, with no branch change.
All three handler bodies have identical tokens after receiver normalization.
Schedule, Codec and Ref extraction is complete; other R15b families remain
open. No source form, public core export or application boundary changes.

Each unit passes the compiler's deno task check: formatting, lint, strict type
checking, 1,816 fast tests and 176 slow tests. Each behavior comparison has
8,970 identical records, zero missing and zero new, with the documented
capture-only record-file permission overlay. Full gates and capture run
serially because benchmark cleanup assertions observe shared temporary
directories. Website checks pass 11 tests and 48 strict snippet units.

October 21, 2026: remaining R13 and R15b cleanup

R13 is complete. Generated-file writing consumes tagged ready/failure states;
validator computations distinguish derived, checked and poisoned results; mode
solver assumptions no longer mutate published modes. Internal Schema nodes
carry one presence state, while canonical IR retains its existing flags.
Language-server project state carries a revision and its delta together and
retains the last successful pair when a configuration update fails.

R15b now separates all source-checker builtin families. Collections, Effect,
Layer, Fiber, Scope, Stream/Sink and Schema join the earlier Schedule, Codec and
Ref modules. Family handlers use shared operations or a narrow family context;
the shared BuiltinContext stays at ten operations. The body checker owns
argument evaluation, diagnostics and body-table writes; generic dispatch keeps
arity and pipeline rejection order. Schema metadata and its exhaustive handler
table stay together. The validator remains independent of checker policy.

The final compiler gate passes 1,826 fast tests and 176 slow tests. Each remaining
family unit has a constant-input behavior comparison with 8,986 records on each side,
zero missing and zero new records. These comparisons cover checking, lowering,
emission, program queries and independent validation, with the documented
capture-only record-file permission overlay applied equally to both trees.
New R13 state and boundary tests also run in the full gate. This cleanup changes
no source syntax, public core exports, canonical IR or application disposition.
Manual release acceptance remains pending, and the other documented rederive
items remain separate work.

October 22, 2026: audit and save plan completion

The compiler audit batch AU1 through AU8 and all recorded follow-ups are
complete. Commit 1af80d7 gives benchmark temporary directories a process-specific
prefix, so concurrent verification runs cannot affect each other's cleanup
assertions. The regression verifies that owned leaks are still detected and
foreign directories are ignored. Two concurrent benchmark test runs pass
all eight tests each. The full compiler gate passes 1,826 fast tests and
177 slow tests, including loopback HTTP/SQLite and offline installation.

The save-transpilation plan SV1 through SV6 is complete. The user chose to
record the full M7 and M4 run in compiler commit 5236308. The large body-save
p90 is 24.927 ms against the 100 ms budget; sampled RSS is higher with the
disk program, and the observations establish no memory bound. The completed
audit and save plans now live under docs/archive/plans/ in the compiler
repository. Its status page no longer lists the audit batch as open.

This documentation cleanup changes no source form or application disposition.
Manual editor and playground acceptance remains pending, as do the separately
tracked rederive items and the package-interoperability deferral.

October 22, 2026: checker identity guards

The CHK-11 remainder is complete. The source checker removes 24 identity
casts and four duplicate error-prefix checks. Declaration metadata now ties
alias and brand kinds to type identities and error kinds to error identities.
Explicit guards preserve the existing results of nominal-error lookups.
Public query signatures and definition-map key types remain unchanged.

All 274 focused tests pass. Three compile probes now reject mismatched
declaration kinds and identities that the baseline accepted; valid declarations
still compile. The full compiler gate passes 1,826 fast tests and 177 slow
tests. Constant-input behavior captures contain 8,986 records on each side,
with zero missing and zero new records, using the documented record-file
permission overlay in both temporary trees. The affected source files retain
8,082 filtered lines and add 12 AST branches for explicit guards.

Source forms, public core exports, canonical IR and independent validator
policy are unchanged. Manual editor and playground acceptance remains pending.

October 22, 2026: builtin type table and workflow comparison

CHK-12 is complete. One ordered resolver list derives the 17 named builtin
types and their exported name set. An exhaustive checker table keeps plain,
generic and declaration-only Brand policy explicit, with one shared generic
arity check. The current adaptation retains the later checker ID guards and
keeps source-order IR separate from interned type references.

All 287 focused tests pass, including exact RetrySchedule and Fiber error
messages and spans. Three compile probes reject missing and unknown table
rows and an invalid generic arity. The full compiler gate passes 1,826 fast
and 177 slow tests. Behavior captures match all 8,986 repository-suite records
and all 11,416 records after an additional 1,088-program named-type corpus,
with zero missing and zero new records. The documented record-file permission
overlay applies equally to both temporary trees. Across the two source files,
filtered lines increase by 32 and AST branches decrease by 38; named lowering
falls from 153 to 46 raw lines and from cyclomatic 41 to 15.

The book's activate-and-save pair now includes the same conditional write in
both languages. Already-active users return without a write; inactive users
are activated and saved. The shown pair contains 253 non-whitespace characters
in Effektive and 304 in Effect-TS, including its pure helper and explicit
exported contracts, excluding shared chapter 4 declarations from both counts.
The complete source is available as effektive-examples/activation.eff.
The Effektive snippets pass checking, lowering, independent validation and
strict emitted TypeScript checking. Five runtime cases match the handwritten Effect-TS:
already active, inactive, missing user, lookup failure and save failure,
including returned values, typed failures and service-call traces. The site's
11 tests and 48 strict translation units pass; no Effektive block lacks a panel.

Source forms, public core exports, canonical IR and validator policy are
unchanged. Manual editor and playground acceptance remains pending.

October 22, 2026: LSP parameter schemas and collection comparison

FE-2 completes the R12 front-end cleanup. Private ordered schemas share
primitive, object, array and optional checks for incoming LSP parameters.
Exact errors, first-error order, optional-field absence and ignored extra
fields are preserved. Initialization defaults and warnings remain explicit;
editor requests still validate positions before optional document versions.
All ten public narrower signatures are unchanged. The protocol module falls
from 479 to 469 filtered lines and from 110 to 57 AST branches; maximum
cyclomatic complexity falls from 11 to 10.

All 100 focused LSP tests pass. The 19 protocol tests, including two new editor
characterization tests, also pass against the frozen pre-refactor source.
Two compile probes reject a missing required schema field and an explicitly
undefined optional field; valid optional fields compile. A deterministic
corpus compares 30,000 inputs per narrower: all 300,000 results match,
including exact errors and serialized output. The full compiler gate passes
1,828 fast and 177 slow tests.

The book's collection pair now exports listActiveNames in both languages and
links complete source at effektive-examples/active-names.eff. The displayed
pair uses 194 non-whitespace characters in Effektive and 266 in Effect-TS,
including its pure helper and explicit exported contracts. The effectful
wrapper alone uses 96 and 144 respectively. Shared chapter 4 declarations
are excluded from both counts. The Effektive source passes checking,
lowering, independent validation and strict emitted TypeScript checking.
Five runtime cases match the handwritten Effect-TS: empty input, no active
users, preserved order, duplicate names and a typed service failure. Each
calls Users.all exactly once. All 11 site tests and 48 strict translation
units pass, with no Effektive block missing a translation panel.

Source forms, public core exports, canonical IR and independent validator
policy are unchanged. ARC-5 and VAL-8 remain open, along with manual editor
and playground acceptance.

October 22, 2026: builtin fact assessment and recovery comparison

The ARC-5 name-only lowering proposal is declined after checking its
prerequisite. The current NodeFact union has 90 distinct kinds, including
66 payload-free kinds. Of those, 54 are fixed builtin call tags, ten depend
on callbacks or retry options, and two describe ordinary calls or the None
value. Six resolved builtin names select different lowering kinds. For
example, mapEffect can lower to map-stream or map-effect; retry can lower to
retry or retry-with-schedule. A name-only table would lose these decisions.
The checker, fact-table and lowering implementation stays unchanged. A
selective fixed-tag rewrite has no measured benefit and is not accepted work.

Two new regression tests cover 13 valid counterexamples, checking resolved
names, exact lowered IR kinds and independent validator acceptance. All 231
focused tests pass. The full compiler gate passes 1,830 fast and 177 slow
tests. VAL-8 remains open, along with manual editor and playground acceptance.

The book's recovery pair now exports activationLabel in both languages and
links complete source at effektive-examples/activation-label.eff. Its
Effect-TS version uses Effect.as and Effect.catchTag. The displayed pair
uses 181 non-whitespace characters in Effektive and 216 in Effect-TS,
including the Label alias and explicit exported contracts; shared
declarations and saveActive are excluded from both counts. The Effektive
source passes checking, lowering, independent validation and strict emitted
TypeScript checking. Five runtime cases match the handwritten Effect-TS:
already active, inactive, recovered missing user, lookup failure and save
failure. Returned labels, typed storage failures and service-call traces
match. All 11 site tests and 48 strict translation units pass, with no
Effektive block missing a translation panel.

Source forms, public core exports, canonical IR and independent validator
policy are unchanged. No performance saving is claimed for ARC-5.

October 22, 2026: validator builtin classification and retry comparison

VAL-8 is complete. The independent validator caches typed identity and call
classifications for map, filter, fold, all and traverse. Import shape checks
still use the ID; call rules still follow the first recorded name. Every
prelude value remains marked as a builtin, including malformed IDs. Raw
names preserve non-string failures in the original guarded call phase.
Shared container reconstruction and concurrency checks remain independent
of the source checker. An exhaustive shape switch rejects an added
unhandled builtin name at compile time.

All 202 existing focused validator tests and three new characterization
tests pass. The new tests also pass against the frozen validator. The full
gate passes 1,833 fast and 177 slow tests. Constant-input behavior captures
match all 9,082 records, with zero missing and zero new. Both temporary
trees run the same tests and the documented record-file permission overlay.
A separate corpus compares 16,560 full validator diagnostic arrays for
malformed IDs and names, callback modes, duplicate prelude entries,
parameter counts and nested type/container substitutions; every result
matches. Across two existing files and one new helper, filtered lines rise
from 5,685 to 5,748 and AST branches stay at 1,631. The measure.ts cyclomatic
value of checkBuiltinShape falls from 66 to 50. No performance or memory
gain is claimed.

The retry example now exports lookupWithRetry in both languages and uses
the cold Users.use effect directly in Effect-TS, without an extra suspension.
Complete source is available at effektive-examples/retry-lookup.eff. The
shown pair uses 123 non-whitespace characters in Effektive and 156 in
Effect-TS, including explicit exported contracts and excluding shared
chapter 4 declarations. Effektive still requires its deferred direct call.
The source passes checking, lowering, independent validation and strict
emitted TypeScript checking. Five runtime cases match the handwritten
Effect-TS: immediate success, success after one or two failures, exhaustion
after three attempts, and an immediate None result. Values, typed failures
and exact service-call counts match. All 11 site tests and 48 strict
translation units pass; no Effektive block lacks a translation panel.

Source forms, public core exports and canonical IR are unchanged. Manual
editor and playground acceptance remains pending, as do the separately
recorded refactor deferrals. ARC-5 remains declined as proposed.

October 22, 2026: decoupling Phase 1

A fresh architecture review found places where one rule lives in two units
without a compile check. The accepted plan is in the compiler repository at
docs/plans/2026-10-22-decoupling-review.md. Phase 1 closes five of them. The
builtin instance identity now has one owner in ids.ts, for lowering and
emission; the independent validator keeps its own pattern. Editor type
completion reads the parser's type words, and the resolver, completion and
contract actions share one table of Effect error identities. The module
checker passes type phase results as values instead of fields. Every
prelude call name needs a prologue row, and a static prologue fact must carry
the kebab form of its name; both are compile errors now. A revision keeps a
copy of its input files, so rename and contract actions check the real
configuration text instead of a rebuilt one.

Two results are visible. Type completion now also offers Schedule and the
seven Schema field wrapper words. A rename or contract action under a
configuration with unknown keys now counts those configuration diagnostics
on both sides of its speculative check, so a rename that adds new
diagnostics is rejected.

The full gate passes 1,837 fast and 177 slow tests. A constant-input behavior
capture of the first four units matches all 9,082 records, with zero missing
and zero new. For the revision-input unit, single-revision captures differ
only in 11 speculative program records, which pair one to one by diagnostic
hash. Both temporary trees used the same tests and the documented
record-file permission overlay. A probe found zero union-order ties that
fall back to type reference numbers in 4,075 fast-suite comparisons.

Source forms, public core exports and canonical IR are unchanged. Phase 2
moves pipeline stage effects to the checker, which also fixes a found defect:
a scoped or forkScoped stage with an effectful left value lowers to IR that
the independent validator rejects. Manual editor and playground acceptance
remains pending.

October 22, 2026: decoupling Phase 2 and the scoped stage fix

Phase 2 gives three rules one owner each. The source checker now computes
the effect set of a pipeline stage whose left value has effects, and
lowering reads that set. Before, lowering kept a second copy of these
rules for every stage kind. That copy had no case for scoped and forkScoped,
so a program such as makeJob() |> scoped passed the checker, but the
independent validator rejected its IR with validation/003 and
validation/004. That program now lowers to valid IR; the direct call form
was always correct. Hover and the emitter now print a declaration header
with one shared function; hover still shows the inferred result type. Body
scheduling in the project checker now has one writer for each result map.

The full gate passes 1,847 fast and 177 slow tests, including ten new stage
tests with effectful left values. A constant-input behavior capture matches
all 9,109 records, with zero missing and zero new; it ran the same tests on
both sides, without the two scoped cases whose result the fix changes, and
with the documented record-file permission overlay. No golden file or IR
fixture changes. Across the core library, filtered lines fall from 34,502
to 34,393 and AST branches from 8,065 to 7,961. No performance or memory
gain is claimed.

Source forms, public core exports and canonical IR are unchanged. The
remaining decoupling phases, manual editor and playground acceptance, and
the separately recorded refactor deferrals remain open.

October 22, 2026: decoupling Phase 3, the editor boundary

Phase 3 puts the editor queries behind one boundary. A Revision now answers
read-only queries for module infos, path lookups, resolutions, imports,
declaration entries, the type table, and validation. The editor files, the
build command, the language server, the host outputs, and the playground
use these queries. The project and checked fields of a Revision are now
private, so a change to a checker shape no longer reaches the adapters.

Rename and the missing-contract actions no longer compare diagnostic
counts. They compare diagnostics by code, source, and span, with each span
moved through the edits. A rename is rejected when it adds an analysis
diagnostic. An action must remove a diagnostic and add none. A probe ran
the old and the new rules on 2,800 renames over the 14 fixture projects and
on 100 contract action cases: it found no difference. One rename outside
the fixtures now gives a different rejection message; a new test pins it.

The full gate passes 1,852 fast and 177 slow tests. Constant-input
behavior captures match all records for each unit, with zero missing and
zero new: 9,115, 9,116, and 9,116 records. One first run lost three clean
program records to run variance; single-revision reruns matched. No golden
file or IR fixture changes. Across the core library, filtered lines rise
from 34,393 to 34,521 and AST branches from 7,961 to 7,970, because the new
queries add more code than the editor files lose. No performance or memory
gain is claimed.

Source forms and canonical IR are unchanged. The public core exports
change: the Revision fields project and checked are private, the core
module no longer re-exports methodOfCapability, moduleOfId, nameOfId, and
readConfig, and it now exports the types TypeReader, TypeNode, and TypeRef.
The package version stays 0.6.0. Phase 4, manual editor and playground
acceptance, and the separately recorded refactor deferrals remain open.

October 22, 2026: decoupling Phase 4, the edit spread

Phase 4 reduces the number of places that one change must edit. Each
builtin family of the checker now holds the rows of its builtins. So a new
builtin in an existing family no longer edits the body checker. A test
checks that each prelude name has exactly one row. Pattern checking and
the operator rules left the body checker. The body checker falls from
3,039 to 2,092 lines.

The independent validator now keeps its builtin families in separate
files, behind a context that the validator owns. The validator still
imports no checker code, and a test checks that for each file. The main
validator file falls from 4,901 to 1,638 lines. The build watch loop and
the language server save round now share one save round, with the removal
rule of each caller as a parameter.

One fix changes visible text. A validation diagnostic inside a schedule
argument named the field "argument", which does not exist in the IR. It
now names "times" or "delayMillis". Review also found that the shared save
round changed the order of the watch loop output. A fix restores the old
order, and a new test pins it.

The full gate passes 1,861 fast and 177 slow tests. Constant-input
behavior captures match all records for each group of units, with zero
missing. The checker and validator units have 9,127 records, and the save
round has 9,180. One capture had one extra clean program record, which a
capture of one revision against itself also shows. Token comparisons of
the moved code match 95 builtin handlers, 95 prologues, 16 pattern and
operator members, and 119 validator items.

Across the core library,
filtered lines rise from 34,521 to 35,184, and AST branches go from 7,970
to 7,969. No performance or memory gain is claimed.

Source forms, canonical IR, golden files, and the public core exports are
unchanged. Five measured items stay deferred, because they would add edit
sites or code for a small gain. One difference stays open for a decision.
The build command writes the outputs of a module that a nested project
owns, and the language server does not.

October 22, 2026: nested projects in build and watch

A directory under a project root that holds its own effektive.json is a
nested project. The language server already left the outputs of a nested
project to that project. The build and watch commands wrote them, so two
projects could write one file. Now build and watch skip those outputs too.
The outer project still checks the nested modules and prints their
diagnostics.

One shared ownership rule serves the command-line tool and
the language server. Two tests cover the rule, and both fail with the old
rule. The full gate passes 1,862 fast and 177 slow tests with Deno 2.9.7.

October 23, 2026: emitter builtin families

The Effect-TS emitter now keeps the code of each builtin family in its own
file, as the checker and the independent validator already do. Nine
family files hold the stream, schedule, schema, codec, layer, fiber,
scope, effect, and collections code. The main expression emitter falls
from 2,898 to 1,769 lines. A new builtin in an existing family now edits
one family file in each of the three compiler stages.

Role interfaces now name the parts of the emitter scope. The compiler
rejects a family file that reads the import ledger, and a test rejects a
family file that imports the expression emitter. One helper replaces 12
hand-written type assertions.

Two behavior captures compare 9,198 records on each side, including 1,749
emitted modules, with no new and no missing record. A comparison of the
moved code matches 38 items. The full gate passes 1,863 fast and 177 slow
tests with Deno 2.9.8. Across the core library, filtered lines rise from
35,184 to 35,626, and AST branches go from 7,969 to 8,003. No performance
or memory gain is claimed. Source forms, canonical IR, golden files, and
the public core exports are unchanged.

October 23, 2026: nominal data types

The compiler adds the data declaration. A data type is a nominal record with a
runtime tag, as in data User = { id: UserId, name: Name }. It has its own type
table entry and the identity type:module#Name. A program builds a value with
User(record), reads fields, updates with a spread, and gets the base record
with unbrand. The generated copy leaves out the tag. The emitter prints
Schema.TaggedStruct with a tag from the resolved identity, and the encoded form
keeps the tag.

A match selects data types and errors by name, with coverage by declaration. A
record pattern on such a subject, a subject that mixes nominal and other
types, and a constructor pattern that names an alias or a brand all give
pattern/004. A data or error field cannot hold a function or deferred type
(declaration/015). A data type can be recursive when every cycle passes through
an Option, an array, an optional field, or a union with a member outside the
cycle. The emitter then prints explicit types and suspended references. A brand
of a record, of a data type, or of a union with such a member now gives
declaration/014, so the form Brand<{ ... }> is gone. The editor, the TextMate
grammar and the playground highlighter know the word data.

The change has seven commits in the effektive-lang repository: 2a57d9c,
2404446, 2285033, 6b21dc2, ac90799, 8ab15c0, and 24f3937. The first six change
the compiler and the last changes its documents. The full gate passed for
each commit. Before the last commit, one slow test lost its child process once
(exit code 139), and it passed on three reruns. The last run passes 1,927 fast tests and 181 slow tests with Deno
2.9.8. The slow tests build and run the emitted data forms, including a match
that selects each arm by tag and a recursive tree, list, and forest that encode
and decode. The five example programs and their golden files do not change,
because each of their records is built or read by host code.

The website now shows data types in the specification: the declaration rules,
a construction, update, field read and unbrand figure, a match by name figure,
the grammar rule dataDecl, and the IR nodes. typed-ir.ts gains the data
expression node, the data pattern, and the data type definition. Each new
Effect-TS panel was checked in two ways. The compiler builds the Effektive
source with --validate --tsc and reports zero diagnostics. The strict check
passes all 49 illustrative units with no missing translation, and the eleven
server tests pass. The panels use short tags and compact layout, as the other
panels do. The edition advances to draft 0.59 because this change adds a
source form.

October 23, 2026: nominal data chapter and order lifecycle application

The mini-book gains the chapter Nominal data after A payment pipeline. The book
now has eleven chapters. The chapter has three figures: the order states with a
construction and a spread update, a match by name over Order with no wildcard
arm, and the recursive pricing rules. The prose states that a Paid value is not
a Pending value, even where the fields overlap, and that JSON enters through a
plain record type. The Effect-TS panels use short tags. The compiler writes
module-qualified tags such as contracts#Pending. The panel of the recursive
figure keeps the explicit interfaces, the Encoded mirror interfaces, and
Schema.suspend, because typeof Rule.Type inside a cycle fails the check.

The site copies the order lifecycle application from the effektive-lang
repository to effektive-examples/order-lifecycle/. The copy has the two Effektive
modules, main.ts, checks.ts, deno.json, effektive.json, and a README. The
modules, main.ts and the two configuration files match the fixture byte for
byte, and checks.ts is runtime_test.ts under a new name. The modules chapter
and the specification each gain a paragraph that calls the application a
witness for nominal data types. It is not a gate application, and the stopping
rule does not count it. The navigation labels, the Previous and Next links, and
the three chapter menus now include the new chapter.

The compiler builds the downloaded copy with --validate --tsc and reports two
modules and zero diagnostics. In that copy, main.ts runs, and the nine checks in
checks.ts pass with Deno 2.9.8. The compiler also builds the Effektive source of
the three figures with --validate --tsc and reports zero diagnostics. The strict
check passes all 52 illustrative units with no missing translation, and the
eleven server tests pass.

October 23, 2026: runtime checks at the host boundary

The specification gains two paragraphs. The first states that a match whose
last arm is not _ tests that arm too. A value outside the subject type then
causes a defect instead of taking the last arm. The second states that each
module wraps a host provider whose method results contain data types. Each
result and each stream element goes through Schema.is, and the paragraph lists
the positions that stay trusted. The edition stays at draft 0.59, because no
source form changes.

The compiler commits are 94c64bd for the match test, 29fc514 for the provider
checks, and 8436f78 for the documentation. The measurement used an Apple M4 Pro
with Deno 2.9.8 and an in-memory host. A wrapped provider adds about 0.14 us for
each call and about 0.13 us for each stream element. The site tests pass 11 of 11, and the
strict check passes all 52 illustrative units with no missing translation.

October 23, 2026: companion module of host interfaces

The specification gains a paragraph on the companion module. The compiler
emits host.effi.ts for each host interface file that a module imports. It holds
the types, errors, data types, and services of the interface, with their tags.
Source modules and the host module import them from it.

The data type rules
gain declaration/016 for an opaque type in a data field, an error field, or a
brand base. Results that name interface declarations are no longer a trusted
position, because the companion module gives them a schema. The edition stays
at draft 0.59, because no source form changes.

The service workflow example now imports the Runtime service from
host.effi.ts in adapter.ts, driver.ts, and integration_driver.ts. These files
match the effektive-lang fixture byte for byte. The Runtime tag changes from
service-workflow#Runtime to host#Runtime. The compiler commits are d7f0691,
decf945, c2428bd, c877fc3, and e6ec178.

The compiler builds a copy of the example with --validate --tsc and reports
three modules and zero diagnostics. In that copy, main.ts runs, the fifteen
checks pass, and the seven integration checks pass with Deno 2.9.8. The site
tests pass 11 of 11, and the strict check passes all 52 illustrative units.

October 23, 2026: review fixes of the companion module

A code review of the companion module found eight problems, and six of them
are fixed. An unnamed host opaque type now comes from its host module, not
from the companion module. Data construction and the host check now copy a
value without a prototype when an optional field has an Object.prototype name.

The specification gains one sentence on this copy in the host provider
paragraph. The lowerProject function now lowers .effi modules too, so the
public API emits each companion module. The edition stays at draft 0.59,
because no source form changes.

The compiler commits are 857c84a, 5d8de3d, e15a3db, 418603e, and dc03e9d. The
compiler gate passes 1946 fast tests and 191 slow tests with Deno 2.9.8.

October 23, 2026: data type figure without a field alias

The data type figure of the specification no longer declares AccountFields. The
data declaration already gives the base record. A function that is not
exported infers the unbrand result, and the compiler prints that record type
inline. The site tests pass 11 of 11, and the strict check passes all 52 units.

A data or error body that does not parse now gets the error type. Before this
change, each use of such a type gave a false type-mismatch error after
syntax/008. The compiler commit is 317d018, and its gate passes 1947 fast
tests and 191 slow tests.

October 23, 2026: the nominal declaration

The specification and the book replace the data declaration and Brand<T>
with the nominal declaration. The form nominal Name = type declares a nominal
type. A record body gives a tagged nominal record. Any other body gives a
brand. The function unbrand is removed.

The specification states the widening rule: a nominal value fits its base
type, and a base value still needs the constructor. It also states the
operator rule. The operators + and - on one numeric nominal type give that
type. Other arithmetic widens to the base type. Two different nominal types
never mix. The edition advances to draft 0.60 because this change replaces
source forms.

The book chapter Nominal data is now Nominal types, with the id
nominal-types. The spec-account figure now declares AccountFields and
nominal Account = AccountFields. It ends with a function that returns the
Account value as AccountFields, so the base record needs no second field list.
The figure units book-data-states, book-data-match, book-data-rules, and
spec-data-match are renamed to book-nominal-states, book-nominal-match,
book-nominal-rules, and spec-nominal-match.

The site copies pay.eff, contracts.eff, and orders.eff from the effektive-lang
fixtures. The three files match the fixtures byte for byte. The host files
and checks.ts did not change. typed-ir.ts moves to IR version 3 with the
nominal definition kind, the nominal construction node, and the nominal
pattern kind. log.ir.json gets the version bump only. It comes from a
different source than the fixture, so the site does not copy the fixture.

The compiler commits are d59b5bf, 9da2ebd, bd52a86, 95c72b7, and 76dc088.
The compiler builds the Effektive source of ten changed figure units with
--tsc and reports zero diagnostics for each. The units are spec-types,
spec-account, spec-cents, spec-nominal-match, spec-example-pay, book-values,
payment, book-nominal-states, book-nominal-match, and book-nominal-rules.
The Effect-TS panels of spec-account and spec-cents change to match the
emitted code. The other panels already matched it.

The compiler builds the example directory with --tsc and reports eleven
modules and zero diagnostics. It builds the four application directories with
--validate --tsc. Each build reports zero diagnostics. The module counts are
two for order-lifecycle, two for scheduled-worker, three for service-workflow,
and two for stream-processor. In the order lifecycle copy, the nine checks in
checks.ts pass with Deno 2.9.8. The site tests pass 11 of 11, and the strict
check passes all 52 illustrative units with no missing translation.

A later compiler commit, 5cc0e63, lets the operator rules follow a chain of
nominal types. With nominal Tip = Cents, a Tip value compares with Tip, Cents,
and int. The specification sentence on compatible operands now says this. The
compiler gate passes 1962 fast tests and 195 slow tests.

Portable publisher witness (2026-10-23)

The portable publisher is an exploratory witness, not a gate application.
The accepted three-application stopping rule remains unchanged. Effektive
source owns assessment, planning, validation, conflict policy, grants, and
serial batching. Generic memory and SQLite implementations share textual
keys, payloads, and opaque storage versions.

Focused compiler checks cover source contracts, lowering, and independent
IR validation. Twenty compiled memory workflow and lifetime cases pass.
One ten-case KV suite passes on each implementation. Five further SQLite
cases cover backend parity, cross-lease invalidation, an open failure, persistence through independent leases, and simulated lost
acknowledgement after an actual commit. The simulated failure
returns uncertainty without retry. A scoped integration process receives
filesystem access only to its temporary directory and no network permission.

The witness establishes finite batch behavior in one process. It does not
establish HTTP admission control, distributed transactions, crash recovery,
or exactly-once delivery. Synchronous SQLite operations remain synchronous.
No new language form was selected by that witness. Sealed nominal types, reusable purity
contracts, and optional import rules remain review-only design proposals.


Approved portable type controls (2026-10-23)

The user approved sealed nominal types, pure function types, and optional
project import rules after the portability witness. The compiler implements
all three controls. The three-application stopping rule remains unchanged.

A sealed nominal type gives its declaring module construction authority.
Foreign construction, retained updates, arithmetic, implicit base widening,
and Schema derivation or decoding fail. Schema callbacks also preserve input
authority when their final decoded result is unsealed. Encoding remains legal.
Owner-provided conversions remain callable. Existing open nominal types keep
their behavior. Optional sealed metadata extends IR version 3.

Pure function types require pure execution and empty effect rows. Unmarked
function types retain effect execution. Empty rows do not make run or provide
pure. Ordered import rules restrict resolved direct edges without selecting
a platform. Services and Layers still provide platform composition.

The final compiler gate passes formatting, linting, type checking, 2030 fast
tests, and 199 slow tests. Independent validator regressions reject altered
sealed operations and identity forgeries. Project validation binds lowered
module names to their keys. Non-prelude imported declarations cannot claim
the consumer's identity. Supporting types can still belong to third modules.

The updated specification includes two new paired source and TypeScript
panels. Both Effektive panels pass checking, lowering, and independent
validation. All 54 illustrative TypeScript units pass strict checking, with
no missing translation. The site passes all 11 serving and asset tests.
The linked public IR model passes deno check, and site.js passes node --check.

The portable-types example builds as two modules with zero diagnostics under
--validate --tsc. Its three compiled runtime checks cover positive parsing,
an imported pure callback, and an inline pure callback. Three mutations reject
foreign construction, an effectful callback, and a forbidden import.
The four existing application examples also report zero source diagnostics.

Generated TypeScript and host implementations remain trusted. The validator
checks provided declaration metadata and does not compare imported payloads
with separate producer IR. TextMate fallback coloring stays conservative;
LSP semantic tokens correctly classify parsed multiline pure function types.

Compiler commits: 843b011 adds pure contracts and import rules; 7818a95 adds
sealed authority, validator identity checks, and callback-input protection.


Terse source rules (2026-10-24)

Draft 0.62 follows the compiler changes TE1 to TE4 and TE7 of the terse
source plan. A non-exported function infers each omitted fails and uses
clause. A written clause closes its own set. A result annotation alone no
longer closes the sets. Exported functions and function types stay closed.
A recursive local function needs parameter and result annotations only.
A fails clause can name an alias of errors. Branches of different nominal
records or errors join to their union. A sinkForEach callback and the method
records of a source Layer take expected types from their context. The
language server shows the inferred clauses as inlay hints.

The linked IR model and log.ir.json replace the function field contract with
written, which holds the flags result, fails, and uses. The IR keeps version 3.
The specification, the mini book, site.js, and the example sources follow
these rules. Non-exported helpers lose their fails, uses, and result
annotations. The invalid example in the specification now exports broken,
because a non-exported function no longer fails that check.

Checks run on 2026-10-24
The compiler is effektive-lang at 15ee871. Commits 3d0f17b..15ee871 hold the
changes. Every changed example source reports 0 diagnostics under
deno task effektive check: activation, activation-label, active-names,
retry-lookup, core1, pay, users, log, collections, and the main project.
The four synced applications and portable-types build with --validate --tsc
and report 0 diagnostics. Their checks.ts files pass 9, 10, 15, 13, and 3
cases for order-lifecycle, scheduled-worker, service-workflow,
stream-processor, and portable-types.
The Effektive panels of both pages form 51 units, chained by their
data-check names. The only changes against the earlier pages are
spec-diagnostics, which now reports failure-contract/001 as documented, and
the units that already failed before. Those units are fragments or depend on
a host module that the check project does not register.
The strict TypeScript check passes for 54 units with 0 Effektive blocks that
lack an Effect-TS tab. The site passes all 11 tests after deno task stamp
renewed the asset version to 0.7.0. The linked public IR model passes
deno check. The function declaration in log.ir.json carries the three
written flags; no type check binds that JSON file to the model.

Measured counts
The convention counts non-whitespace characters of the panel code.
The activate and save pair went from 253 to 248 in Effektive, because
activate loses its result annotation. Effect-TS stays at 304.
The collection pair went from 194 to 187, because activeNames loses its
result annotation. The wrapper counts of 96 and 144 are unchanged. The recovery
pair (181 and 216) and the retry pair (123 and 156) are unchanged.

Limits
These checks cover the listed panels and sources, not every language form.
The Effect-TS tabs still show the full intended output with explicit
types. The specification text for TE1 to TE4 has no compiled example,
because each Effektive panel needs a manual Effect-TS tab. The compiler
tests for these rules live in effektive-lang. The site runs no compiler.
deno fmt --check reports 47 unformatted files before and after this change.

Draft 0.63 checks, October 24, 2026
The compiler separates frontend queries from TypeScript output caches and emits
IR v4. The downloadable typed-ir.ts is the compiler model. The manual fixture
uses version 4. Earlier wire versions are rejected without conversion.

The concise figure and the downloadable examples build with --validate --tsc.
The worker and stream downloads also build independently with those flags.
The compiler check passes 2,098 fast tests and 207 slow tests, including all five
application witnesses and runtime checks for all four new source forms.
The site passes 55 strict TypeScript units and 11 server/asset tests.
The new figure has an Effect-TS panel; no Effektive figure lacks one.

Bare arrows preserve explicit exported contracts. Option fallback evaluates its
subject once and the fallback only for None. Record bindings read fields in
written order. Resource finalization runs once after successful acquisition,
including typed failure, defect, and interruption.

A real VS Code development host displays all four forms without diagnostics.
The resource binding has three references across acquisition naming, use, and
finalization, and its hover is available. The compiler repository retains the
screenshot and the detailed migration and performance evidence.

These checks cover the selected examples and contracts. They do not establish
bounded memory, arbitrary backend compatibility, or website deployment.