@cbortech/cbor 0.26.8 → 0.27.1

package/dist/cdn/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/cdn/index.ts"],"sourcesContent":["/**\n * Public lower-level CDN tokenization and serialization API\n * (`@cbortech/cbor/cdn`).\n *\n * Exposes the same lexer the parser uses, so tooling such as syntax\n * highlighters stays in exact agreement with parsing behavior. Also exposes\n * the `preserveAppSequence` source-preservation primitives that the built-in\n * `dt`/`ip`/`cri` extensions use, so a third-party `CborExtension` whose\n * result has its own dedicated notation (regenerated from a resolved value,\n * the way `dt'...'`/`ip'...'`/`cri'...'` do) can support `preserveAppSequence`\n * too, instead of always discarding the original `` prefix`...` ``,\n * non-canonical `prefix'...'`, or raw-tag `N(...)` source spelling. See the\n * `dt`/`ip`/`cri` extension sources for the pattern these are meant to be\n * used in.\n */\n\nimport { Tokenizer, type Token, type EdnComment } from './tokenizer';\nimport { CdnSyntaxError } from './errors';\n\nexport type { Token, TokenType, EdnComment } from './tokenizer';\nexport { CdnSyntaxError } from './errors';\n\nexport {\n  resolveEiSuffix,\n  canonicalEncodingWidth,\n  decideTaggedAppSeqRendering,\n  adjustRawAppSeqSource,\n  adjustAppSeqIndicator,\n} from './serialize-utils';\nexport type { AppSeqRenderDecision } from './serialize-utils';\n\nexport interface TokenizeResult {\n  /** Scanned tokens in source order, excluding the final EOF token. */\n  tokens: Token[];\n  /** Comments encountered while scanning, in source order. */\n  comments: EdnComment[];\n}\n\nexport interface TokenizeLenientResult extends TokenizeResult {\n  /**\n   * The scan failure, if any. When set, `tokens` ends with a synthetic\n   * `ERROR` token covering the source from the last clean token to the end\n   * of the input.\n   */\n  error?: CdnSyntaxError;\n}\n\n/**\n * Tokenize CDN text. Throws {@link CdnSyntaxError} on invalid input.\n */\nexport function tokenize(text: string): TokenizeResult {\n  const tokenizer = new Tokenizer(text);\n  const tokens: Token[] = [];\n  for (;;) {\n    const tok = tokenizer.consume();\n    if (tok.type === 'EOF') break;\n    tokens.push(tok);\n  }\n  return { tokens, comments: tokenizer.comments };\n}\n\n/**\n * Error-tolerant tokenization for editors and highlighters: never throws on\n * invalid input. Tokens before the failure are returned as scanned; the\n * remainder of the input is covered by a single synthetic `ERROR` token and\n * the failure is reported in `error`.\n */\nexport function tokenizeLenient(text: string): TokenizeLenientResult {\n  const tokenizer = new Tokenizer(text);\n  const tokens: Token[] = [];\n  try {\n    for (;;) {\n      const tok = tokenizer.consume();\n      if (tok.type === 'EOF') break;\n      tokens.push(tok);\n    }\n    return { tokens, comments: tokenizer.comments };\n  } catch (e) {\n    const error =\n      e instanceof CdnSyntaxError\n        ? e\n        : new CdnSyntaxError(e instanceof Error ? e.message : String(e));\n    const start = tokenizer.lastEndOffset;\n    if (start < text.length) {\n      let line = 1;\n      let col = 1;\n      for (let i = 0; i < start; i++) {\n        if (text[i] === '\\n') {\n          line++;\n          col = 1;\n        } else {\n          col++;\n        }\n      }\n      tokens.push({\n        type: 'ERROR',\n        value: text.slice(start),\n        raw: text.slice(start),\n        line,\n        col,\n        offset: start,\n        endOffset: text.length,\n      });\n    }\n    return { tokens, comments: tokenizer.comments, error };\n  }\n}\n"],"mappings":";;AAkDA,SAAgB,EAAS,GAA8B;CACrD,IAAM,IAAY,IAAI,EAAU,CAAI,GAC9B,IAAkB,CAAC;CACzB,SAAS;EACP,IAAM,IAAM,EAAU,QAAQ;EAC9B,IAAI,EAAI,SAAS,OAAO;EACxB,EAAO,KAAK,CAAG;CACjB;CACA,OAAO;EAAE;EAAQ,UAAU,EAAU;CAAS;AAChD;AAQA,SAAgB,EAAgB,GAAqC;CACnE,IAAM,IAAY,IAAI,EAAU,CAAI,GAC9B,IAAkB,CAAC;CACzB,IAAI;EACF,SAAS;GACP,IAAM,IAAM,EAAU,QAAQ;GAC9B,IAAI,EAAI,SAAS,OAAO;GACxB,EAAO,KAAK,CAAG;EACjB;EACA,OAAO;GAAE;GAAQ,UAAU,EAAU;EAAS;CAChD,SAAS,GAAG;EACV,IAAM,IACJ,aAAa,IACT,IACA,IAAI,EAAe,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC,CAAC,GAC7D,IAAQ,EAAU;EACxB,IAAI,IAAQ,EAAK,QAAQ;GACvB,IAAI,IAAO,GACP,IAAM;GACV,KAAK,IAAI,IAAI,GAAG,IAAI,GAAO,KACzB,AAAI,EAAK,OAAO,QACd,KACA,IAAM,KAEN;GAGJ,EAAO,KAAK;IACV,MAAM;IACN,OAAO,EAAK,MAAM,CAAK;IACvB,KAAK,EAAK,MAAM,CAAK;IACrB;IACA;IACA,QAAQ;IACR,WAAW,EAAK;GAClB,CAAC;EACH;EACA,OAAO;GAAE;GAAQ,UAAU,EAAU;GAAU;EAAM;CACvD;AACF"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/cdn/index.ts"],"sourcesContent":["/**\n * Public lower-level CDN tokenization and serialization API\n * (`@cbortech/cbor/cdn`).\n *\n * Exposes the same lexer the parser uses, so tooling such as syntax\n * highlighters stays in exact agreement with parsing behavior. Also exposes\n * the `preserveAppSeqSource` source-preservation primitives that the built-in\n * `dt`/`ip`/`cri` extensions use, so a third-party `CborExtension` whose\n * result has its own dedicated notation (regenerated from a resolved value,\n * the way `dt'...'`/`ip'...'`/`cri'...'` do) can support `preserveAppSeqSource`\n * too, instead of always discarding the original `` prefix`...` ``,\n * non-canonical `prefix'...'`, or raw-tag `N(...)` source spelling. See the\n * `dt`/`ip`/`cri` extension sources for the pattern these are meant to be\n * used in.\n */\n\nimport { Tokenizer, type Token, type EdnComment } from './tokenizer';\nimport { CdnSyntaxError } from './errors';\n\nexport type { Token, TokenType, EdnComment } from './tokenizer';\nexport { CdnSyntaxError } from './errors';\n\nexport {\n  resolveEiSuffix,\n  canonicalEncodingWidth,\n  decideTaggedAppSeqRendering,\n  adjustRawAppSeqSource,\n  adjustAppSeqIndicator,\n} from './serialize-utils';\nexport type { AppSeqRenderDecision } from './serialize-utils';\n\nexport interface TokenizeResult {\n  /** Scanned tokens in source order, excluding the final EOF token. */\n  tokens: Token[];\n  /** Comments encountered while scanning, in source order. */\n  comments: EdnComment[];\n}\n\nexport interface TokenizeLenientResult extends TokenizeResult {\n  /**\n   * The scan failure, if any. When set, `tokens` ends with a synthetic\n   * `ERROR` token covering the source from the last clean token to the end\n   * of the input.\n   */\n  error?: CdnSyntaxError;\n}\n\n/**\n * Tokenize CDN text. Throws {@link CdnSyntaxError} on invalid input.\n */\nexport function tokenize(text: string): TokenizeResult {\n  const tokenizer = new Tokenizer(text);\n  const tokens: Token[] = [];\n  for (;;) {\n    const tok = tokenizer.consume();\n    if (tok.type === 'EOF') break;\n    tokens.push(tok);\n  }\n  return { tokens, comments: tokenizer.comments };\n}\n\n/**\n * Error-tolerant tokenization for editors and highlighters: never throws on\n * invalid input. Tokens before the failure are returned as scanned; the\n * remainder of the input is covered by a single synthetic `ERROR` token and\n * the failure is reported in `error`.\n */\nexport function tokenizeLenient(text: string): TokenizeLenientResult {\n  const tokenizer = new Tokenizer(text);\n  const tokens: Token[] = [];\n  try {\n    for (;;) {\n      const tok = tokenizer.consume();\n      if (tok.type === 'EOF') break;\n      tokens.push(tok);\n    }\n    return { tokens, comments: tokenizer.comments };\n  } catch (e) {\n    const error =\n      e instanceof CdnSyntaxError\n        ? e\n        : new CdnSyntaxError(e instanceof Error ? e.message : String(e));\n    const start = tokenizer.lastEndOffset;\n    if (start < text.length) {\n      let line = 1;\n      let col = 1;\n      for (let i = 0; i < start; i++) {\n        if (text[i] === '\\n') {\n          line++;\n          col = 1;\n        } else {\n          col++;\n        }\n      }\n      tokens.push({\n        type: 'ERROR',\n        value: text.slice(start),\n        raw: text.slice(start),\n        line,\n        col,\n        offset: start,\n        endOffset: text.length,\n      });\n    }\n    return { tokens, comments: tokenizer.comments, error };\n  }\n}\n"],"mappings":";;AAkDA,SAAgB,EAAS,GAA8B;CACrD,IAAM,IAAY,IAAI,EAAU,CAAI,GAC9B,IAAkB,CAAC;CACzB,SAAS;EACP,IAAM,IAAM,EAAU,QAAQ;EAC9B,IAAI,EAAI,SAAS,OAAO;EACxB,EAAO,KAAK,CAAG;CACjB;CACA,OAAO;EAAE;EAAQ,UAAU,EAAU;CAAS;AAChD;AAQA,SAAgB,EAAgB,GAAqC;CACnE,IAAM,IAAY,IAAI,EAAU,CAAI,GAC9B,IAAkB,CAAC;CACzB,IAAI;EACF,SAAS;GACP,IAAM,IAAM,EAAU,QAAQ;GAC9B,IAAI,EAAI,SAAS,OAAO;GACxB,EAAO,KAAK,CAAG;EACjB;EACA,OAAO;GAAE;GAAQ,UAAU,EAAU;EAAS;CAChD,SAAS,GAAG;EACV,IAAM,IACJ,aAAa,IACT,IACA,IAAI,EAAe,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC,CAAC,GAC7D,IAAQ,EAAU;EACxB,IAAI,IAAQ,EAAK,QAAQ;GACvB,IAAI,IAAO,GACP,IAAM;GACV,KAAK,IAAI,IAAI,GAAG,IAAI,GAAO,KACzB,AAAI,EAAK,OAAO,QACd,KACA,IAAM,KAEN;GAGJ,EAAO,KAAK;IACV,MAAM;IACN,OAAO,EAAK,MAAM,CAAK;IACvB,KAAK,EAAK,MAAM,CAAK;IACrB;IACA;IACA,QAAQ;IACR,WAAW,EAAK;GAClB,CAAC;EACH;EACA,OAAO;GAAE;GAAQ,UAAU,EAAU;GAAU;EAAM;CACvD;AACF"}

