chronolizer 0.2.0 → 0.3.0

package/README.md

@@ -1,258 +1,260 @@
 # Chronolizer
 
-Chronolizer is an Effect v4 library for bidirectional natural-language date ranges.
+Chronolizer is an Effect 4 library that converts natural-language date ranges to compact date-math filters and back. It supports open ranges, autocomplete, typo correction, and eight languages.
 
-It converts complete English, German, Spanish, French, Dutch, Turkish, Czech, and Polish date-range expressions to a small date-math format. It also renders supported ranges to canonical natural language and resolves the AST with an explicit Effect time zone.
-
-## Status
+```text
+year to date          → { gte: "now/y", lte: "now" }
+January of last year  → { gte: "now-1y/y", lt: "now-1y/y+1M" }
+since January 2025    → { gte: "2025-01-01" }
+```
 
-This package uses `effect@4.0.0-rc.112`. Its API can change while Effect v4 is in release-candidate status.
+> [!NOTE]
+> Chronolizer currently uses `effect@4.0.0-rc.112`. The API can change while Effect v4 has release-candidate status.
 
-## Package entry points
+## Install Chronolizer
 
-Chronolizer is side-effect free and publishes separate ESM entry points:
+Chronolizer requires Effect 4 and ESM. Install both packages as direct dependencies.
 
-```ts
-import { formatNatural, parseFilter, parseNatural, resolve, suggestNatural } from "chronolizer";
-import { GermanLanguageLayer } from "chronolizer/locales/de";
+```sh
+pnpm add chronolizer effect@4.0.0-rc.112
 ```
 
-- `chronolizer` is the single main API entry. It also includes the English language pack.
-- `chronolizer/locales/en`, `chronolizer/locales/de`, `chronolizer/locales/es`, `chronolizer/locales/fr`, `chronolizer/locales/nl`, `chronolizer/locales/tr`, `chronolizer/locales/cs`, and `chronolizer/locales/pl` expose language packs separately.
-- Every non-English language must be imported from its own locale subpath.
-
-The package declares `sideEffects: false`, so consumer bundlers can remove unused main API exports. The package build runs Publint and Are the Types Wrong. CI checks transitive gzip limits and verifies that the main entry does not load non-English locales.
+## Parse your first date range
 
-## Main concepts
-
-- Effect Schema owns the date AST, filter data, results, and errors.
-- Complete periods are half-open: `[start, next period start)`.
-- Open ranges are supported.
-- Weeks always start on Monday.
-- Parsing does not read the clock or host time zone.
-- Resolution requires `DateTime.CurrentTimeZone`.
-- Natural rendering is canonical. It does not reproduce the source wording.
-- Typo correction is conservative and optional. It does not change numbers, ISO dates, or short ambiguous words.
-
-## Natural language to filter
+English is available from the main package entry.
 
 ```ts
 import { EnglishLanguageLayer, formatFilter, parseNatural } from "chronolizer";
 import { Effect } from "effect";
 
-const run = Effect.fn(function* () {
-  const result = yield* parseNatural("January of last year", {
-    locale: "en",
-    typoMode: "strict",
-  });
-
-  return formatFilter(result.range);
-}, Effect.provide(EnglishLanguageLayer));
-
-const program = run();
+const program = parseNatural("January of last year", { locale: "en" }).pipe(
+  Effect.map(({ range }) => formatFilter(range)),
+  Effect.tap((filter) => Effect.log("Date filter", filter)),
+  Effect.provide(EnglishLanguageLayer),
+);
 
