@effected/toml 0.1.0 → 0.2.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

@@ -11,6 +11,13 @@ import { Effect, Option, Schema, SchemaIssue, SchemaTransformation } from "effec
 * 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"])) }) {};
@@ -84,7 +91,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,7 +110,7 @@ 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
+	* Parse a TOML 1.1.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`
@@ -159,6 +166,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

@@ -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,7 +186,7 @@ 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
+   * Parse a TOML 1.1.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`
@@ -208,6 +231,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 +444,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 +469,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 +953,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.2.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"
     }
   ]
 }