package/dist/cdn/serialize-utils.d.ts

@@ -1,6 +1,16 @@
 import { CborComment, CborComments, ToCDNOptions } from '../types';
 import { EncodingWidth } from '../cbor/encode';
 import { AppSeqEncodingEdit, AppSeqSourceFeatures } from '../ast/CborItem';
+/**
+ * Append every element of `source` onto `target` in place.
+ *
+ * Not `target.push(...source)`: spreading a large array as call arguments
+ * can exceed the engine's argument-count limit (observed with hex-dump
+ * lines for a deeply nested large array/map, and with CDN reflow
+ * breakpoints for a large embedded array — RangeError: Maximum call stack
+ * size exceeded).
+ */
+export declare function pushAll<T>(target: T[], source: readonly T[]): void;
 /** Resolve indent option to a string, or null for single-line output. */
 export declare function resolveIndent(options: ToCDNOptions | undefined): string | null;
 /** Build the indent prefix for a given depth. */
@@ -19,12 +29,59 @@ export declare function indentOf(indentStr: string, depth: number): string;
  * other comment kind.
  */
 export declare function joinConcatParts(literals: readonly string[], indentStr: string | null, depth: number, midComments?: readonly (readonly string[])[]): string;
+/**
+ * Serialize string parts as a `t1<<...>>` / `b1<<...>>` app-sequence
+ * (draft-ietf-cbor-edn-literals-27 §3.5) — the `modernConcat` replacement
+ * for `joinConcatParts`'s `+`-joining. Unlike a `+` chain, this
+ * notation has its own closing delimiter, so (matching how `<<...>>`/
+ * `CborEmbeddedCBOR` places its own encoding-width indicator, and unlike
+ * `emitParts`, which has nowhere else to put it) `suffix` is appended after
+ * `>>` rather than onto the last literal — it describes the one merged value
+ * `t1<<...>>` denotes as a whole, not any individual argument.
+ *
+ * Always single-line (an app-sequence is loose/collapsible, like
+ * every other `<<...>>` form), except when there's a mid-chain comment to
+ * preserve — nothing else forces it multi-line, since (unlike a real `+`
+ * chain) there's no risk of an unbounded single line growing unreadable that
+ * this format was ever meant to solve; a comment is the one thing a single
+ * line genuinely cannot hold, mirroring `joinConcatParts`'s own reason for
+ * going multi-line.
+ */
+export declare function joinAppSeqParts(prefix: 't1' | 'b1', literals: readonly string[], suffix: string, indentStr: string | null, depth: number, midComments?: readonly (readonly string[])[]): string;
 export interface Commented {
     comments?: CborComments;
     blankLineBefore?: boolean;
 }
 export declare function hasPreservedComments(item: Commented): boolean;
 export declare function hasContainerLayoutComments(item: Commented): boolean;