+Effect.runPromise(program);
 // { gte: "now-1y/y", lt: "now-1y/y+1M" }
 ```
 
-Other examples:
+`parseNatural` parses the complete input. It does not extract a date range from a longer sentence.
 
-```text
-year to date                    -> { gte: "now/y", lte: "now" }
-January 2025                    -> { gte: "2025-01-01", lt: "2025-02-01" }
-since January 2025              -> { gte: "2025-01-01" }
-before January 2025             -> { lt: "2025-01-01" }
-through January 2025            -> { lt: "2025-02-01" }
-last 3 months                   -> { gte: "now-3M", lte: "now" }
-30 months ago                   -> { gte: "now-30M/M", lt: "now-30M/M+1M" }
-01 January 2025 - 31 January 2025
-                                -> { gte: "2025-01-01", lt: "2025-02-01" }
-Q1 2025                         -> { gte: "2025-01-01", lt: "2025-04-01" }
-Januar letzten Jahres           -> { gte: "now-1y/y", lt: "now-1y/y+1M" }
-die letzten 3 Monate            -> { gte: "now-3M", lte: "now" }
-seit Jahresbeginn               -> { gte: "now/y", lte: "now" }
-seit Januar 2025                -> { gte: "2025-01-01" }
-```
-
-Chronolizer parses the complete input. It does not extract a date phrase from a larger sentence.
-
-Supported families include named and abbreviated months, named dates, quarters, weekends, period starts and ends, past and future rolling windows, calendar offsets, open boundaries, `now`-bounded ranges, and explicit inclusive connectors. Each language uses its own grammar and canonical forms.
+## Common tasks
 
-## Autocomplete natural language
+### Parse other languages
 
-Use `suggestNatural()` for autocomplete fields. Each Schema-owned suggestion contains canonical display text and the semantic range that it represents:
+Import each non-English language from its own package entry. This keeps unused languages out of your bundle.
 
 ```ts
-import { EnglishLanguageLayer, suggestNatural } from "chronolizer";
+import { formatFilter, parseNatural } from "chronolizer";
+import { GermanLanguageLayer } from "chronolizer/locales/de";
 import { Effect } from "effect";
 
-const program = suggestNatural("last m", {
-  locale: "en",
-  limit: 5,
-}).pipe(Effect.provide(EnglishLanguageLayer));
+const program = parseNatural("seit Jahresbeginn", { locale: "de" }).pipe(
+  Effect.map(({ range }) => formatFilter(range)),
+  Effect.tap((filter) => Effect.log("Datumsfilter", filter)),
+  Effect.provide(GermanLanguageLayer),
+);
 
-// [{ text: "last month", range: ... }]
+Effect.runPromise(program);
+// { gte: "now/y", lte: "now" }
 ```
 
-Suggestions support incomplete words, bounded spelling errors, numeric rolling periods, and partial four-digit years. For example, `january 202` suggests `January 2020`, `January 2021`, and later matching years. Every returned suggestion is checked by the exact parser. `allowFuture: false` applies the same positive-relative-range policy as `parseNatural()`.
+Use `languagePluginsLayer` when one application needs more than one language:
 
-The default limit is 10. The maximum accepted limit is 100. A nonpositive or invalid limit returns no suggestions.
+```ts
+import { EnglishLanguage, languagePluginsLayer, parseNatural } from "chronolizer";
+import { GermanLanguage } from "chronolizer/locales/de";
+import { PolishLanguage } from "chronolizer/locales/pl";
+import { Effect } from "effect";
 
-### Exclude positive relative ranges
+const Languages = languagePluginsLayer([EnglishLanguage, GermanLanguage, PolishLanguage]);
 
-Set `allowFuture: false` to reject expressions whose relative range extends after `now`:
+const program = parseNatural("letzten Monat", { locale: "de" }).pipe(Effect.provide(Languages));
 
-```ts
-const program = parseNatural("next 3 months", {
-  locale: "en",
-  allowFuture: false,
-});
+Effect.runPromise(program);
 ```
 
-This option rejects relative forms such as `next month`, `this year`, and `in 3 years`. It does not classify fixed dates such as `January 2099`, because parsing does not read the clock.
+### Format a range as natural language
 
-## Filter to natural language
+`formatNatural` returns the canonical phrase for a range. It preserves the meaning, but it does not reproduce the original wording. Absolute days use the locale's numeric `Intl.DateTimeFormat` form.
 
 ```ts
 import { formatNatural, parseFilter } from "chronolizer";
 import { GermanLanguageLayer } from "chronolizer/locales/de";
 import { Effect } from "effect";
 
-const run = Effect.fn(function* () {
-  const range = yield* parseFilter({
-    gte: "2025-01-01",
-    lt: "2025-02-01",
-  });
-
-  return yield* formatNatural(range, { locale: "de" });
-}, Effect.provide(GermanLanguageLayer));
-
-const program = run();
+const program = parseFilter({ gte: "2025-01-01", lt: "2025-02-01" }).pipe(
+  Effect.flatMap((range) => formatNatural(range, { locale: "de" })),
+  Effect.tap((text) => Effect.log("Date range", text)),
+  Effect.provide(GermanLanguageLayer),
+);
 
+Effect.runPromise(program);
 // "Januar 2025"
 ```
 
