chronolizer 0.1.0 → 0.2.0

package/dist/language/errors.d.mts

@@ -0,0 +1,38 @@
+import { Schema } from "effect";
+//#region src/language/errors.d.ts
+declare const UnsupportedLocaleError_base: Schema.Class<UnsupportedLocaleError, Schema.TaggedStruct<"UnsupportedLocaleError", {
+  readonly locale: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class UnsupportedLocaleError extends UnsupportedLocaleError_base {}
+declare const LanguageConflictError_base: Schema.Class<LanguageConflictError, Schema.TaggedStruct<"LanguageConflictError", {
+  readonly locale: Schema.String;
+  readonly firstPluginId: Schema.String;
+  readonly secondPluginId: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class LanguageConflictError extends LanguageConflictError_base {}
+declare const LanguageRegistrationError_base: Schema.Class<LanguageRegistrationError, Schema.TaggedStruct<"LanguageRegistrationError", {
+  readonly pluginId: Schema.String;
+  readonly locale: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class LanguageRegistrationError extends LanguageRegistrationError_base {}
+declare const NaturalLanguageParseError_base: Schema.Class<NaturalLanguageParseError, Schema.TaggedStruct<"NaturalLanguageParseError", {
+  readonly input: Schema.String;
+  readonly locale: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class NaturalLanguageParseError extends NaturalLanguageParseError_base {}
+declare const AmbiguousNaturalLanguageError_base: Schema.Class<AmbiguousNaturalLanguageError, Schema.TaggedStruct<"AmbiguousNaturalLanguageError", {
+  readonly input: Schema.String;
+  readonly locale: Schema.String;
+  readonly alternatives: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+declare class AmbiguousNaturalLanguageError extends AmbiguousNaturalLanguageError_base {}
+declare const NaturalLanguageRenderError_base: Schema.Class<NaturalLanguageRenderError, Schema.TaggedStruct<"NaturalLanguageRenderError", {
+  readonly locale: Schema.String;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class NaturalLanguageRenderError extends NaturalLanguageRenderError_base {}
+//#endregion
+export { AmbiguousNaturalLanguageError, LanguageConflictError, LanguageRegistrationError, NaturalLanguageParseError, NaturalLanguageRenderError, UnsupportedLocaleError };

package/dist/language/errors.mjs

@@ -0,0 +1,30 @@
+import { Schema } from "effect";
+//#region src/language/errors.ts
+var UnsupportedLocaleError = class extends Schema.TaggedError()("UnsupportedLocaleError", { locale: Schema.String }) {};
+var LanguageConflictError = class extends Schema.TaggedError()("LanguageConflictError", {
+	locale: Schema.String,
+	firstPluginId: Schema.String,
+	secondPluginId: Schema.String,
+	message: Schema.String
+}) {};
+var LanguageRegistrationError = class extends Schema.TaggedError()("LanguageRegistrationError", {
+	pluginId: Schema.String,
+	locale: Schema.String,
+	message: Schema.String
+}) {};
+var NaturalLanguageParseError = class extends Schema.TaggedError()("NaturalLanguageParseError", {
+	input: Schema.String,
+	locale: Schema.String,
+	message: Schema.String
+}) {};
+var AmbiguousNaturalLanguageError = class extends Schema.TaggedError()("AmbiguousNaturalLanguageError", {
+	input: Schema.String,
+	locale: Schema.String,
+	alternatives: Schema.Array(Schema.String)
+}) {};
+var NaturalLanguageRenderError = class extends Schema.TaggedError()("NaturalLanguageRenderError", {
+	locale: Schema.String,
+	message: Schema.String
+}) {};
+//#endregion
+export { AmbiguousNaturalLanguageError, LanguageConflictError, LanguageRegistrationError, NaturalLanguageParseError, NaturalLanguageRenderError, UnsupportedLocaleError };

package/dist/language/model.d.mts

@@ -0,0 +1,239 @@
+import { DateRangeExpr, InstantExpr } from "../ast/schemas.mjs";
+import { LanguageConflictError, LanguageRegistrationError } from "./errors.mjs";
+import { Effect, Option, Schema, Scope } from "effect";
+//#region src/language/model.d.ts
+declare const ParseQuality: Schema.Literals<readonly ["exact", "corrected", "ambiguous"]>;
+type ParseQuality = typeof ParseQuality.Type;
+declare const Correction: Schema.Struct<{
+  readonly original: Schema.String;
+  readonly replacement: Schema.String;
+  readonly distance: Schema.Int;
+  readonly offset: Schema.Int;
+}>;
+type Correction = typeof Correction.Type;
+declare const NaturalCorrectionCandidate: Schema.Struct<{
+  readonly text: Schema.String;
+  readonly corrections: Schema.$Array<Schema.Struct<{
+    readonly original: Schema.String;
+    readonly replacement: Schema.String;
+    readonly distance: Schema.Int;
+    readonly offset: Schema.Int;
+  }>>;
+  readonly cost: Schema.Int;
+}>;
+type NaturalCorrectionCandidate = typeof NaturalCorrectionCandidate.Type;
+declare const NaturalAlternative: Schema.Struct<{
+  readonly canonical: Schema.String;
+  readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.optionalKey<Schema.Never>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.optionalKey<Schema.Never>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>]>;
+}>;
+type NaturalAlternative = typeof NaturalAlternative.Type;
+declare const NaturalParseResult: Schema.Struct<{
+  readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.optionalKey<Schema.Never>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.optionalKey<Schema.Never>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>]>;
+  readonly quality: Schema.Literals<readonly ["exact", "corrected", "ambiguous"]>;
+  readonly corrections: Schema.$Array<Schema.Struct<{
+    readonly original: Schema.String;
+    readonly replacement: Schema.String;
+    readonly distance: Schema.Int;
+    readonly offset: Schema.Int;
+  }>>;
+  readonly alternatives: Schema.$Array<Schema.Struct<{
+    readonly canonical: Schema.String;
+    readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
+      readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>]>;
+      readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>, Schema.TaggedStruct<"LessThanOrEqual", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>]>;
+    }>, Schema.TaggedStruct<"DateRange", {
+      readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>]>;
+      readonly upper: Schema.optionalKey<Schema.Never>;
+    }>, Schema.TaggedStruct<"DateRange", {
+      readonly lower: Schema.optionalKey<Schema.Never>;
+      readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>, Schema.TaggedStruct<"LessThanOrEqual", {
+        readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+      }>]>;
+    }>]>;
+  }>>;
+}>;
+type NaturalParseResult = typeof NaturalParseResult.Type;
+declare const NaturalCandidate: Schema.Struct<{
+  readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.optionalKey<Schema.Never>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.optionalKey<Schema.Never>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>]>;
+  readonly canonical: Schema.String;
+}>;
+type NaturalCandidate = typeof NaturalCandidate.Type;
+declare const NaturalSuggestion: Schema.Struct<{
+  readonly text: Schema.String;
+  readonly range: Schema.Union<readonly [Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.Union<readonly [Schema.TaggedStruct<"GreaterThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"GreaterThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+    readonly upper: Schema.optionalKey<Schema.Never>;
+  }>, Schema.TaggedStruct<"DateRange", {
+    readonly lower: Schema.optionalKey<Schema.Never>;
+    readonly upper: Schema.Union<readonly [Schema.TaggedStruct<"LessThan", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>, Schema.TaggedStruct<"LessThanOrEqual", {
+      readonly value: Schema.Codec<InstantExpr, InstantExpr, never, never>;
+    }>]>;
+  }>]>;
+}>;
+type NaturalSuggestion = typeof NaturalSuggestion.Type;
+declare const BaseLanguageContribution_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
+  readonly _tag: "BaseLanguage";
+} & import("effect/Pipeable").Pipeable;
+declare class BaseLanguageContribution extends BaseLanguageContribution_base<{
+  readonly locale: string;
+  readonly vocabulary: ReadonlyArray<string>;
+  readonly normalize?: (input: string, locale: string) => string;
+  readonly correct?: (input: string, vocabulary: ReadonlyArray<string>) => ReadonlyArray<NaturalCorrectionCandidate>;
+  readonly parseExact: (input: string) => Option.Option<NaturalCandidate>;
+  readonly suggest?: (input: string, limit: number) => ReadonlyArray<string>;
+  readonly render: (range: DateRangeExpr) => Option.Option<string>;
+}> {}
+declare const LanguageExtensionContribution_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Readonly<A> & {
+  readonly _tag: "LanguageExtension";
+} & import("effect/Pipeable").Pipeable;
+declare class LanguageExtensionContribution extends LanguageExtensionContribution_base<{
+  readonly locale: string;
+  readonly priority: number;
+  readonly vocabulary: ReadonlyArray<string>;
+  readonly parseExact: (input: string) => Option.Option<NaturalCandidate>;
+  readonly suggest?: (input: string, limit: number) => ReadonlyArray<string>;
+}> {}
+type LanguageContribution = BaseLanguageContribution | LanguageExtensionContribution;
+declare const canonicalBaseLocale: (input: string) => Option.Option<string>;
+declare const Locale: Schema.String;
+declare const BaseLanguageMetadata: Schema.TaggedStruct<"BaseLanguage", {
+  readonly locale: Schema.String;
+  readonly vocabulary: Schema.$Array<Schema.String>;
+}>;
+declare const LanguageExtensionMetadata: Schema.TaggedStruct<"LanguageExtension", {
+  readonly locale: Schema.String;
+  readonly priority: Schema.Int;
+  readonly vocabulary: Schema.$Array<Schema.String>;
+}>;
+declare const LanguageContributionMetadata: Schema.Union<readonly [Schema.TaggedStruct<"BaseLanguage", {
+  readonly locale: Schema.String;
+  readonly vocabulary: Schema.$Array<Schema.String>;
+}>, Schema.TaggedStruct<"LanguageExtension", {
+  readonly locale: Schema.String;
+  readonly priority: Schema.Int;
+  readonly vocabulary: Schema.$Array<Schema.String>;
+}>]>;
+interface LanguagePluginContext {
+  readonly register: (pluginId: string, contribution: LanguageContribution) => Effect.Effect<void, LanguageRegistrationError | LanguageConflictError, Scope.Scope>;
+}
+interface LanguagePlugin {
+  readonly id: string;
+  readonly effect: (context: LanguagePluginContext) => Effect.Effect<void, LanguageRegistrationError | LanguageConflictError, Scope.Scope>;
+}
+interface CompiledLanguage {
+  readonly locale: string;
+  readonly vocabulary: ReadonlyArray<string>;
+  readonly normalize: (input: string, locale: string) => string;
+  readonly correct: ((input: string, vocabulary: ReadonlyArray<string>) => ReadonlyArray<NaturalCorrectionCandidate>) | undefined;
+  readonly parseExact: (input: string) => ReadonlyArray<NaturalCandidate>;
+  readonly suggest: (input: string, limit: number) => ReadonlyArray<string>;
+  readonly render: (range: DateRangeExpr) => Option.Option<string>;
+}
+//#endregion
+export { BaseLanguageContribution, BaseLanguageMetadata, CompiledLanguage, Correction, LanguageContribution, LanguageContributionMetadata, LanguageExtensionContribution, LanguageExtensionMetadata, LanguagePlugin, LanguagePluginContext, Locale, NaturalAlternative, NaturalCandidate, NaturalCorrectionCandidate, NaturalParseResult, NaturalSuggestion, ParseQuality, canonicalBaseLocale };