+/**
+ * Subset of `ToCDNOptions` needed to resolve comment on/off + style —
+ * accepted structurally so callers with a narrower/wider options type (or a
+ * plain `FromCDNOptions`, which shares both fields) don't need a cast.
+ */
+interface CommentOptions {
+    preserveComments?: boolean | 'c-style' | 'cdn-style';
+    comments?: 'strip' | 'c-style' | 'cdn-style';
+}
+/**
+ * Whether comments should be emitted for freshly-regenerated output (as
+ * opposed to a preserved app-sequence/raw-tag source — see
+ * `decideTaggedAppSeqRendering`'s own comment handling for that case, which
+ * has a different "nothing set" default).
+ *
+ * `preserveComments: true` always emits (verbatim); otherwise, comments are
+ * emitted only when `comments` requests a real style (not `'strip'`,
+ * the default when unset) — matching the deprecated `preserveComments:
+ * 'c-style'/'cdn-style'` shorthand, which behaves the same as `comments`
+ * set to that value.
+ */
+export declare function shouldEmitComments(options: CommentOptions | undefined): boolean;
+/**
+ * The marker style to normalize emitted comments to, or `undefined` for
+ * verbatim (original markers kept as-is). Only meaningful when
+ * `shouldEmitComments` is `true`; see its doc for the on/off precedence.
+ */
+export declare function resolveCommentStyle(options: CommentOptions | undefined): 'c-style' | 'cdn-style' | undefined;
 /**
  * Convert a single comment's text to the requested marker style.
  *
@@ -125,6 +182,17 @@ export declare function serializeContainer(p: {
     closeChar: string;
     count: number;
     indefiniteLength: boolean;
+    /**
+     * Whether an indefinite-length container shows the `_` marker
+     * (`(_ "a", "b")`) before its content. Defaults to `true`; set `false` for
+     * a container that denotes an indefinite-length value through some other
+     * notation entirely (e.g. `ilts<<"a", "b">>`) rather than through the
+     * `_`-marked legacy streamstring form — the value is still genuinely
+     * indefinite-length (so `indefiniteLength: true` still correctly
+     * suppresses any encoding-width suffix, which has no meaning for it), but
+     * that other notation has no `_` marker of its own to show.
+     */
+    indefiniteMarker?: boolean;
     encodingWidth: EncodingWidth | undefined;
     /**
      * Where the resolved encoding-indicator suffix is placed.
@@ -142,20 +210,72 @@ export declare function serializeContainer(p: {
      * this to its encoded content's byte length instead.
      */
     canonicalCount?: () => bigint;