-Natural language is many-to-one. Chronolizer therefore guarantees semantic round trips, not the original words.
-
-## Validate external filters
+### Add autocomplete
 
-`parseFilter` accepts a validated `DateFilter`. Decode external data with the exported Schema first:
+`suggestNatural` returns valid canonical phrases and their semantic ranges.
 
 ```ts
-import { DateFilter, parseFilter } from "chronolizer";
-import { Effect, Schema } from "effect";
+import { EnglishLanguageLayer, suggestNatural } from "chronolizer";
+import { Effect } from "effect";
 
-const decodeDateFilter = Schema.decodeUnknownEffect(DateFilter);
+const program = suggestNatural("last m", { locale: "en", limit: 5 }).pipe(
+  Effect.tap((suggestions) => Effect.log("Suggestions", suggestions)),
+  Effect.provide(EnglishLanguageLayer),
+);
 
-const program = decodeDateFilter(externalInput).pipe(Effect.flatMap(parseFilter));
+Effect.runPromise(program);
+// [{ text: "last month", range: ... }, ...]
 ```
 
-A filter has at most one lower bound (`gt` or `gte`), at most one upper bound (`lt` or `lte`), and at least one bound.
-
-## Compact expression syntax
+The default limit is 10. The maximum limit is 100. A nonpositive or invalid limit returns no suggestions.
 
-```text
-expression := anchor operation*
-anchor     := "now" | YYYY-MM-DD | YYYY-MM-DD "||"
-operation  := ("+" | "-") positiveInteger unit | "/" unit
-unit       := "d" | "w" | "M" | "q" | "y"
-```
+### Accept spelling errors
 
-Examples:
+Set `typoMode` to `"tolerant"` for conservative correction:
 
-```text
-now/y
-now-1y/y
-now-1y/y+1M
-2025-01-01
-2025-01-01||+1M
+```ts
+const program = parseNatural("januray of last yaer", {
+  locale: "en",
+  typoMode: "tolerant",
+});
 ```
 
-Operations run from left to right. `/unit` floors to the start of the calendar unit. Fixed dates require `||` before operations.
+The successful value contains its `quality`, applied `corrections`, and any semantic `alternatives`. Strict mode is the default and does not correct the input.
+
+### Exclude future relative ranges
 
-## Resolve with an explicit time zone
+Set `allowFuture` to `false` to reject explicit relative future ranges:
 
 ```ts
-import { parseFilter, resolve } from "chronolizer";
-import { DateTime, Effect } from "effect";
+const program = parseNatural("next 3 months", {
+  locale: "en",
+  allowFuture: false,
+});
+```
 
-const run = Effect.fn(function* () {
-  const range = yield* parseFilter({ gte: "now/y", lte: "now" });
-  return yield* resolve(range);
-}, DateTime.withCurrentZoneNamed("Europe/Berlin"));
+This option rejects forms such as `next month`, `next 3 weeks`, and `in 3 years`. It keeps complete current calendar periods such as `today`, `this week`, and `this month`. It does not change them to period-to-date ranges.
 
-const program = run();
-```
+The option does not compare fixed dates, such as `January 2099`, with the current date. Parsing does not read the clock.
 
-The resolver uses Effect Clock and `DateTime.CurrentTimeZone`. It never uses the host local time zone without an explicit caller decision. Named zones use the runtime ICU time-zone data.
+The same option is available in `suggestNatural`.
 
-## Tolerant parsing
+### Resolve a range to dates
 
-```ts
-const program = parseNatural("januray of last yaer", {
-  locale: "en",
-  typoMode: "tolerant",
-});
-```
+Provide an Effect time zone when you resolve relative expressions:
 
