@effected/toml 0.1.0 → 0.3.0

package/README.md

@@ -3,9 +3,9 @@
 [![npm](https://img.shields.io/npm/v/@effected%2Ftoml?label=npm&color=cb3837)](https://www.npmjs.com/package/@effected/toml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-4caf50.svg)](https://opensource.org/licenses/MIT)
 [![Node.js %3E%3D24.11.0](https://img.shields.io/badge/Node.js-%3E%3D24.11.0-5fa04e.svg)](https://nodejs.org/)
-[![TypeScript 6.0](https://img.shields.io/badge/TypeScript-6.0-3178c6.svg)](https://www.typescriptlang.org/)
+[![TypeScript 7.0](https://img.shields.io/badge/TypeScript-7.0-3178c6.svg)](https://www.typescriptlang.org/)
 
-Zero-dependency TOML 1.0.0 parsing, editing and formatting expressed as Effect schemas and pure functions. Parse TOML into plain values or a byte-exact linear CST, compute comment-preserving edits, format, modify by path, walk a document as a `Stream`, and decode straight into a validated domain schema.
+Zero-dependency TOML 1.1.0 parsing, editing and formatting expressed as Effect schemas and pure functions. Parse TOML into plain values or a byte-exact linear CST, compute comment-preserving edits, format, modify by path, walk a document as a `Stream`, and decode straight into a validated domain schema.
 
 > **Pre-release.** This package is part of the `@effected/*` kit, in pre-`1.0.0`
 > development against a single pinned Effect v4 beta. Packages graduate to
@@ -23,7 +23,7 @@ Zero-dependency TOML 1.0.0 parsing, editing and formatting expressed as Effect s
 
 TOML is the config format behind `Cargo.toml`, `pyproject.toml` and a large share of the Rust and Python toolchains — files that people maintain by hand and comment heavily. Most JavaScript TOML libraries round-trip through a plain-object model, which loses every comment and blank line the moment you write the file back out.
 
-The engine here is written from scratch against the TOML 1.0.0 spec, and it is the only format package in this repo that vendors no upstream code at all. It parses into a lossless linear CST whose expression spans tile the source byte-exact, so `TomlDocument.parse(text).stringify()` reproduces the original text exactly for any valid document. There is no separate re-serialization path that can drift from the source. Edits are byte-minimal splices against that CST, so formatting and path-based modification preserve every comment and every byte you did not touch.
+The engine here is written from scratch against the TOML 1.1.0 spec, and it is the only format package in this repo that vendors no upstream code at all. Parsing accepts everything 1.1 added — newlines, comments and trailing commas inside inline tables, optional seconds in times, and the `\e` and `\xHH` string escapes — while `Toml.stringify` deliberately emits 1.0 spellings, which are valid 1.1, so documents this package writes stay readable by 1.0-only consumers. It parses into a lossless linear CST whose expression spans tile the source byte-exact, so `TomlDocument.parse(text).stringify()` reproduces the original text exactly for any valid document. There is no separate re-serialization path that can drift from the source. Edits are byte-minimal splices against that CST, so formatting and path-based modification preserve every comment and every byte you did not touch.
 
 The value model is honest about TOML's types rather than flattening them into JavaScript's. Integers past ±(2^53 − 1) decode to `bigint` instead of silently losing precision, and TOML's four date-time types decode to four calendar-validated value classes instead of a `Date` that cannot represent a local time. TOML has no null, so `Toml.stringify` on a value containing `null` fails with a structured `UnsupportedValue` diagnostic naming the offending path rather than dropping the key. Every fallible entry point carries a typed error built from `TomlDiagnostic`, and nesting-depth guards on both the parse and the stringify side mean hostile input fails through that channel rather than as a stack overflow.
 
@@ -39,6 +39,8 @@ pnpm add @effected/toml effect
 
 Requires Node.js >=24.11.0. `effect` v4 is a peer dependency; the package itself adds no other runtime dependencies.
 
+All `@effected/*` packages are ESM-only: the exports maps publish only `import` conditions, so `require()` — including tools that resolve in CJS mode — fails with Node's `ERR_PACKAGE_PATH_NOT_EXPORTED` rather than loading a CJS build that does not exist. Import from an ES module.
+
 ## Quick start
 
 Compose your schema with `Toml.schema` to decode TOML straight into a validated domain value, or reach for the pre-bound `Toml.TomlFromString` codec when you just want the plain value:
@@ -133,7 +135,7 @@ Effect.runPromise(Effect.result(Toml.stringify({ a: null }))).then(console.log);
 
 ## Conformance
 
-The engine runs the [toml-test](https://github.com/toml-lang/toml-test) 1.0.0 compliance corpus — every valid case and every invalid case — to a 100% pass rate with no skip list, and a differential property suite cross-checks it against an independent TOML parser. Both oracles are devDependency-only; neither reaches your runtime.
+The engine runs the [toml-test](https://github.com/toml-lang/toml-test) compliance corpus — its `files-toml-1.1.0` subset, 214 valid cases and 467 invalid ones — to a 100% pass rate with no skip list, and a differential property suite cross-checks it against an independent TOML parser. Both oracles are devDependency-only; neither reaches your runtime.
 
 ## License
 

package/Toml.js

@@ -4,13 +4,20 @@ import { parseExpressions } from "./internal/parser.js";
 import { buildValue } from "./internal/semantic.js";
 import { stringifyValue } from "./internal/stringifyValue.js";
 import { TomlDiagnostic } from "./TomlDiagnostic.js";
-import { Effect, Option, Schema, SchemaIssue, SchemaTransformation } from "effect";
+import { Effect, Option, Result, Schema, SchemaIssue, SchemaTransformation } from "effect";
 
 //#region src/Toml.ts
 /**
 * Options controlling stringify behavior. The only knob is `newline` —
 * omitted, it resolves to `"\n"`.
 *
+* @remarks
+* Stringify deliberately emits only TOML 1.0.0 spellings — seconds always
+* present in times, no `\e`/`\xHH` escapes, single-line inline tables — even
+* though {@link Toml.parse} accepts the full TOML 1.1.0 grammar. Every 1.0
+* document is valid 1.1, so this conservative-write/liberal-read asymmetry
+* keeps emitted documents readable by 1.0-only consumers.
+*
 * @public
 */
 var TomlStringifyOptions = class extends Schema.Class("TomlStringifyOptions")({ newline: Schema.optionalKey(Schema.Literals(["\n", "\r\n"])) }) {};
@@ -47,34 +54,38 @@ var TomlStringifyError = class extends Schema.TaggedErrorClass()("TomlStringifyE
 * Run the parser and semantic pass, materializing the engine's raw carriers
 * into the typed error: `RawTomlError` becomes a positioned diagnostic and a
 * `GuardExceeded` depth trip becomes a `NestingDepthExceeded` diagnostic
-* (never an unhandled defect). Anything else is a genuine defect and rethrows.
+* (never an unhandled defect). Anything else is a genuine defect and rethrows
+* — synchronously to a `Result` caller, and as a `Die` through the `Effect`
+* forms, which evaluate this inside the effect.
 */
-const parseOrFail = (text) => Effect.try({
-	try: () => buildValue(parseExpressions(text)),
-	catch: (defect) => {
-		if (isRawTomlError(defect)) return new TomlParseError({ diagnostics: [TomlDiagnostic.fromRaw(text, defect.diagnostic)] });
-		if (isGuardExceeded(defect)) return new TomlParseError({ diagnostics: [TomlDiagnostic.fromRaw(text, {
+const parseToResult = (text) => {
+	try {
+		return Result.succeed(buildValue(parseExpressions(text)));
+	} catch (defect) {
+		if (isRawTomlError(defect)) return Result.fail(new TomlParseError({ diagnostics: [TomlDiagnostic.fromRaw(text, defect.diagnostic)] }));
+		if (isGuardExceeded(defect)) return Result.fail(new TomlParseError({ diagnostics: [TomlDiagnostic.fromRaw(text, {
 			code: "NestingDepthExceeded",
 			message: defect.message,
 			offset: defect.offset,
 			length: 0
-		})] });
+		})] }));
 		throw defect;
 	}
-});
-const stringifyOrFail = (value, options) => Effect.try({
-	try: () => stringifyValue(value, options?.newline ?? "\n"),
-	catch: (defect) => {
-		if (isRawTomlError(defect)) return new TomlStringifyError({ diagnostic: TomlDiagnostic.fromRaw("", defect.diagnostic) });
-		if (isGuardExceeded(defect)) return new TomlStringifyError({ diagnostic: TomlDiagnostic.fromRaw("", {
+};
+const stringifyToResult = (value, options) => {
+	try {
+		return Result.succeed(stringifyValue(value, options?.newline ?? "\n"));
+	} catch (defect) {
+		if (isRawTomlError(defect)) return Result.fail(new TomlStringifyError({ diagnostic: TomlDiagnostic.fromRaw("", defect.diagnostic) }));
+		if (isGuardExceeded(defect)) return Result.fail(new TomlStringifyError({ diagnostic: TomlDiagnostic.fromRaw("", {
 			code: "NestingDepthExceeded",
 			message: defect.message,
 			offset: 0,
 			length: 0
-		}) });
+		}) }));
 		throw defect;
 	}
-});
+};
 /**
 * Static entry points for TOML parsing, stringification and the schema
 * factories. Not instantiable.
@@ -84,7 +95,7 @@ const stringifyOrFail = (value, options) => Effect.try({
 * channels — including the hardening guards (nesting-depth caps on both
 * sides, circular-reference detection on encode) that keep malformed or
 * adversarial input on the typed channel instead of surfacing as an
-* unhandled defect. `parse` takes no options: TOML 1.0.0 parsing has no
+* unhandled defect. `parse` takes no options: TOML 1.1.0 parsing has no
 * knobs.
 *
 * @example
@@ -103,32 +114,110 @@ const stringifyOrFail = (value, options) => Effect.try({
 var Toml = class Toml {
 	constructor() {}
 	/**
-	* Parse a TOML 1.0.0 document into a plain JavaScript value: tables and
-	* inline tables become plain objects (`__proto__` lands as an own data
-	* property), arrays become plain arrays, integers become `number` (or
-	* `bigint` past 2^53) and date-times become the four `TomlDateTime`
-	* classes. Fails with {@link TomlParseError} at the first violation;
-	* returns `unknown`, never `any`.
+	* Parse a TOML 1.1.0 document into a plain JavaScript value, synchronously,
+	* returning a `Result` instead of an `Effect`: tables and inline tables
+	* become plain objects (`__proto__` lands as an own data property), arrays
+	* become plain arrays, integers become `number` (or `bigint` past 2^53) and
+	* date-times become the four `TomlDateTime` classes. Fails with
+	* {@link TomlParseError} at the first violation; returns `unknown`, never
+	* `any`.
 	*
 	* A nesting-depth bomb (arrays or inline tables past the engine cap) also
 	* fails through {@link TomlParseError} with a `NestingDepthExceeded`
 	* diagnostic, never as an unhandled defect.
+	*
+	* @remarks
+	* {@link Toml.parse} is defined in terms of this function; the two never
+	* diverge. Reach for the `Effect` variant inside Effect code — it carries
+	* the `Toml.parse` tracing span — and for this one at synchronous
+	* boundaries such as a lint-staged handler.
+	*
+	* @example
+	* ```ts
+	* import { Toml } from "@effected/toml";
+	* import { Result } from "effect";
+	*
+	* const ok = Toml.parseResult('name = "Alice"');
+	* if (Result.isSuccess(ok)) {
+	*   console.log(ok.success); // => { name: "Alice" }
+	* }
+	*
+	* const bad = Toml.parseResult("name = ");
+	* if (Result.isFailure(bad)) {
+	*   console.log(bad.failure._tag); // => "TomlParseError"
+	* }
+	* ```
+	*
+	* @param text - The TOML source to parse.
+	* @returns A `Result` succeeding with the decoded value (`unknown`, never
+	*   `any`), or failing with {@link TomlParseError}.
+	*/
+	static parseResult(text) {
+		return parseToResult(text);
+	}
+	/**
+	* Parse a TOML 1.1.0 document into a plain JavaScript value. Defined in
+	* terms of {@link Toml.parseResult} — synchronous callers can use that
+	* variant directly.
+	*
+	* @param text - The TOML source to parse.
+	* @returns An `Effect` that succeeds with the decoded value, or fails with
+	*   {@link TomlParseError}.
 	*/
-	static parse = Effect.fn("Toml.parse")(function* (text) {
-		return yield* parseOrFail(text);
-	});
+	static parse = Effect.fn("Toml.parse")((text) => Effect.fromResult(Toml.parseResult(text)));
 	/**
-	* Stringify a plain JavaScript value as a canonical TOML document: within
-	* a table, non-table pairs first, then sub-tables as `[dotted.header]`
+	* Stringify a plain JavaScript value as a canonical TOML document,
+	* synchronously, returning a `Result` instead of an `Effect`: within a
+	* table, non-table pairs first, then sub-tables as `[dotted.header]`
 	* sections depth-first, then arrays of tables as `[[dotted.header]]`
 	* sections, a blank line before every header except at document start.
 	* Fails with {@link TomlStringifyError} on unsupported values (TOML has no
 	* null), out-of-int64-range `bigint`s, circular references and
 	* depth-guard trips — all on the typed channel.
+	*
+	* @remarks
+	* {@link Toml.stringify} is defined in terms of this function; the two
+	* never diverge. Reach for the `Effect` variant inside Effect code — it
+	* carries the `Toml.stringify` tracing span — and for this one at
+	* synchronous boundaries.
+	*
+	* @example
+	* ```ts
+	* import { Toml } from "@effected/toml";
+	* import { Result } from "effect";
+	*
+	* const ok = Toml.stringifyResult({ name: "Alice" });
+	* if (Result.isSuccess(ok)) {
+	*   console.log(ok.success); // => 'name = "Alice"\n'
+	* }
+	*
+	* const bad = Toml.stringifyResult({ nope: null });
+	* if (Result.isFailure(bad)) {
+	*   console.log(bad.failure._tag); // => "TomlStringifyError"
+	* }
+	* ```
+	*
+	* @param value - The plain JavaScript value to stringify.
+	* @param options - Optional {@link TomlStringifyOptions}; `newline`
+	*   defaults to `"\n"`.
+	* @returns A `Result` succeeding with the TOML text, or failing with
+	*   {@link TomlStringifyError}.
+	*/
+	static stringifyResult(value, options) {
+		return stringifyToResult(value, options);
+	}
+	/**
+	* Stringify a plain JavaScript value as a canonical TOML document. Defined
+	* in terms of {@link Toml.stringifyResult} — synchronous callers can use
+	* that variant directly.
+	*
+	* @param value - The plain JavaScript value to stringify.
+	* @param options - Optional {@link TomlStringifyOptions}; `newline`
+	*   defaults to `"\n"`.
+	* @returns An `Effect` that succeeds with the TOML text, or fails with
+	*   {@link TomlStringifyError}.
 	*/
-	static stringify = Effect.fn("Toml.stringify")(function* (value, options) {
-		return yield* stringifyOrFail(value, options);
-	});
+	static stringify = Effect.fn("Toml.stringify")((value, options) => Effect.fromResult(Toml.stringifyResult(value, options)));
 	/**
 	* A `Schema<unknown, string>` decoding a TOML document and encoding values
 	* back to canonical TOML text.
@@ -140,7 +229,7 @@ var Toml = class Toml {
 	static fromString() {
 		return Schema.String.pipe(Schema.decodeTo(Schema.Unknown, SchemaTransformation.transformOrFail({
 			decode: (input) => Toml.parse(input).pipe(Effect.mapError((error) => new SchemaIssue.InvalidValue(Option.some(input), { message: error.message }))),
-			encode: (value) => stringifyOrFail(value).pipe(Effect.mapError((error) => new SchemaIssue.InvalidValue(Option.some(value), { message: error.message })))
+			encode: (value) => Effect.fromResult(Toml.stringifyResult(value)).pipe(Effect.mapError((error) => new SchemaIssue.InvalidValue(Option.some(value), { message: error.message })))
 		})));
 	}
 	/**
@@ -159,6 +248,49 @@ var Toml = class Toml {
 	static schema(target) {
 		return Toml.TomlFromString.pipe(Schema.decodeTo(target));
 	}
+	/**
+	* Bind a target schema to the TOML codec once, yielding the composed
+	* schema plus pre-derived `decode`/`encode` directions — the
+	* {@link Toml.schema} composition without the generic `Schema` machinery
+	* at every use site. Binds the plain form only: TOML 1.1.0 parsing on
+	* decode, default stringify options on encode.
+	*
+	* Both directions fail with `Schema.SchemaError`, exactly as
+	* `Schema.decodeEffect`/`Schema.encodeEffect` over {@link Toml.schema}
+	* would; the target's decoding/encoding service requirements flow through.
+	*
+	* @remarks
+	* Schema-producing: each call composes a fresh schema and derives both
+	* directions from it. Bind the result to a `const` — that single binding is
+	* the point.
+	*
+	* @example
+	* ```ts
+	* import { Toml } from "@effected/toml";
+	* import { Effect, Schema } from "effect";
+	*
+	* const Config = Schema.Struct({ name: Schema.String });
+	* const config = Toml.bind(Config);
+	*
+	* const program = Effect.gen(function* () {
+	*   const value = yield* config.decode('name = "Alice"');
+	*   const text = yield* config.encode(value);
+	*   return [value, text] as const;
+	* });
+	* ```
+	*
+	* @param target - The domain schema decoded values must satisfy.
+	* @returns A {@link TomlBoundCodec} carrying the composed schema and its
+	*   two pre-bound directions.
+	*/
+	static bind(target) {
+		const schema = Toml.schema(target);
+		return {
+			schema,
+			decode: Schema.decodeEffect(schema),
+			encode: Schema.encodeEffect(schema)
+		};
+	}
 };
 
 //#endregion

package/TomlNode.js

@@ -98,7 +98,7 @@ var TomlDateTimeLiteral = class extends Schema.TaggedClass()("TomlDateTimeLitera
 	length: Schema.Number
 }) {};
 /**
-* An array value node. Heterogeneous per TOML 1.0.0; may span multiple lines
+* An array value node. Heterogeneous per TOML; may span multiple lines
 * (the span covers brackets, inner newlines and inner comments).
 *
 * @public
@@ -121,7 +121,8 @@ var TomlInlineEntry = class extends Schema.TaggedClass()("TomlInlineEntry", {
 	length: Schema.Number
 }) {};
 /**
-* An inline table value node (`{ k = v, ... }`). Single-line by grammar.
+* An inline table value node (`{ k = v, ... }`). May span multiple lines
+* since TOML 1.1 (the span covers braces, inner newlines and inner comments).
 *
 * @public
 */

package/index.d.ts

@@ -1,4 +1,4 @@
-import { Data, Effect, Schema, Stream } from "effect";
+import { Data, Effect, Result, Schema, Stream } from "effect";
 //#region src/TomlDiagnostic.d.ts
 /**
  * Error codes emitted by the lexer stage.
@@ -17,7 +17,7 @@ type TomlLexErrorCode = typeof TomlLexErrorCode.Type;
  *
  * @public
  */
-declare const TomlParseErrorCode: Schema.Literals<readonly ["ExpectedKey", "ExpectedEquals", "ExpectedValue", "ExpectedNewline", "ExpectedTableHeaderClose", "UnterminatedArray", "UnterminatedInlineTable", "TrailingCommaInInlineTable", "NewlineInInlineTable", "InvalidValue", "InvalidNumber", "IntegerOutOfRange", "InvalidDateTime", "NestingDepthExceeded"]>;
+declare const TomlParseErrorCode: Schema.Literals<readonly ["ExpectedKey", "ExpectedEquals", "ExpectedValue", "ExpectedNewline", "ExpectedTableHeaderClose", "UnterminatedArray", "UnterminatedInlineTable", "InvalidValue", "InvalidNumber", "IntegerOutOfRange", "InvalidDateTime", "NestingDepthExceeded"]>;
 /**
  * The union of all parser-stage error code string literals.
  *
@@ -54,7 +54,7 @@ type TomlStringifyErrorCode = typeof TomlStringifyErrorCode.Type;
  *
  * @public
  */
-declare const TomlErrorCode: Schema.Union<readonly [Schema.Literals<readonly ["InvalidUtf8", "UnterminatedString", "InvalidEscape", "InvalidUnicodeEscape", "ControlCharacterInString", "ControlCharacterInComment", "InvalidCharacter", "BareCarriageReturn"]>, Schema.Literals<readonly ["ExpectedKey", "ExpectedEquals", "ExpectedValue", "ExpectedNewline", "ExpectedTableHeaderClose", "UnterminatedArray", "UnterminatedInlineTable", "TrailingCommaInInlineTable", "NewlineInInlineTable", "InvalidValue", "InvalidNumber", "IntegerOutOfRange", "InvalidDateTime", "NestingDepthExceeded"]>, Schema.Literals<readonly ["DuplicateKey", "TableRedefined", "ArrayOfTablesConflict", "DottedKeyConflict", "InlineTableExtended"]>, Schema.Literals<readonly ["CircularReference", "UnsupportedValue", "IntegerOutOfRange", "NestingDepthExceeded"]>]>;
+declare const TomlErrorCode: Schema.Union<readonly [Schema.Literals<readonly ["InvalidUtf8", "UnterminatedString", "InvalidEscape", "InvalidUnicodeEscape", "ControlCharacterInString", "ControlCharacterInComment", "InvalidCharacter", "BareCarriageReturn"]>, Schema.Literals<readonly ["ExpectedKey", "ExpectedEquals", "ExpectedValue", "ExpectedNewline", "ExpectedTableHeaderClose", "UnterminatedArray", "UnterminatedInlineTable", "InvalidValue", "InvalidNumber", "IntegerOutOfRange", "InvalidDateTime", "NestingDepthExceeded"]>, Schema.Literals<readonly ["DuplicateKey", "TableRedefined", "ArrayOfTablesConflict", "DottedKeyConflict", "InlineTableExtended"]>, Schema.Literals<readonly ["CircularReference", "UnsupportedValue", "IntegerOutOfRange", "NestingDepthExceeded"]>]>;
 /**
  * The union of all TOML error code string literals.
  *
@@ -62,7 +62,7 @@ declare const TomlErrorCode: Schema.Union<readonly [Schema.Literals<readonly ["I
  */
 type TomlErrorCode = typeof TomlErrorCode.Type;
 declare const TomlDiagnostic_base: Schema.Class<TomlDiagnostic, Schema.Struct<{
-  readonly code: Schema.Union<readonly [Schema.Literals<readonly ["InvalidUtf8", "UnterminatedString", "InvalidEscape", "InvalidUnicodeEscape", "ControlCharacterInString", "ControlCharacterInComment", "InvalidCharacter", "BareCarriageReturn"]>, Schema.Literals<readonly ["ExpectedKey", "ExpectedEquals", "ExpectedValue", "ExpectedNewline", "ExpectedTableHeaderClose", "UnterminatedArray", "UnterminatedInlineTable", "TrailingCommaInInlineTable", "NewlineInInlineTable", "InvalidValue", "InvalidNumber", "IntegerOutOfRange", "InvalidDateTime", "NestingDepthExceeded"]>, Schema.Literals<readonly ["DuplicateKey", "TableRedefined", "ArrayOfTablesConflict", "DottedKeyConflict", "InlineTableExtended"]>, Schema.Literals<readonly ["CircularReference", "UnsupportedValue", "IntegerOutOfRange", "NestingDepthExceeded"]>]>;
+  readonly code: Schema.Union<readonly [Schema.Literals<readonly ["InvalidUtf8", "UnterminatedString", "InvalidEscape", "InvalidUnicodeEscape", "ControlCharacterInString", "ControlCharacterInComment", "InvalidCharacter", "BareCarriageReturn"]>, Schema.Literals<readonly ["ExpectedKey", "ExpectedEquals", "ExpectedValue", "ExpectedNewline", "ExpectedTableHeaderClose", "UnterminatedArray", "UnterminatedInlineTable", "InvalidValue", "InvalidNumber", "IntegerOutOfRange", "InvalidDateTime", "NestingDepthExceeded"]>, Schema.Literals<readonly ["DuplicateKey", "TableRedefined", "ArrayOfTablesConflict", "DottedKeyConflict", "InlineTableExtended"]>, Schema.Literals<readonly ["CircularReference", "UnsupportedValue", "IntegerOutOfRange", "NestingDepthExceeded"]>]>;
   readonly message: Schema.String;
   readonly offset: Schema.Number;
   readonly length: Schema.Number;
@@ -104,6 +104,13 @@ declare const TomlStringifyOptions_base: Schema.Class<TomlStringifyOptions, Sche
  * Options controlling stringify behavior. The only knob is `newline` —
  * omitted, it resolves to `"\n"`.
  *
+ * @remarks
+ * Stringify deliberately emits only TOML 1.0.0 spellings — seconds always
+ * present in times, no `\e`/`\xHH` escapes, single-line inline tables — even
+ * though {@link Toml.parse} accepts the full TOML 1.1.0 grammar. Every 1.0
+ * document is valid 1.1, so this conservative-write/liberal-read asymmetry
+ * keeps emitted documents readable by 1.0-only consumers.
+ *
  * @public
  */
 declare class TomlStringifyOptions extends TomlStringifyOptions_base {}
@@ -135,6 +142,22 @@ declare const TomlStringifyError_base: Schema.Class<TomlStringifyError, Schema.T
 declare class TomlStringifyError extends TomlStringifyError_base {
   get message(): string;
 }
+/**
+ * A domain codec pre-bound to its two directions, returned by
+ * {@link Toml.bind}: the composed `schema` (what {@link Toml.schema} returns)
+ * plus `decode` and `encode` functions derived from it once, so callers need
+ * no generic `Schema` machinery at the use site.
+ *
+ * @public
+ */
+interface TomlBoundCodec<T, RD = never, RE = never> {
+  /** The composed codec decoding a TOML `string` straight into `T`. */
+  readonly schema: Schema.Codec<T, string, RD, RE>;
+  /** Decode TOML text into a validated `T`. */
+  readonly decode: (text: string) => Effect.Effect<T, Schema.SchemaError, RD>;
+  /** Encode a `T` back to canonical TOML text. */
+  readonly encode: (value: T) => Effect.Effect<string, Schema.SchemaError, RE>;
+}
 /**
  * Static entry points for TOML parsing, stringification and the schema
  * factories. Not instantiable.
@@ -144,7 +167,7 @@ declare class TomlStringifyError extends TomlStringifyError_base {
  * channels — including the hardening guards (nesting-depth caps on both
  * sides, circular-reference detection on encode) that keep malformed or
  * adversarial input on the typed channel instead of surfacing as an
- * unhandled defect. `parse` takes no options: TOML 1.0.0 parsing has no
+ * unhandled defect. `parse` takes no options: TOML 1.1.0 parsing has no
  * knobs.
  *
  * @example
@@ -163,26 +186,104 @@ declare class TomlStringifyError extends TomlStringifyError_base {
 declare class Toml {
   private constructor();
   /**
-   * Parse a TOML 1.0.0 document into a plain JavaScript value: tables and
-   * inline tables become plain objects (`__proto__` lands as an own data
-   * property), arrays become plain arrays, integers become `number` (or
-   * `bigint` past 2^53) and date-times become the four `TomlDateTime`
-   * classes. Fails with {@link TomlParseError} at the first violation;
-   * returns `unknown`, never `any`.
+   * Parse a TOML 1.1.0 document into a plain JavaScript value, synchronously,
+   * returning a `Result` instead of an `Effect`: tables and inline tables
+   * become plain objects (`__proto__` lands as an own data property), arrays
+   * become plain arrays, integers become `number` (or `bigint` past 2^53) and
+   * date-times become the four `TomlDateTime` classes. Fails with
+   * {@link TomlParseError} at the first violation; returns `unknown`, never
+   * `any`.
    *
    * A nesting-depth bomb (arrays or inline tables past the engine cap) also
    * fails through {@link TomlParseError} with a `NestingDepthExceeded`
    * diagnostic, never as an unhandled defect.
+   *
+   * @remarks
+   * {@link Toml.parse} is defined in terms of this function; the two never
+   * diverge. Reach for the `Effect` variant inside Effect code — it carries
+   * the `Toml.parse` tracing span — and for this one at synchronous
+   * boundaries such as a lint-staged handler.
+   *
+   * @example
+   * ```ts
+   * import { Toml } from "@effected/toml";
+   * import { Result } from "effect";
+   *
+   * const ok = Toml.parseResult('name = "Alice"');
+   * if (Result.isSuccess(ok)) {
+   *   console.log(ok.success); // => { name: "Alice" }
+   * }
+   *
+   * const bad = Toml.parseResult("name = ");
+   * if (Result.isFailure(bad)) {
+   *   console.log(bad.failure._tag); // => "TomlParseError"
+   * }
+   * ```
+   *
+   * @param text - The TOML source to parse.
+   * @returns A `Result` succeeding with the decoded value (`unknown`, never
+   *   `any`), or failing with {@link TomlParseError}.
+   */
+  static parseResult(text: string): Result.Result<unknown, TomlParseError>;
+  /**
+   * Parse a TOML 1.1.0 document into a plain JavaScript value. Defined in
+   * terms of {@link Toml.parseResult} — synchronous callers can use that
+   * variant directly.
+   *
+   * @param text - The TOML source to parse.
+   * @returns An `Effect` that succeeds with the decoded value, or fails with
+   *   {@link TomlParseError}.
    */
   static readonly parse: (text: string) => Effect.Effect<unknown, TomlParseError, never>;
   /**
-   * Stringify a plain JavaScript value as a canonical TOML document: within
-   * a table, non-table pairs first, then sub-tables as `[dotted.header]`
+   * Stringify a plain JavaScript value as a canonical TOML document,
+   * synchronously, returning a `Result` instead of an `Effect`: within a
+   * table, non-table pairs first, then sub-tables as `[dotted.header]`
    * sections depth-first, then arrays of tables as `[[dotted.header]]`
    * sections, a blank line before every header except at document start.
    * Fails with {@link TomlStringifyError} on unsupported values (TOML has no
    * null), out-of-int64-range `bigint`s, circular references and
    * depth-guard trips — all on the typed channel.
+   *
+   * @remarks
+   * {@link Toml.stringify} is defined in terms of this function; the two
+   * never diverge. Reach for the `Effect` variant inside Effect code — it
+   * carries the `Toml.stringify` tracing span — and for this one at
+   * synchronous boundaries.
+   *
+   * @example
+   * ```ts
+   * import { Toml } from "@effected/toml";
+   * import { Result } from "effect";
+   *
+   * const ok = Toml.stringifyResult({ name: "Alice" });
+   * if (Result.isSuccess(ok)) {
+   *   console.log(ok.success); // => 'name = "Alice"\n'
+   * }
+   *
+   * const bad = Toml.stringifyResult({ nope: null });
+   * if (Result.isFailure(bad)) {
+   *   console.log(bad.failure._tag); // => "TomlStringifyError"
+   * }
+   * ```
+   *
+   * @param value - The plain JavaScript value to stringify.
+   * @param options - Optional {@link TomlStringifyOptions}; `newline`
+   *   defaults to `"\n"`.
+   * @returns A `Result` succeeding with the TOML text, or failing with
+   *   {@link TomlStringifyError}.
+   */
+  static stringifyResult(value: unknown, options?: TomlStringifyOptions): Result.Result<string, TomlStringifyError>;
+  /**
+   * Stringify a plain JavaScript value as a canonical TOML document. Defined
+   * in terms of {@link Toml.stringifyResult} — synchronous callers can use
+   * that variant directly.
+   *
+   * @param value - The plain JavaScript value to stringify.
+   * @param options - Optional {@link TomlStringifyOptions}; `newline`
+   *   defaults to `"\n"`.
+   * @returns An `Effect` that succeeds with the TOML text, or fails with
+   *   {@link TomlStringifyError}.
    */
   static readonly stringify: (value: unknown, options?: TomlStringifyOptions | undefined) => Effect.Effect<string, TomlStringifyError, never>;
   /**
@@ -208,6 +309,42 @@ declare class Toml {
    * {@link Toml.fromString}).
    */
   static schema<T, E, RD = never, RE = never>(target: Schema.Codec<T, E, RD, RE>): Schema.Codec<T, string, RD, RE>;
+  /**
+   * Bind a target schema to the TOML codec once, yielding the composed
+   * schema plus pre-derived `decode`/`encode` directions — the
+   * {@link Toml.schema} composition without the generic `Schema` machinery
+   * at every use site. Binds the plain form only: TOML 1.1.0 parsing on
+   * decode, default stringify options on encode.
+   *
+   * Both directions fail with `Schema.SchemaError`, exactly as
+   * `Schema.decodeEffect`/`Schema.encodeEffect` over {@link Toml.schema}
+   * would; the target's decoding/encoding service requirements flow through.
+   *
+   * @remarks
+   * Schema-producing: each call composes a fresh schema and derives both
+   * directions from it. Bind the result to a `const` — that single binding is
+   * the point.
+   *
+   * @example
+   * ```ts
+   * import { Toml } from "@effected/toml";
+   * import { Effect, Schema } from "effect";
+   *
+   * const Config = Schema.Struct({ name: Schema.String });
+   * const config = Toml.bind(Config);
+   *
+   * const program = Effect.gen(function* () {
+   *   const value = yield* config.decode('name = "Alice"');
+   *   const text = yield* config.encode(value);
+   *   return [value, text] as const;
+   * });
+   * ```
+   *
+   * @param target - The domain schema decoded values must satisfy.
+   * @returns A {@link TomlBoundCodec} carrying the composed schema and its
+   *   two pre-bound directions.
+   */
+  static bind<T, E, RD = never, RE = never>(target: Schema.Codec<T, E, RD, RE>): TomlBoundCodec<T, RD, RE>;
 }
 //#endregion
 //#region src/TomlDateTime.d.ts
@@ -385,7 +522,7 @@ declare const TomlArray_base: Schema.Class<TomlArray, Schema.TaggedStruct<"TomlA
   readonly length: Schema.Number;
 }>, {}>;
 /**
- * An array value node. Heterogeneous per TOML 1.0.0; may span multiple lines
+ * An array value node. Heterogeneous per TOML; may span multiple lines
  * (the span covers brackets, inner newlines and inner comments).
  *
  * @public
@@ -410,7 +547,8 @@ declare const TomlInlineTable_base: Schema.Class<TomlInlineTable, Schema.TaggedS
   readonly length: Schema.Number;
 }>, {}>;
 /**
- * An inline table value node (`{ k = v, ... }`). Single-line by grammar.
+ * An inline table value node (`{ k = v, ... }`). May span multiple lines
+ * since TOML 1.1 (the span covers braces, inner newlines and inner comments).
  *
  * @public
  */
@@ -893,5 +1031,5 @@ declare class TomlVisitor {
   static visit(text: string): Stream.Stream<TomlVisitorEvent, TomlParseError>;
 }
 //#endregion
-export { Toml, TomlArray, TomlArrayTableHeader, TomlBoolean, TomlDateTimeLiteral, TomlDiagnostic, TomlDocument, TomlEdit, TomlErrorCode, TomlExpression, TomlFloat, TomlFormat, TomlFormattingOptions, TomlInlineEntry, TomlInlineTable, TomlInteger, TomlKey, TomlKeyKind, TomlKeyValue, TomlLexErrorCode, TomlLocalDate, TomlLocalDateTime, TomlLocalTime, TomlModificationError, TomlOffsetDateTime, TomlParseError, TomlParseErrorCode, type TomlPath, TomlRange, type TomlRangeLike, type TomlSegment, TomlSemanticErrorCode, TomlString, TomlStringStyle, TomlStringifyError, TomlStringifyErrorCode, TomlStringifyOptions, TomlTableHeader, TomlTrivia, TomlValueNode, TomlVisitor, TomlVisitorEvent };
+export { Toml, TomlArray, TomlArrayTableHeader, TomlBoolean, type TomlBoundCodec, TomlDateTimeLiteral, TomlDiagnostic, TomlDocument, TomlEdit, TomlErrorCode, TomlExpression, TomlFloat, TomlFormat, TomlFormattingOptions, TomlInlineEntry, TomlInlineTable, TomlInteger, TomlKey, TomlKeyKind, TomlKeyValue, TomlLexErrorCode, TomlLocalDate, TomlLocalDateTime, TomlLocalTime, TomlModificationError, TomlOffsetDateTime, TomlParseError, TomlParseErrorCode, type TomlPath, TomlRange, type TomlRangeLike, type TomlSegment, TomlSemanticErrorCode, TomlString, TomlStringStyle, TomlStringifyError, TomlStringifyErrorCode, TomlStringifyOptions, TomlTableHeader, TomlTrivia, TomlValueNode, TomlVisitor, TomlVisitorEvent };
 //# sourceMappingURL=index.d.ts.map

package/internal/diagnostics.js

@@ -17,8 +17,6 @@ const TOML_PARSE_ERROR_CODES = [
 	"ExpectedTableHeaderClose",
 	"UnterminatedArray",
 	"UnterminatedInlineTable",
-	"TrailingCommaInInlineTable",
-	"NewlineInInlineTable",
 	"InvalidValue",
 	"InvalidNumber",
 	"IntegerOutOfRange",

package/internal/parser.js

@@ -105,8 +105,12 @@ const parseLineEnd = (source, pos) => {
 		end: after
 	};
 };
-/** Skip whitespace, newlines and comments inside array brackets. */
-const skipArrayGap = (source, pos) => {
+/**
+* Skip whitespace, newlines and comments inside array brackets or inline-table
+* braces — the grammar's `ws-comment-newline`, shared by both container
+* parsers since TOML 1.1 let inline tables span lines.
+*/
+const skipValueGap = (source, pos) => {
 	let i = pos;
 	for (;;) {
 		i = scanWhitespace(source, i);
@@ -122,12 +126,6 @@ const skipArrayGap = (source, pos) => {
 		return i;
 	}
 };
-/** Guard the inline-table single-line rule and unterminated end-of-input. */
-const checkInsideInlineTable = (source, pos, openPos) => {
-	if (pos >= source.length) raise("UnterminatedInlineTable", "inline table not closed before end of input", openPos, pos - openPos);
-	const code = source.charCodeAt(pos);
-	if (code === LF || code === CR) raise("NewlineInInlineTable", "inline tables must fit on a single line", pos, 1);
-};
 /** Whether a token that classified as `number` spells a float (never called on hex/oct/bin). */
 const isFloatToken = (token) => !/^0[xob]/.test(token) && (/[.eE]/.test(token) || token.includes("inf") || token.includes("nan"));
 /** An array value starting at `[`; `depth` is this array's own nesting count. */
@@ -136,7 +134,7 @@ const parseArray = (source, openPos, depth) => {
 	const items = [];
 	let i = openPos + 1;
 	for (;;) {
-		i = skipArrayGap(source, i);
+		i = skipValueGap(source, i);
 		if (i >= source.length) raise("UnterminatedArray", "array not closed before end of input", openPos, i - openPos);
 		if (source.charCodeAt(i) === RIGHT_BRACKET) {
 			i += 1;
@@ -144,7 +142,7 @@ const parseArray = (source, openPos, depth) => {
 		}
 		const item = parseValue(source, i, depth);
 		items.push(item.node);
-		i = skipArrayGap(source, item.end);
+		i = skipValueGap(source, item.end);
 		const code = source.charCodeAt(i);
 		if (code === COMMA) {
 			i += 1;
@@ -166,28 +164,29 @@ const parseArray = (source, openPos, depth) => {
 		end: i
 	};
 };
-/** An inline table starting at `{`; `depth` is this table's own nesting count. */
+/**
+* An inline table starting at `{`; `depth` is this table's own nesting count.
+* TOML 1.1 grammar: `ws-comment-newline` may sit before each key-value,
+* before each separator and before the closing brace, and a trailing comma is
+* allowed — but `keyval-sep` is still ws-only, so no newline may split a key
+* from its `=` or the `=` from its value.
+*/
 const parseInlineTable = (source, openPos, depth) => {
 	if (depth > 256) throw new GuardExceeded("NestingDepthExceeded", 256, depth, openPos);
 	const entries = [];
-	let i = scanWhitespace(source, openPos + 1);
-	checkInsideInlineTable(source, i, openPos);
-	if (source.charCodeAt(i) === RIGHT_BRACE) return {
-		node: new TomlInlineTable({
-			entries,
-			offset: openPos,
-			length: i + 1 - openPos
-		}),
-		end: i + 1
-	};
+	let i = openPos + 1;
 	for (;;) {
+		i = skipValueGap(source, i);
+		if (i >= source.length) raise("UnterminatedInlineTable", "inline table not closed before end of input", openPos, i - openPos);
+		if (source.charCodeAt(i) === RIGHT_BRACE) {
+			i += 1;
+			break;
+		}
 		const entryStart = i;
 		const keyPath = parseKeyPath(source, i);
 		i = scanWhitespace(source, keyPath.end);
-		checkInsideInlineTable(source, i, openPos);
 		if (source.charCodeAt(i) !== EQUALS) raise("ExpectedEquals", "expected = after key", i, 1);
 		i = scanWhitespace(source, i + 1);
-		checkInsideInlineTable(source, i, openPos);
 		const value = parseValue(source, i, depth);
 		entries.push(new TomlInlineEntry({
 			keyPath: keyPath.node,
@@ -195,20 +194,17 @@ const parseInlineTable = (source, openPos, depth) => {
 			offset: entryStart,
 			length: value.end - entryStart
 		}));
-		i = scanWhitespace(source, value.end);
-		checkInsideInlineTable(source, i, openPos);
+		i = skipValueGap(source, value.end);
 		const code = source.charCodeAt(i);
 		if (code === RIGHT_BRACE) {
 			i += 1;
 			break;
 		}
 		if (code === COMMA) {
-			const commaPos = i;
-			i = scanWhitespace(source, i + 1);
-			checkInsideInlineTable(source, i, openPos);
-			if (source.charCodeAt(i) === RIGHT_BRACE) raise("TrailingCommaInInlineTable", "inline tables may not end with a trailing comma", commaPos, 1);
+			i += 1;
 			continue;
 		}
+		if (i >= source.length) raise("UnterminatedInlineTable", "inline table not closed before end of input", openPos, i - openPos);
 		raise("UnterminatedInlineTable", "expected , or } in inline table", i, 1);
 	}
 	return {

package/internal/scanner.js

@@ -17,6 +17,7 @@ const RIGHT_BRACKET = 93;
 const RIGHT_BRACE = 125;
 const LOWER_U = 117;
 const UPPER_U = 85;
+const LOWER_X = 120;
 const BOM = 65279;
 const raise = (code, message, offset, length) => {
 	throw new RawTomlError({
@@ -36,7 +37,7 @@ const isBareKeyChar = (code) => code >= 97 && code <= 122 || code >= 65 && code
 /** The number of code units to skip for a single leading U+FEFF BOM. */
 const skipBom = (source) => source.charCodeAt(0) === BOM ? 1 : 0;
 /**
-* Reject a document carrying U+FFFD REPLACEMENT CHARACTER. TOML 1.0.0 requires
+* Reject a document carrying U+FFFD REPLACEMENT CHARACTER. TOML requires
 * a valid UTF-8 document, but this engine receives an already-decoded JS
 * string — after Node's lossy utf8 decode, U+FFFD is the only surviving
 * evidence of a malformed byte sequence. The grammar technically admits
@@ -106,20 +107,29 @@ const simpleEscape = (code) => {
 		case 110: return "\n";
 		case 102: return "\f";
 		case 114: return "\r";
+		case 101: return "\x1B";
 		case QUOTE: return "\"";
 		case BACKSLASH: return "\\";
 		default: return;
 	}
 };
 const HEX_DIGITS = /^[0-9A-Fa-f]+$/;
+const ESCAPE_LETTERS = {
+	2: "x",
+	4: "u",
+	8: "U"
+};
 /**
-* Decode a `\uXXXX` / `\UXXXXXXXX` escape at `backslash`. The code point must
-* be a Unicode scalar value: surrogates and values above U+10FFFF are errors.
+* Decode a `\xHH` / `\uXXXX` / `\UXXXXXXXX` escape at `backslash`. The code
+* point must be a Unicode scalar value: surrogates and values above U+10FFFF
+* are errors. `\xHH` (TOML 1.1) covers U+0000–U+00FF — the escape is a
+* grammar-sibling of `basic-unescaped`, so the decoded character bypasses the
+* control-character ban by design.
 */
 const decodeUnicodeEscape = (source, backslash, width) => {
 	const start = backslash + 2;
 	const hex = source.slice(start, start + width);
-	if (hex.length < width || !HEX_DIGITS.test(hex)) return raise("InvalidUnicodeEscape", `\\${width === 4 ? "u" : "U"} escape requires ${width} hexadecimal digits`, backslash, width + 2);
+	if (hex.length < width || !HEX_DIGITS.test(hex)) return raise("InvalidUnicodeEscape", `\\${ESCAPE_LETTERS[width]} escape requires ${width} hexadecimal digits`, backslash, width + 2);
 	const codePoint = Number.parseInt(hex, 16);
 	if (codePoint >= 55296 && codePoint <= 57343 || codePoint > 1114111) return raise("InvalidUnicodeEscape", `${codeLabel(codePoint)} is not a Unicode scalar value`, backslash, width + 2);
 	return {
@@ -127,6 +137,8 @@ const decodeUnicodeEscape = (source, backslash, width) => {
 		end: start + width
 	};
 };
+/** The escape width for a unicode-style escape letter, or undefined. */
+const unicodeEscapeWidth = (code) => code === LOWER_X ? 2 : code === LOWER_U ? 4 : code === UPPER_U ? 8 : void 0;
 /** Scan a single-line basic string starting at the opening `"`. */
 const scanBasicString = (source, pos) => {
 	let out = "";
@@ -143,11 +155,12 @@ const scanBasicString = (source, pos) => {
 			out += source.slice(chunkStart, i);
 			const next = source.charCodeAt(i + 1);
 			const mapped = simpleEscape(next);
+			const width = unicodeEscapeWidth(next);
 			if (mapped !== void 0) {
 				out += mapped;
 				i += 2;
-			} else if (next === LOWER_U || next === UPPER_U) {
-				const decoded = decodeUnicodeEscape(source, i, next === LOWER_U ? 4 : 8);
+			} else if (width !== void 0) {
+				const decoded = decodeUnicodeEscape(source, i, width);
 				out += String.fromCodePoint(decoded.codePoint);
 				i = decoded.end;
 			} else return raise("InvalidEscape", `invalid escape sequence \\${source[i + 1] ?? ""}`, i, 2);
@@ -234,8 +247,9 @@ const scanMultilineBasicString = (source, pos) => {
 				chunkStart = i;
 				continue;
 			}
-			if (next === LOWER_U || next === UPPER_U) {
-				const decoded = decodeUnicodeEscape(source, i, next === LOWER_U ? 4 : 8);
+			const width = unicodeEscapeWidth(next);
+			if (width !== void 0) {
+				const decoded = decodeUnicodeEscape(source, i, width);
 				out += String.fromCodePoint(decoded.codePoint);
 				i = decoded.end;
 				chunkStart = i;
@@ -319,10 +333,10 @@ const scanTokenSpan = (source, pos) => {
 	}
 	return i;
 };
-const OFFSET_DATE_TIME = /^([0-9]{4})-([0-9]{2})-([0-9]{2})[Tt ]([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.([0-9]+))?([Zz]|[+-][0-9]{2}:[0-9]{2})$/;
-const LOCAL_DATE_TIME = /^([0-9]{4})-([0-9]{2})-([0-9]{2})[Tt ]([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.([0-9]+))?$/;
+const OFFSET_DATE_TIME = /^([0-9]{4})-([0-9]{2})-([0-9]{2})[Tt ]([0-9]{2}):([0-9]{2})(?::([0-9]{2})(?:\.([0-9]+))?)?([Zz]|[+-][0-9]{2}:[0-9]{2})$/;
+const LOCAL_DATE_TIME = /^([0-9]{4})-([0-9]{2})-([0-9]{2})[Tt ]([0-9]{2}):([0-9]{2})(?::([0-9]{2})(?:\.([0-9]+))?)?$/;
 const LOCAL_DATE = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/;
-const LOCAL_TIME = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(?:\.([0-9]+))?$/;
+const LOCAL_TIME = /^([0-9]{2}):([0-9]{2})(?::([0-9]{2})(?:\.([0-9]+))?)?$/;
 /**
 * Scan a non-string scalar value token. Stops at whitespace, newlines, `,`,
 * `]`, `}` and `#` — with the G5 extension: a token that scanned as a full
@@ -409,13 +423,13 @@ const classifyValueToken = (token, offset) => {
 	const length = Math.max(token.length, 1);
 	let match = OFFSET_DATE_TIME.exec(token);
 	if (match !== null) {
-		const [, y = "", mo = "", d = "", h = "", mi = "", s = "", fraction, offsetText = ""] = match;
+		const [, y = "", mo = "", d = "", h = "", mi = "", s, fraction, offsetText = ""] = match;
 		const year = Number(y);
 		const month = Number(mo);
 		const day = Number(d);
 		const hour = Number(h);
 		const minute = Number(mi);
-		const second = Number(s);
+		const second = s === void 0 ? 0 : Number(s);
 		validateDate(year, month, day, offset, length);
 		validateTime(hour, minute, second, offset, length);
 		const offsetMinutes = decodeOffsetMinutes(offsetText, offset, length);
@@ -432,13 +446,13 @@ const classifyValueToken = (token, offset) => {
 	}
 	match = LOCAL_DATE_TIME.exec(token);
 	if (match !== null) {
-		const [, y = "", mo = "", d = "", h = "", mi = "", s = "", fraction] = match;
+		const [, y = "", mo = "", d = "", h = "", mi = "", s, fraction] = match;
 		const year = Number(y);
 		const month = Number(mo);
 		const day = Number(d);
 		const hour = Number(h);
 		const minute = Number(mi);
-		const second = Number(s);
+		const second = s === void 0 ? 0 : Number(s);
 		validateDate(year, month, day, offset, length);
 		validateTime(hour, minute, second, offset, length);
 		return new TomlLocalDateTime({
@@ -466,10 +480,10 @@ const classifyValueToken = (token, offset) => {
 	}
 	match = LOCAL_TIME.exec(token);
 	if (match !== null) {
-		const [, h = "", mi = "", s = "", fraction] = match;
+		const [, h = "", mi = "", s, fraction] = match;
 		const hour = Number(h);
 		const minute = Number(mi);
-		const second = Number(s);
+		const second = s === void 0 ? 0 : Number(s);
 		validateTime(hour, minute, second, offset, length);
 		return new TomlLocalTime({
 			hour,

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "@effected/toml",
-	"version": "0.1.0",
+	"version": "0.3.0",
 	"private": false,
-	"description": "TOML 1.0.0 parsing, editing and formatting as Effect schemas: typed diagnostics, a lossless CST and first-class date-time values.",
+	"description": "TOML 1.1.0 parsing, editing and formatting as Effect schemas: typed diagnostics, a lossless CST and first-class date-time values.",
 	"keywords": [
 		"toml",
 		"parser",
@@ -32,12 +32,13 @@
 	"exports": {
 		".": {
 			"types": "./index.d.ts",
-			"import": "./index.js"
+			"import": "./index.js",
+			"default": "./index.js"
 		},
 		"./package.json": "./package.json"
 	},
 	"peerDependencies": {
-		"effect": "4.0.0-beta.98"
+		"effect": "4.0.0-beta.99"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.9"
+      "packageVersion": "7.58.11"
     }
   ]
 }