-    hasEntryComments: () => boolean;
+    /**
+     * Whether entry `i` structurally has any captured comments (parse-time
+     * presence only — not whether they'll actually be shown; see `hasComments`
+     * in the implementation, which additionally consults `entryOptions(i)` so
+     * an entry whose own override hides its comments doesn't force multi-line
+     * layout, and an entry whose own override *shows* comments the container's
+     * own `preserveComments` would otherwise hide still gets the chance to).
+     */
+    hasEntryComments: (i: number) => boolean;
     /** Render entry `i` at child depth (`item` or `key: value`). */
     renderEntry: (i: number, colSep: string) => string;
     /**
      * Whether entry `i` contains no nested array/map, so it may stay on the
-     * container's line under `inlineLeafContainers`. Omitted = always a leaf
-     * (used by `CborEmbeddedCBOR`, where an entry that is itself a container
-     * still inlines as long as its own rendering fits on one line).
+     * container's line under `inlineLeafContainers` (or always, when
+     * `alwaysInlineLeaf` is set). Omitted = always a leaf (used by
+     * `CborEmbeddedCBOR`, where an entry that is itself a container still
+     * inlines as long as its own rendering fits on one line).
      */
     entryIsLeaf?: (i: number) => boolean;
+    /**
+     * Whether entry `i` is, or wraps, a text string or byte string with two or
+     * more words (`isMultiWordText` / `isMultiWordByteString`). When true,
+     * disqualifies the container from staying on one line under
+     * `inlineLeafContainers` (or `alwaysInlineLeaf`) even though the entry has
+     * no nested array/map — a multi-word string reads better with a line of
+     * its own. This does *not* also cover a prefixed literal like `h'...'`
+     * (which has no word count to check at all, but still disqualifies under
+     * the strict rule) — that's covered separately, generically, by
+     * `isPrefixedLiteralText` (checked against the rendered entry `s` below)
+     * or, for a `CborTag`, `isMultiWordRenderedLiteral`. Omitted = never
+     * disqualifies.
+     */
+    entryIsMultiWordText?: (i: number) => boolean;
+    /**
+     * Always run the one-line collapse probe, regardless of
+     * `options.inlineLeafContainers`. Set only by `CborEmbeddedCBOR`
+     * (`<<...>>`): unlike `CborArray`/`CborMap`, where spreading entries one
+     * per line is a deliberate structural default that `inlineLeafContainers`
+     * opts out of, a flat sequence of encoded items has no such structure to
+     * display — there's nothing gained by always breaking it, so it
+     * collapses onto one line whenever it fits independent of the option.
+     * Indefinite-length string groups (`(_ "a", "b")`) do *not* get this
+     * treatment — they follow CborArray/CborMap's option-gated default
+     * instead, providing `entryIsLeaf` the same way (see `strict` below),
+     * despite also being a "loose rule" container in the
+     * `_containsCdnContainer`/`entryHasContainer` sense (a chunk can never
+     * actually be an array/map, so that distinction is moot for them in
+     * practice). This flag and the loose/strict distinction are genuinely
+     * independent concerns, not the same thing.
+     */
+    alwaysInlineLeaf?: boolean;
     /** Node whose leading comments are emitted above entry `i` (item / map key). */
     entryLeadingNode: (i: number) => Commented;
     /** Pre-formatted trailing comment text for entry `i` (starts with ' ', or ''). */
     entryTrailing: (i: number, style: 'c-style' | 'cdn-style' | undefined) => string;
+    /**
+     * Per-entry options for entry `i`'s own comment handling (whether to
+     * emit its comments at all, and in which style) — distinct from
+     * `options` above, which still governs the container-wide layout
+     * decisions (single-line vs multi-line, `hasComments`'s own gate, the
+     * container's own dangling comments). Omitted when the caller never
+     * resolves per-entry options at all (`toCDN()`'s `itemOptions` isn't in
+     * play), in which case every entry falls back to `options` — identical
+     * to this parameter not existing.
+     */
+    entryOptions?: (i: number) => ToCDNOptions | undefined;
 }): string;
 /**
  * Single-child counterpart to `serializeContainer`, for a wrapper that
@@ -176,9 +296,105 @@ export declare function serializeContainer(p: {
  * rendering, `depth` otherwise (matching a plain value's existing
  * "transparent" nesting — `tag(content)` doesn't indent `content` an extra
  * level when there's nothing to justify going multi-line for).
+ *
+ * `childOptions` — the child's own resolved options, distinct from
+ * `options` (the wrapper's) when `toCDN()`'s `itemOptions` has overridden
+ * something for the child specifically (see `CborTag._toCDN`) — governs
+ * only the child's *own* leading/trailing comments (whether to show them
+ * at all, and in which style); `options` still governs whether to go
+ * multi-line at all and the wrapper's own dangling comments, the same way
+ * `serializeContainer`'s container-wide `options` does for its own
+ * dangling comments even when its `entryOptions` resolves per-entry ones.
  */