-The result reports:
+```ts
+import { parseFilter, resolve } from "chronolizer";
+import { DateTime, Effect } from "effect";
 
-- `quality`: `exact`, `corrected`, or `ambiguous`;
-- each correction and edit distance;
-- semantic alternatives for equal-cost ties.
+const program = parseFilter({ gte: "now/y", lte: "now" }).pipe(
+  Effect.flatMap(resolve),
+  DateTime.withCurrentZoneNamed("Europe/Berlin"),
+);
 
-Strict mode never runs correction.
+Effect.runPromise(program);
+```
 
-## Language plugins
+`resolve` uses the Effect clock and `DateTime.CurrentTimeZone`. It does not use the host time zone without your decision.
 
-`LanguageRegistry` is an Effect service. A language is a scoped plugin contribution. `languagePluginsLayer` validates plugin identifiers, rejects conflicting base languages, applies deterministic extension order, and removes registrations when the Layer scope closes.
+### Validate an external filter
 
-Combine all required language plugins in one registry Layer:
+Use the exported Effect Schema before you parse unknown data:
 
 ```ts
-import { EnglishLanguage, languagePluginsLayer, parseNatural } from "chronolizer";
-import { GermanLanguage } from "chronolizer/locales/de";
-import { PolishLanguage } from "chronolizer/locales/pl";
-import { Effect } from "effect";
+import { DateFilter, parseFilter } from "chronolizer";
+import { Effect, Schema } from "effect";
 
-const Languages = languagePluginsLayer([EnglishLanguage, GermanLanguage, PolishLanguage]);
+const program = Schema.decodeUnknownEffect(DateFilter)(externalInput).pipe(
+  Effect.flatMap(parseFilter),
+);
 
-const program = parseNatural("letzten Monat", {
-  locale: "de",
-}).pipe(Effect.provide(Languages));
+Effect.runPromise(program);
 ```
 
-Importing a language plugin does not register it globally. Do not merge individual `*LanguageLayer` values for multi-language use because each one creates a separate registry. Use `languagePluginsLayer([...plugins])` instead.
+## Supported expressions
 
-Language identifiers use canonical BCP 47 base tags. Lookup removes one subtag at a time. For example, `zh-Hant-TW` tries `zh-Hant-TW`, `zh-Hant`, and then `zh`.
+Supported input families include:
 
-Each base language owns:
+- calendar days, weeks, months, quarters, and years;
+- rolling ranges, such as `last 3 months`;
+- calendar offsets, such as `30 months ago`;
+- period-to-date ranges, such as `year to date`;
+- fixed months, quarters, years, and explicit date intervals;
+- named days with or without a year, such as `January 12` and `12th of January`;
+- open ranges, such as `since January 2025` and `from January 12`;
+- compositional boundaries, such as `the day before January 12`;
+- period starts, period ends, and weekends;
+- abbreviated month names and common equivalent phrases.
 
-- exact parsing and canonical rendering;
-- autocomplete phrase generation;
-- optional text normalization;
-- its typo-correction strategy, which can be disabled;
-- vocabulary shared with registered language extensions.
+Examples:
 