package/dist/language/model.mjs

@@ -0,0 +1,53 @@
+import { DateRangeExpr } from "../ast/schemas.mjs";
+import { Data, Option, Result, Schema } from "effect";
+//#region src/language/model.ts
+const ParseQuality = Schema.Literals([
+	"exact",
+	"corrected",
+	"ambiguous"
+]);
+const Correction = Schema.Struct({
+	original: Schema.String,
+	replacement: Schema.String,
+	distance: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+	offset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+});
+const NaturalCorrectionCandidate = Schema.Struct({
+	text: Schema.String,
+	corrections: Schema.Array(Correction),
+	cost: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))
+});
+const NaturalAlternative = Schema.Struct({
+	canonical: Schema.String,
+	range: DateRangeExpr
+});
+const NaturalParseResult = Schema.Struct({
+	range: DateRangeExpr,
+	quality: ParseQuality,
+	corrections: Schema.Array(Correction),
+	alternatives: Schema.Array(NaturalAlternative)
+});
+const NaturalCandidate = Schema.Struct({
+	range: DateRangeExpr,
+	canonical: Schema.String
+});
+const NaturalSuggestion = Schema.Struct({
+	text: Schema.String,
+	range: DateRangeExpr
+});
+var BaseLanguageContribution = class extends Data.TaggedClass("BaseLanguage") {};
+var LanguageExtensionContribution = class extends Data.TaggedClass("LanguageExtension") {};
+const canonicalBaseLocale = (input) => Result.getSuccess(Result.try(() => new Intl.Locale(input).baseName));
+const Locale = Schema.String.check(Schema.makeFilter((value) => Option.contains(canonicalBaseLocale(value), value), { expected: "a canonical BCP 47 base locale identifier" })).annotate({ identifier: "Locale" });
+const BaseLanguageMetadata = Schema.TaggedStruct("BaseLanguage", {
+	locale: Locale,
+	vocabulary: Schema.Array(Schema.String)
+});
+const LanguageExtensionMetadata = Schema.TaggedStruct("LanguageExtension", {
+	locale: Locale,
+	priority: Schema.Int,
+	vocabulary: Schema.Array(Schema.String)
+});
+const LanguageContributionMetadata = Schema.Union([BaseLanguageMetadata, LanguageExtensionMetadata]);
+//#endregion
+export { BaseLanguageContribution, BaseLanguageMetadata, Correction, LanguageContributionMetadata, LanguageExtensionContribution, LanguageExtensionMetadata, Locale, NaturalAlternative, NaturalCandidate, NaturalCorrectionCandidate, NaturalParseResult, NaturalSuggestion, ParseQuality, canonicalBaseLocale };