-export declare function renderSingleChildWithComments(child: Commented, wrapper: Commented, options: ToCDNOptions | undefined, depth: number, renderChild: (childDepth: number) => string, openChar: '(', closeChar: ')'): string;
+export declare function renderSingleChildWithComments(child: Commented, wrapper: Commented, options: ToCDNOptions | undefined, childOptions: ToCDNOptions | undefined, depth: number, renderChild: (childDepth: number) => string, openChar: '(', closeChar: ')'): string;
 export declare function serializeBytes(bytes: Uint8Array, encoding?: 'hex' | 'base64' | 'base64url' | 'base32' | 'base32hex', sqstr?: 'printable-string' | 'string' | 'none'): string;
+/**
+ * True when `bytes` would render as a bare sqstr literal (`'...'`) under
+ * `sqstr` *and* its decoded text has two or more words — same rule as a
+ * plain text string's own word count. Otherwise (it would render as a
+ * prefixed literal like `h'...'`/`b64'...'`, or as something else entirely
+ * via a subclass overriding `_toCDN()`) this returns `false`: a prefixed
+ * literal has no natural word boundary to predict from raw bytes alone,
+ * and — unlike this function, which never renders anything — the actual
+ * "does the real output look like a disqualifying prefixed literal, tag
+ * wrapping, or app-sequence spelling" question is answered generically
+ * from the *rendered* text instead, by `isPrefixedLiteralText` (for a bare
+ * entry) or `isMultiWordRenderedLiteral` (for a `CborTag`, which needs to
+ * see through its own digits/parens onto whatever they wrap).
+ */
+export declare function isMultiWordByteString(bytes: Uint8Array, sqstr?: 'printable-string' | 'string' | 'none'): boolean;
+/**
+ * True when `rendered` — a single entry's own CDN rendering — is shaped
+ * like a prefixed literal: an identifier immediately followed by `'` or a
+ * backtick (`h'...'`, `b64'...'`, `ip'...'`, `dt'...'`, or any other
+ * app-string extension's own spelling, built-in or user-defined). These
+ * have no natural word boundary to check, so — like a byte string's own
+ * prefixed-literal case in `isMultiWordByteString` — the strict
+ * `inlineLeafContainers` rule (`CborArray`/`CborMap`, and the
+ * indefinite-length string groups) always disqualifies a container from
+ * collapsing onto one line when an entry looks like this; the loose rule
+ * (only `CborEmbeddedCBOR`/`<<...>>`) treats it as an ordinary leaf
+ * instead.
+ *
+ * This is a generic, rendering-based catch-all — unlike `isMultiWordByteString`,
+ * it doesn't need per-extension-class support, so it also covers any
+ * app-string extension (registered under `CborExtension.appStringPrefixes`)
+ * without that extension's own `CborItem` subclass needing to know about
+ * `inlineLeafContainers` at all. It only sees a *bare* prefixed literal
+ * (nothing else in `rendered`); `CborTag` uses `isMultiWordRenderedLiteral`
+ * instead to see through its own tag digits/parens onto whatever they wrap.
+ */
+export declare function isPrefixedLiteralText(rendered: string): boolean;
+/**
+ * True when `rendered` — a leaf entry's own, already-rendered CDN text —
+ * counts as multi-word for `inlineLeafContainers`'s purposes, determined by
+ * tokenizing `rendered` itself rather than predicting from whichever
+ * `CborItem` subclass produced it. This makes it exact regardless of *how*
+ * the text came to look the way it does — a `CborTag` subclass
+ * (`CborTaggedIpExt`) overriding `_toCDN()` to render `IP<<'...'>>` instead
+ * of generic `52(...)` tag notation, a preserved `preserveByteString`
+ * spelling, `encodingIndicators: 'always'` adding an explicit `_N`/`_i`
+ * suffix everywhere, or anything else — since it never assumes a rendering
+ * path, only reads the result.
+ *
+ * Recognizes these shapes. Any of them may be followed by one trailing
+ * `ENCODING_INDICATOR` token (`_0`.._3`/`_i`) — stripped *before* any shape
+ * is recognized (not just for a bare literal), since it can trail a tag or
+ * an app-sequence wrapper too and never changes a value's own shape or
+ * word count:
+ * - A bare quoted literal (`"..."`, `` `...` ``, or a bare `'...'` sqstr):
+ *   always counts if its *decoded* content has two or more words,
+ *   regardless of `strict` — matching a text string's own word count.
+ * - A prefixed literal (`h'...'`, `b64'...'`, `ip'...'`, `dt'...'`, ...):
+ *   has no natural word boundary to check, so it counts only when `strict`.
+ * - A generic tag wrapper (`tagNum[_EI](...)`) spanning the *entire* input:
+ *   peels off just that one layer and recurses on what's inside (handling
+ *   nested tags one layer at a time) — this is what lets a plain `CborTag`
+ *   whose content is one of the shapes above still count, e.g.
+ *   `100(dt'...')`, `100("two words")`, or (with `encodingIndicators:
+ *   'always'`) `100_0("two words"_i)`.
+ * - An app-sequence wrapper (`prefix<<item item ...>>`, tokenized as one
+ *   `APP_SEQUENCE` opener and a plain `GT_GT` closer) spanning the *entire*
+ *   input: unlike a tag, its own `<<...>>` is never peeled away — reading
+ *   fine inline is the whole point of that notation, not a transparent
+ *   single-value rewrap — but each top-level item inside (items may be
+ *   separated by a comma, by whitespace alone, or both, per CDN's own
+ *   grammar — `consumeOneItem` finds each one's extent structurally rather
+ *   than only splitting at commas) is checked under the *loose* rule
+ *   (`strict: false`, matching `<<...>>` itself) regardless of the
+ *   `strict` this function was called with, so a multi-word text item
+ *   (`ilts<<"two words">>`, or `ilts<<"two words" "x">>` with no comma at
+ *   all) still always counts, while a prefixed-literal item
+ *   (`ilbs<<h'00'>>`) — unlike the same literal bare or tag-wrapped —
+ *   does not.
+ * - Anything else (a number, `true`/`false`, multiple top-level tokens that
+ *   aren't one of the wrappers above, ...) never counts.
+ *
+ * Tokenizing can throw on malformed input; since `rendered` is always this
+ * library's own output, that should never happen, but a failure is treated
+ * as "not multi-word" rather than propagating.
+ */
+export declare function isMultiWordRenderedLiteral(rendered: string, strict: boolean): boolean;
 /**
  * Which comment syntax a byte-string literal's raw source recognizes —
  * `undefined` when it has none at all (its content is data, not a comment
@@ -188,12 +404,12 @@ export declare function serializeBytes(bytes: Uint8Array, encoding?: 'hex' | 'ba
  * `b32`/`h32` objects by reference — never guessed later from the prefix
  * string, since a user extension can register under any prefix, including
  * one a built-in also uses; see `CborByteString.ednCommentSyntax`).
- *   - `'full'`: `#`, `//`, `/* *\/`, and `/ /` (§5.2.1/§5.3.3) — `h'...'`
+ *   - `'full'`: `#`, `//`, `/* *\/`, and `/ /` (§6.2.1/§6.3.3) — `h'...'`
  *     and its backtick form, and the built-in `b32'...'`/`h32'...'`
  *     extensions, which share hex's comment syntax (`utils/strip-comments.ts`).
  *   - `'hash-only'`: only `#` line comments — standard base64 (`b64'...'`),
  *     where `/` is valid data (e.g. `//8=` decodes to 0xFFFF), never a
- *     comment marker (see Tokenizer._readByteContent, §5.2.2).
+ *     comment marker (see Tokenizer._readByteContent, §6.2.2).
  */
 export type ByteCommentSyntax = 'full' | 'hash-only';
 /**
@@ -223,6 +439,16 @@ export declare function escapeAppString(s: string): string;
  * Produce an EDN double-quoted string literal `"..."` from a string value.
  */
 export declare function escapeString(s: string): string;