-Language extensions can add both exact parsers and autocomplete phrases. The registry combines extension suggestions in the same deterministic order as extension parsers. The core accepts only suggestions that one of the compiled exact parsers can parse.
+| Input                               | Filter                                     |
+| ----------------------------------- | ------------------------------------------ |
+| `today`                             | `{ gte: "now/d", lt: "now/d+1d" }`         |
+| `last 3 months`                     | `{ gte: "now-3M", lte: "now" }`            |
+| `30 months ago`                     | `{ gte: "now-30M/M", lt: "now-30M/M+1M" }` |
+| `January 2025`                      | `{ gte: "2025-01-01", lt: "2025-02-01" }`  |
+| `January 12`                        | `{ gte: "now/y+11d", lt: "now/y+12d" }`    |
+| `Q1 2025`                           | `{ gte: "2025-01-01", lt: "2025-04-01" }`  |
+| `01 January 2025 - 31 January 2025` | `{ gte: "2025-01-01", lt: "2025-02-01" }`  |
+| `through January 2025`              | `{ lt: "2025-02-01" }`                     |
+
+## Supported languages
+
+| Language | Locale | Import                                    |
+| -------- | ------ | ----------------------------------------- |
+| English  | `en`   | `chronolizer` or `chronolizer/locales/en` |
+| German   | `de`   | `chronolizer/locales/de`                  |
+| Spanish  | `es`   | `chronolizer/locales/es`                  |
+| French   | `fr`   | `chronolizer/locales/fr`                  |
+| Dutch    | `nl`   | `chronolizer/locales/nl`                  |
+| Turkish  | `tr`   | `chronolizer/locales/tr`                  |
+| Czech    | `cs`   | `chronolizer/locales/cs`                  |
+| Polish   | `pl`   | `chronolizer/locales/pl`                  |
+
+## Date filter reference
+
+A date filter has at least one bound. It can have one lower bound and one upper bound.
+
+| Key   | Meaning                     |
+| ----- | --------------------------- |
+| `gt`  | After the value, exclusive  |
+| `gte` | On or after the value       |
+| `lt`  | Before the value, exclusive |
+| `lte` | On or before the value      |
+
+An expression starts with `now` or an ISO date. Operations run from left to right.
 
-`normalizeNaturalText` and `correctWhitespaceSeparatedText` are available for languages that use whitespace-separated words. A compact-script language can provide character, dictionary, or `Intl.Segmenter` based correction without changing Chronolizer core.
+```text
+expression := anchor operation*
+anchor     := "now" | YYYY-MM-DD | YYYY-MM-DD "||"
+operation  := ("+" | "-") positiveInteger unit | "/" unit
+unit       := "d" | "w" | "M" | "q" | "y"
+```
 
-Built-in plugins:
+`/unit` moves a value to the start of its calendar unit. Add `||` before operations on a fixed date, for example `2025-01-01||+1M`.
 
-- `EnglishLanguage`
-- `GermanLanguage`
-- `SpanishLanguage`
-- `FrenchLanguage`
-- `DutchLanguage`
-- `TurkishLanguage`
-- `CzechLanguage`
-- `PolishLanguage`
+Complete calendar periods use a half-open interval: the lower bound is inclusive and the next period start is exclusive. Weeks start on Monday.
 
-Import every non-English language from its locale subpath. This keeps the main bundle small and makes language selection explicit.
+A named day without a year uses the current calendar year. Write the year for February 29 because parsing does not read the clock.
 
-Chinese and Japanese language packs are not included yet.
+## Main API
 
-Business calendars, holidays, times of day, recurrence, and sentence extraction are outside v1. A future business-day feature will use an injected calendar service.
+| Export                | Purpose                                                             |
+| --------------------- | ------------------------------------------------------------------- |
+| `parseNatural`        | Parse complete natural-language input to a semantic range           |
+| `formatNatural`       | Render a supported range as a canonical phrase                      |
+| `suggestNatural`      | Return autocomplete suggestions and semantic ranges                 |
+| `parseFilter`         | Parse a date filter to a semantic range                             |
+| `formatFilter`        | Format a semantic range as a date filter                            |
+| `resolve`             | Resolve a semantic range with an Effect clock and time zone         |
+| `DateFilter`          | Validate external date-filter data with Effect Schema               |
+| `DateRangeFromFilter` | Decode and encode a filter through one Effect Schema transformation |
 
 ## License
 

package/dist/ast/constructors.d.mts

@@ -1,12 +1,7 @@
-import { InstantExpr, IsoDate, LowerBound, Shift, StartOf, Unit, UpperBound } from "./schemas.mjs";
+import { DateLiteral, InstantExpr, IsoDate, LowerBound, Now, Shift, StartOf, Unit, UpperBound } from "./schemas.mjs";
 //#region src/ast/constructors.d.ts