package/dist/language/registry.d.mts

@@ -0,0 +1,17 @@
+import { LanguageConflictError, LanguageRegistrationError, UnsupportedLocaleError } from "./errors.mjs";
+import { CompiledLanguage, LanguageContribution, LanguagePlugin } from "./model.mjs";
+import { Context, Effect, Layer, Scope } from "effect";
+//#region src/language/registry.d.ts
+declare namespace LanguageRegistry {
+  interface Service {
+    readonly register: (pluginId: string, contribution: LanguageContribution) => Effect.Effect<void, LanguageRegistrationError | LanguageConflictError, Scope.Scope>;
+    readonly resolve: (locale: string) => Effect.Effect<CompiledLanguage, UnsupportedLocaleError>;
+  }
+}
+declare const LanguageRegistry_base: Context.ServiceClass<LanguageRegistry, "chronolizer/LanguageRegistry", LanguageRegistry.Service>;
+declare class LanguageRegistry extends LanguageRegistry_base {}
+declare const LanguageRegistryLayer: Layer.Layer<LanguageRegistry, never, never>;
+declare const languagePluginsLayer: (plugins: ReadonlyArray<LanguagePlugin>) => Layer.Layer<LanguageRegistry, LanguageConflictError | LanguageRegistrationError, never>;
+declare const defineLanguagePlugin: (plugin: LanguagePlugin) => LanguagePlugin;
+//#endregion
+export { LanguageRegistry, LanguageRegistryLayer, defineLanguagePlugin, languagePluginsLayer };