+/**
+ * True when `value` contains two or more "words" per `Intl.Segmenter`'s
+ * word-boundary rules (UAX #29): e.g. `"Hello, World!"` is two words (a
+ * comma breaks them), `"3.14"` is one (a decimal point between digits
+ * doesn't), and space-less scripts like Japanese/Chinese still split on
+ * their own dictionary-based word boundaries. Used by `inlineLeafContainers`
+ * to keep a multi-word string entry off the container's shared line even
+ * when it would otherwise qualify as a leaf.
+ */
+export declare function isMultiWordText(value: string): boolean;
 /** Produce the numeric string for a float value (with decimal point if needed). */
 export declare function floatValueToString(value: number): string;
 /**
@@ -241,13 +467,13 @@ export declare function canonicalEncodingWidth(n: bigint): EncodingWidth;
  * @param getCanonical  - lazily compute the canonical width (only called in 'always' mode)
  */
 export declare function resolveEiSuffix(options: ToCDNOptions | undefined, encodingWidth: EncodingWidth | undefined, getCanonical: () => EncodingWidth): string;
-/** How a node should render under `preserveAppSequence`. */
+/** How a node should render under `preserveAppPrefix`. */
 export type AppSeqRenderDecision = 'verbatim' | 'adjusted' | 'source' | 'structural' | 'normal';
 /**
  * Decide how an extension result node — from a `prefix'...'` /
  * `` prefix`...` `` / `prefix<<...>>` source, or (for a tag-wrapper node
  * that also has a generic `CborTag` fallback to delegate to) a raw tag
- * literal `N(...)` — should render under `ToCDNOptions.preserveAppSequence`.
+ * literal `N(...)` — should render under `ToCDNOptions.preserveAppPrefix`.
  *
  * A raw-tag source is recognised by `ednSource !== undefined`: the parser
  * only ever sets a tag-wrapper's `ednSource` (the tag *number's* digit
@@ -282,7 +508,7 @@ export type AppSeqRenderDecision = 'verbatim' | 'adjusted' | 'source' | 'structu
  *   `preserveConcatenation` override.
  *   Verbatim raw-tag text inherently contains the nested literal spelling.
  * - `'normal'`: fall through to the class's own notation regeneration
- *   (`prefix'...'`), unaffected by `preserveAppSequence`. For `<<...>>`,
+ *   (`prefix'...'`), unaffected by `preserveAppPrefix`. For `<<...>>`,
  *   this is also used when replaying its sole inner item would defeat an
  *   explicitly disabled, relevant literal-preservation option.
  *
@@ -313,3 +539,4 @@ export declare function adjustRawAppSeqSource(appSeqSource: string, options: ToC
  * reliable way to locate it.
  */
 export declare function adjustAppSeqIndicator(appSeqSource: string, newSuffix: string, options: ToCDNOptions | undefined, innerItemEnd: number | undefined, comments: readonly CborComment[] | undefined): string;
+export {};

package/dist/cdn/tokenizer.d.ts