-declare const now: () => {
-  readonly _tag: "Now";
-};
-declare const dateLiteral: (value: IsoDate) => {
-  readonly _tag: "DateLiteral";
-  readonly value: string;
-};
+declare const now: () => Now;
+declare const dateLiteral: (value: IsoDate) => DateLiteral;
 declare const shift: (base: InstantExpr, amount: number, unit: Unit) => Shift;
 declare const startOf: (base: InstantExpr, unit: Unit) => StartOf;
 declare const greaterThan: (value: InstantExpr) => {

package/dist/ast/fold.d.mts

@@ -8,5 +8,6 @@ interface InstantAlgebra<A> {
 }
 declare const foldInstant: <A>(expression: InstantExpr, algebra: InstantAlgebra<A>) => A;
 declare const containsPositiveShift: (range: DateRangeExpr) => boolean;
+declare const isCurrentPeriod: (range: DateRangeExpr) => boolean;
 //#endregion
-export { InstantAlgebra, containsPositiveShift, foldInstant };
+export { InstantAlgebra, containsPositiveShift, foldInstant, isCurrentPeriod };

package/dist/ast/fold.mjs

@@ -1,36 +1,35 @@
+import { DateLiteral, GreaterThanOrEqual, LessThan, Now, Shift, StartOf } from "./schemas.mjs";
+import { Match, Schema, absurd } from "effect";
 //#region src/ast/fold.ts
+const isDateLiteral = Schema.is(DateLiteral);
+const isGreaterThanOrEqual = Schema.is(GreaterThanOrEqual);
+const isLessThan = Schema.is(LessThan);
+const isNow = Schema.is(Now);
+const isShift = Schema.is(Shift);
+const isStartOf = Schema.is(StartOf);
 const foldInstant = (expression, algebra) => {
-	switch (expression._tag) {
-		case "Now": return algebra.now();
-		case "DateLiteral": return algebra.dateLiteral(expression.value);
-		case "Shift": return algebra.shift(foldInstant(expression.base, algebra), expression.amount, expression.unit);
-		case "StartOf": return algebra.startOf(foldInstant(expression.base, algebra), expression.unit);
-	}
-};
-const shiftOffset = (base, amount, unit) => {
-	switch (unit) {
-		case "year": return {
-			...base,
-			months: base.months + amount * 12
-		};
-		case "quarter": return {
-			...base,
-			months: base.months + amount * 3
-		};
-		case "month": return {
-			...base,
-			months: base.months + amount
-		};
-		case "week": return {
-			...base,
-			days: base.days + amount * 7
-		};
-		case "day": return {
-			...base,
-			days: base.days + amount
-		};
-	}
+	if (isNow(expression)) return algebra.now();
+	if (isDateLiteral(expression)) return algebra.dateLiteral(expression.value);
+	if (isShift(expression)) return algebra.shift(foldInstant(expression.base, algebra), expression.amount, expression.unit);
+	if (isStartOf(expression)) return algebra.startOf(foldInstant(expression.base, algebra), expression.unit);
+	return absurd(expression);
 };
+const shiftOffset = (base, amount, unit) => Match.value(unit).pipe(Match.when("year", () => ({
+	...base,
+	months: base.months + amount * 12
+})), Match.when("quarter", () => ({
+	...base,
+	months: base.months + amount * 3
+})), Match.when("month", () => ({
+	...base,
+	months: base.months + amount
+})), Match.when("week", () => ({
+	...base,
+	days: base.days + amount * 7
+})), Match.when("day", () => ({
+	...base,
+	days: base.days + amount
+})), Match.exhaustive);
 const containsPositiveShiftInstant = (expression) => {
 	const offset = foldInstant(expression, {
 		now: () => ({
@@ -47,5 +46,13 @@ const containsPositiveShiftInstant = (expression) => {
 	return offset.months > 0 || offset.days > 0;
 };
 const containsPositiveShift = (range) => range.lower !== void 0 && containsPositiveShiftInstant(range.lower.value) || range.upper !== void 0 && containsPositiveShiftInstant(range.upper.value);
+const isCurrentPeriod = (range) => {
+	if (!isGreaterThanOrEqual(range.lower) || !isLessThan(range.upper)) return false;
+	const start = range.lower.value;
+	const end = range.upper.value;
+	if (!isStartOf(start) || !isNow(start.base) || !isShift(end)) return false;
+	if (end.amount !== 1 || !isStartOf(end.base) || !isNow(end.base.base)) return false;
+	return start.unit === end.unit && start.unit === end.base.unit;
+};
 //#endregion
-export { containsPositiveShift, foldInstant };
+export { containsPositiveShift, foldInstant, isCurrentPeriod };

package/dist/ast/normalize.mjs

@@ -1,6 +1,8 @@
+import { Shift } from "./schemas.mjs";
 import { boundedRange, dateLiteral, greaterThan, greaterThanOrEqual, lessThan, lessThanOrEqual, lowerOpenRange, now, shift, startOf, upperOpenRange } from "./constructors.mjs";
-import { Match } from "effect";
+import { Match, Schema } from "effect";
 //#region src/ast/normalize.ts
+const isShift = Schema.is(Shift);
 const normalizeInstant = (expression) => Match.valueTags(expression, {
 	Now: () => now(),
 	DateLiteral: (literal) => dateLiteral(literal.value),
@@ -8,7 +10,7 @@ const normalizeInstant = (expression) => Match.valueTags(expression, {
 	Shift: (operation) => {
 		const base = normalizeInstant(operation.base);
 		if (operation.amount === 0) return base;
-		if (base._tag === "Shift" && base.unit === operation.unit) {
+		if (isShift(base) && base.unit === operation.unit) {
 			const amount = base.amount + operation.amount;
 			if (Number.isSafeInteger(amount)) return normalizeInstant(shift(base.base, amount, operation.unit));
 		}

package/dist/ast/schemas.d.mts

@@ -2,35 +2,28 @@ import { Schema } from "effect";
 //#region src/ast/schemas.d.ts
 declare const Unit: Schema.Literals<readonly ["day", "week", "month", "quarter", "year"]>;
 type Unit = typeof Unit.Type;
-declare const daysInMonth: (year: number, month: number) => 28 | 29 | 30 | 31;
+declare const daysInMonth: (year: number, month: number) => number;
 declare const isIsoDate: (value: string) => boolean;
 declare const IsoDate: Schema.String;
 type IsoDate = typeof IsoDate.Type;
-interface Now {
-  readonly _tag: "Now";
-}
-interface DateLiteral {
-  readonly _tag: "DateLiteral";
-  readonly value: IsoDate;
-}
-interface Shift {
-  readonly _tag: "Shift";
-  readonly base: InstantExpr;
-  readonly amount: number;
-  readonly unit: Unit;
-}
-interface StartOf {
-  readonly _tag: "StartOf";
-  readonly base: InstantExpr;
-  readonly unit: Unit;
-}
-type InstantExpr = Now | DateLiteral | Shift | StartOf;
-declare const Now: Schema.TaggedStruct<"Now", {}>;
-declare const DateLiteral: Schema.TaggedStruct<"DateLiteral", {
+declare const Now_base: Schema.Class<Now, Schema.TaggedStruct<"Now", {}>, {}>;
+declare class Now extends Now_base {}
+declare const DateLiteral_base: Schema.Class<DateLiteral, Schema.TaggedStruct<"DateLiteral", {
   readonly value: Schema.String;
-}>;
-declare const Shift: Schema.Codec<Shift>;
-declare const StartOf: Schema.Codec<StartOf>;
+}>, {}>;
+declare class DateLiteral extends DateLiteral_base {}
+declare const Shift_base: Schema.Class<Shift, Schema.TaggedStruct<"Shift", {
+  readonly base: Schema.suspend<Schema.Codec<InstantExpr, InstantExpr, never, never>>;
+  readonly amount: Schema.Int;
+  readonly unit: Schema.Literals<readonly ["day", "week", "month", "quarter", "year"]>;
+}>, {}>;
+declare class Shift extends Shift_base {}
+declare const StartOf_base: Schema.Class<StartOf, Schema.TaggedStruct<"StartOf", {
+  readonly base: Schema.suspend<Schema.Codec<InstantExpr, InstantExpr, never, never>>;
+  readonly unit: Schema.Literals<readonly ["day", "week", "month", "quarter", "year"]>;
+}>, {}>;
+declare class StartOf extends StartOf_base {}
+type InstantExpr = Now | DateLiteral | Shift | StartOf;
 declare const InstantExpr: Schema.Codec<InstantExpr>;
 declare const GreaterThan: Schema.TaggedStruct<"GreaterThan", {
   readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;