package/dist/language/registry.mjs

@@ -0,0 +1,134 @@
+import { LanguageConflictError, LanguageRegistrationError, UnsupportedLocaleError } from "./errors.mjs";
+import { BaseLanguageMetadata, LanguageContributionMetadata, LanguageExtensionMetadata, canonicalBaseLocale } from "./model.mjs";
+import { normalizeNaturalText } from "../natural/text.mjs";
+import { Array, Context, Effect, Layer, Match, Option, Order, Ref, Result, Schema } from "effect";
+//#region src/language/registry.ts
+var LanguageRegistry = class extends Context.Service()("chronolizer/LanguageRegistry") {};
+const metadataOf = (contribution) => Match.valueTags(contribution, {
+	BaseLanguage: (base) => BaseLanguageMetadata.make({
+		locale: base.locale,
+		vocabulary: base.vocabulary
+	}),
+	LanguageExtension: (extension) => LanguageExtensionMetadata.make({
+		locale: extension.locale,
+		priority: extension.priority,
+		vocabulary: extension.vocabulary
+	})
+});
+const localeCandidates = (locale) => {
+	const candidates = [locale];
+	let parent = locale;
+	while (parent.includes("-")) {
+		parent = parent.slice(0, parent.lastIndexOf("-"));
+		candidates.push(parent);
+	}
+	return candidates;
+};
+const compileLanguage = (locale, registered) => {
+	const locales = localeCandidates(locale);
+	const base = Array.sort(Array.filterMap(registered, (entry) => Match.valueTags(entry.contribution, {
+		BaseLanguage: (contribution) => locales.includes(contribution.locale) ? Result.succeed({
+			pluginId: entry.pluginId,
+			contribution
+		}) : Result.failVoid,
+		LanguageExtension: () => Result.failVoid
+	})), Order.mapInput(Order.Number, (entry) => locales.indexOf(entry.contribution.locale)))[0];
+	if (base === void 0) return Option.none();
+	const extensions = Array.sort(Array.filterMap(registered, (entry) => Match.valueTags(entry.contribution, {
+		BaseLanguage: () => Result.failVoid,
+		LanguageExtension: (contribution) => locales.includes(contribution.locale) ? Result.succeed({
+			pluginId: entry.pluginId,
+			contribution
+		}) : Result.failVoid
+	})), Order.combine(Order.mapInput(Order.flip(Order.Number), (entry) => entry.contribution.priority), Order.mapInput(Order.String, (entry) => entry.pluginId)));
+	const vocabulary = Object.freeze(Array.dedupe([...base.contribution.vocabulary, ...Array.flatMap(extensions, (entry) => entry.contribution.vocabulary)]));
+	const parsers = Object.freeze([...extensions.map((entry) => entry.contribution.parseExact), base.contribution.parseExact]);
+	const suggesters = Object.freeze([...extensions.map((entry) => entry.contribution.suggest), base.contribution.suggest].filter((suggest) => suggest !== void 0));
+	const parseExact = (input) => {
+		const candidates = [];
+		for (const parser of parsers) {
+			const candidate = parser(input);
+			if (Option.isSome(candidate)) candidates.push(candidate.value);
+		}
+		return candidates;
+	};
+	return Option.some(Object.freeze({
+		locale: base.contribution.locale,
+		vocabulary,
+		normalize: base.contribution.normalize ?? normalizeNaturalText,
+		correct: base.contribution.correct,
+		parseExact,
+		suggest: (input, limit) => Array.flatMap(suggesters, (suggest) => suggest(input, limit)),
+		render: base.contribution.render
+	}));
+};
+const createRegistry = Effect.fn(function* () {
+	const entries = yield* Ref.make([]);
+	const register = Effect.fn(function* (pluginId, contribution) {
+		if (pluginId.length === 0 || !Schema.is(LanguageContributionMetadata)(metadataOf(contribution))) return yield* new LanguageRegistrationError({
+			pluginId,
+			locale: contribution.locale,
+			message: "Invalid plugin identifier or contribution metadata"
+		});
+		const token = Symbol(pluginId);
+		yield* Effect.acquireRelease(Ref.modify(entries, (current) => {
+			const conflictingBase = Match.valueTags(contribution, {
+				BaseLanguage: (base) => Array.findFirst(current, (entry) => Match.valueTags(entry.contribution, {
+					BaseLanguage: (registeredBase) => registeredBase.locale === base.locale,
+					LanguageExtension: () => false
+				})),
+				LanguageExtension: () => Option.none()
+			});
+			return Option.match(conflictingBase, {
+				onNone: () => [Result.succeed(token), Array.append(current, {
+					token,
+					pluginId,
+					contribution
+				})],
+				onSome: (conflict) => [Result.fail(new LanguageConflictError({
+					locale: contribution.locale,
+					firstPluginId: conflict.pluginId,
+					secondPluginId: pluginId,
+					message: "Only one base language can be registered for a locale"
+				})), current]
+			});
+		}).pipe(Effect.flatMap((result) => Effect.fromResult(result))), (registeredToken) => Ref.update(entries, (items) => Array.filter(items, (entry) => entry.token !== registeredToken)));
+	});
+	const resolve = Effect.fn(function* (locale) {
+		const canonical = canonicalBaseLocale(locale);
+		if (Option.isSome(canonical)) {
+			const compiled = compileLanguage(canonical.value, yield* Ref.get(entries));
+			if (Option.isSome(compiled)) return compiled.value;
+		}
+		return yield* new UnsupportedLocaleError({ locale });
+	});
+	return LanguageRegistry.of({
+		register,
+		resolve
+	});
+});
+const LanguageRegistryLayer = Layer.effect(LanguageRegistry, createRegistry());
+const duplicatePluginId = (plugins) => {
+	const ids = /* @__PURE__ */ new Set();
+	for (const plugin of plugins) {
+		if (ids.has(plugin.id)) return plugin.id;
+		ids.add(plugin.id);
+	}
+};
+const createPluginRegistry = Effect.fn(function* (plugins) {
+	const duplicate = duplicatePluginId(plugins);
+	if (duplicate !== void 0) return yield* new LanguageRegistrationError({
+		pluginId: duplicate,
+		locale: "*",
+		message: "Plugin identifiers must be unique"
+	});
+	const registry = yield* createRegistry();
+	const context = { register: registry.register };
+	const ordered = Array.sortWith(plugins, (plugin) => plugin.id, Order.String);
+	for (const plugin of ordered) yield* plugin.effect(context);
+	return registry;
+});
+const languagePluginsLayer = (plugins) => Layer.effect(LanguageRegistry, createPluginRegistry(plugins));
+const defineLanguagePlugin = (plugin) => plugin;
+//#endregion
+export { LanguageRegistry, LanguageRegistryLayer, defineLanguagePlugin, languagePluginsLayer };

package/dist/locales/cs.d.mts

@@ -0,0 +1,10 @@
+import { LanguageConflictError, LanguageRegistrationError } from "../language/errors.mjs";
+import { BaseLanguageContribution, LanguagePlugin } from "../language/model.mjs";
+import { LanguageRegistry } from "../language/registry.mjs";
+import "../index.mjs";
+//#region src/locales/cs.d.ts
+declare const CzechContribution: BaseLanguageContribution;
+declare const CzechLanguage: LanguagePlugin;
+declare const CzechLanguageLayer: import("effect/Layer").Layer<LanguageRegistry, LanguageConflictError | LanguageRegistrationError, never>;
+//#endregion
+export { CzechContribution, CzechLanguage, CzechLanguageLayer };