@@ -81,7 +81,7 @@ export declare class Tokenizer {
      * Returns true if a comment was consumed, false if the current char is not a
      * comment start. `quote` is the closing delimiter character.
      *
-     * Supports / ... /, /* *\/, //, and # comment forms (§2.2).
+     * Supports / ... /, /* *\/, //, and # comment forms (§2.1).
      */
     private _skipByteStringComment;
     /**
@@ -98,7 +98,7 @@ export declare class Tokenizer {
      * Called with `i` pointing at the comment-start character.
      * Returns the index after the comment, or -1 if no comment was found.
      *
-     * Supports / ... /, /* *\/, //, and # comment forms (§2.2).
+     * Supports / ... /, /* *\/, //, and # comment forms (§2.1).
      * `context` is used in unterminated-comment error messages.
      */
     private _skipRawComment;
@@ -113,13 +113,13 @@ export declare class Tokenizer {
      * - Literal LF (U+000A) is allowed; all other C0 controls and U+007F are rejected.
      * - Literal CR (U+000D) is silently stripped (source-level CRLF normalisation).
      * - Only spec-defined escape sequences are accepted; `\q` etc. throw SyntaxError.
-     * - `\/` is valid only in double-quoted strings (not in escapable-s, §5.1).
+     * - `\/` is valid only in double-quoted strings (not in escapable-s, §6.1).
      * - `\\` (backslash) is valid in both single- and double-quoted strings.
      * - `\uXXXX` for a high surrogate must be immediately followed by `\uXXXX` for
      *   the corresponding low surrogate; lone surrogates are rejected.
      * - `\u{N}` … `\u{10FFFF}` extended syntax is supported; surrogates are rejected.
      * - In single-quoted strings, `\u` escapes to printable ASCII (U+0020–U+007E)
-     *   are forbidden (hexchar-s restriction, draft-25 §5.1).
+     *   are forbidden (hexchar-s restriction, draft-ietf-cbor-edn-literals-27 §6.1).
      */
     private _readStringContent;
     /**
@@ -134,13 +134,14 @@ export declare class Tokenizer {
      *   which is then decoded into the corresponding non-BMP code point.
      *
      * In single-quoted strings (`quote === "'"`), `\u` escapes that resolve to
-     * printable ASCII (U+0020–U+007E) are rejected per draft-25 §5.1 hexchar-s.
+     * printable ASCII (U+0020–U+007E) are rejected per draft-ietf-cbor-edn-literals-27
+     * §6.1 hexchar-s.
      * Use `\\` for backslash (U+005C) and `\'` for the single-quote delimiter.
      */
     private _readUnicodeEscape;
     /**
      * Read raw text-string content between N-backtick delimiters
-     * (§2.5.4 of draft-ietf-cbor-edn-literals-26).
+     * (§2.3.3 of draft-ietf-cbor-edn-literals-27).
      *
      * - The opening delimiter is the maximal run of consecutive backticks (N ≥ 1).
      * - No escape sequences are processed — content is taken verbatim.
@@ -153,7 +154,7 @@ export declare class Tokenizer {
      */
     private _readRawStringContent;
     /**
-     * Post-process raw hex content from a `h``…``\` raw string (§5.3.3).
+     * Post-process raw hex content from a `h``…``\` raw string (§6.3.3).
      *
      * Skips:
      *   - lblank whitespace (LF, SP; also CR for source-level normalisation)
@@ -162,13 +163,13 @@ export declare class Tokenizer {
      * Detects `...` ellipsis sequences.
      *
      * A trailing `# comment` immediately before the closing delimiter is allowed
-     * per §5.3.3 `r-app-string-h`.
+     * per §6.3.3 `r-app-string-h`.
      *
      * Returns { value: hex-string-with-ellipsis-markers, elided: boolean }
      */
     private _processRawHexContent;
     /**
-     * Post-process raw base64 content from a `b64``…``\` raw string (§5.3.4).
+     * Post-process raw base64 content from a `b64``…``\` raw string (§6.3.4).
      *
      * Skips:
      *   - lblank whitespace (LF, SP; also CR for source-level normalisation)
@@ -180,12 +181,12 @@ export declare class Tokenizer {
     /**
      * Read raw byte-string content between `quote` chars (b64 / b64url).
      *
-     * Strips whitespace and skips `# ...` line comments per §2.5.5.
+     * Strips whitespace and skips `# ...` line comments per §6.2.2.
      * `/` is NOT treated as a comment delimiter because it is a valid base64 character.
      */
     private _readByteContent;
     /**
-     * Read hex byte-string content, recognising `...` ellipsis sequences (§4.2).
+     * Read hex byte-string content, recognising `...` ellipsis sequences (§5.2).
      *
      * Returns the raw hex string (with `...` markers embedded) and a flag
      * indicating whether any ellipsis was found.

package/dist/extensions/builtins.d.ts

@@ -2,17 +2,17 @@ import { CborExtension } from './types';
 /**
  * Core data-model extensions (bignum tags 2/3, embedded-CBOR tag 24, and the
  * CPA888 ellipsis tag). These implement base CBOR/EDN representation rather
- * than an application-oriented extension, so they are always active and are
- * not affected by the `builtinExtensions` option.
+ * than an app-extension, so they are always active and are not affected by
+ * the `builtinExtensions` option.
  */
 export declare const CORE_EXTENSIONS: readonly CborExtension[];
 /**
- * Default application-oriented extensions bundled with the library.
+ * Default app-extensions bundled with the library.
  * Overridable per call via `builtinExtensions` (an array to use instead, or
  * `false` to disable all of them).
  *
- * `dt`, `ip`, `t1`, and `b1` are mandatory-to-implement per §2.1 of
- * draft-ietf-cbor-edn-literals-26; `cri`, `ilbs`, `ilts`, and `float` are
+ * `dt`, `ip`, `t1`, and `b1` are mandatory-to-implement per §3 of
+ * draft-ietf-cbor-edn-literals-27; `cri`, `ilbs`, `ilts`, and `float` are
  * bundled but not mandatory.
  */
 export declare const BUILTIN_EXTENSIONS: readonly CborExtension[];

package/dist/extensions/cri.d.ts

@@ -3,7 +3,7 @@ import { CborExtension } from './types';
 import { CborArray } from '../ast/CborArray';
 import { CborTag } from '../ast/CborTag';
 /**
- * CBOR tag number for the tagged CRI variant (§3.4 and §5.2.5 of draft-ietf-cbor-edn-literals-25).
+ * CBOR tag number for the tagged CRI variant (§3.7 and §6.2.5 of draft-ietf-cbor-edn-literals-27).
  */
 export declare const TAG_CRI = 99n;
 /**
@@ -11,7 +11,7 @@ export declare const TAG_CRI = 99n;
  * Falls back to generic array notation if the content cannot be expressed as a URI.
  */
 export declare class CborCriExt extends CborArray {
-    _toCDN(options: ToCDNOptions | undefined, depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, depth: number, path?: readonly unknown[]): string;
 }
 /**
  * tag(99, CRI array) whose toCDN() emits CRI'…' notation.
@@ -19,10 +19,10 @@ export declare class CborCriExt extends CborArray {
  */
 export declare class CborTaggedCriExt extends CborTag {
     constructor(content: CborArray);
-    _toCDN(options: ToCDNOptions | undefined, depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, depth: number, path?: readonly unknown[]): string;
 }
 /**
- * Create the cri/CRI CborExtension (§3.4 and §5.2.5 of draft-ietf-cbor-edn-literals-25).
+ * Create the cri/CRI CborExtension (§3.7 and §6.2.5 of draft-ietf-cbor-edn-literals-27).
  *
  * - `cri'uri'`        → CborCriExt (bare CRI array, no CBOR tag)
  * - `CRI'uri'`        → CborTaggedCriExt tag(99, CRI array)

package/dist/extensions/dt.d.ts

@@ -32,7 +32,7 @@ export declare class CborEpochDtExtUint extends CborUint {
         encodingWidth?: EncodingWidth;
         ednSource?: string;
     });
-    _toCDN(options: ToCDNOptions | undefined, _depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, _depth: number, path?: readonly unknown[]): string;
 }
 /**
  * Negative epoch timestamp whose toCDN() emits dt'…' notation.
@@ -43,7 +43,7 @@ export declare class CborEpochDtExtNint extends CborNint {
         encodingWidth?: EncodingWidth;
         ednSource?: string;
     });
-    _toCDN(options: ToCDNOptions | undefined, _depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, _depth: number, path?: readonly unknown[]): string;
 }
 /**
  * Float epoch timestamp whose toCDN() emits dt'…' notation.
@@ -54,7 +54,7 @@ export declare class CborEpochDtExtFloat extends CborFloat {
         precision?: 'half' | 'single' | 'double';
         literalSource?: string;
     });
-    _toCDN(options: ToCDNOptions | undefined, _depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, _depth: number, path?: readonly unknown[]): string;
 }
 /**
  * CBOR tag(1, epoch) whose toCDN() emits DT'…' notation.
@@ -64,7 +64,7 @@ export declare class CborTaggedEpochDtExt extends CborTag {
     constructor(datetimeOrContent: string | CborEpochDtExtUint | CborEpochDtExtNint | CborEpochDtExtFloat, options?: {
         encodingWidth?: EncodingWidth;
     });
-    _toCDN(options: ToCDNOptions | undefined, depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, depth: number, path?: readonly unknown[]): string;
 }
 /**
  * CBOR tag(1, epoch) whose toJS() returns a plain Date object.

package/dist/extensions/ip.d.ts

@@ -8,7 +8,7 @@ import { CborArray } from '../ast/CborArray';
  * Bare IP address byte string whose toCDN() emits ip'…' notation.
  */
 export declare class CborIpExt extends CborByteString {
-    _toCDN(options: ToCDNOptions | undefined, _depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, _depth: number, path?: readonly unknown[]): string;
 }
 /**
  * Bare IP address prefix (CIDR) whose toCDN() emits ip'…/prefix' notation.
@@ -17,7 +17,7 @@ export declare class CborIpExt extends CborByteString {
 export declare class CborIpPrefixExt extends CborArray {
     private readonly _isV4;
     constructor(prefixLen: number, truncated: Uint8Array, isV4: boolean);
-    _toCDN(options: ToCDNOptions | undefined, depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, depth: number, path?: readonly unknown[]): string;
 }
 /**
  * CBOR tag(52/54, …) IP address whose toCDN() emits IP'…' notation.
@@ -26,10 +26,10 @@ export declare class CborIpPrefixExt extends CborArray {
  */
 export declare class CborTaggedIpExt extends CborTag {
     constructor(tag: bigint, content: CborItem);
-    _toCDN(options: ToCDNOptions | undefined, depth: number): string;
+    _toCDN(options: ToCDNOptions | undefined, depth: number, path?: readonly unknown[]): string;
 }
 /**
- * Create an ip/IP CborExtension (RFC 9164 / §3.2 of draft-ietf-cbor-edn-literals-25).
+ * Create an ip/IP CborExtension (RFC 9164 / §3.3 of draft-ietf-cbor-edn-literals-27).
  *
  * - `ip'addr'`          → CborIpExt (bare byte string, 4 or 16 bytes)
  * - `IP'addr'`          → CborTaggedIpExt  tag(52 or 54, bytes)