@cbortech/cbor 0.26.6 → 0.26.8

package/dist/ast/CborTextString.d.ts

@@ -10,16 +10,52 @@ export declare class CborTextString extends CborItem {
     readonly ednParts: readonly string[] | undefined;
     /** Original raw-string source text, when parsed from a single backtick literal. */
     readonly ednSource: string | undefined;
+    /**
+     * Original double-quoted source text (including its escape sequences),
+     * when parsed from a single non-concatenated `"..."` literal. Used by
+     * `_toCDN()` to round-trip the literal's exact spelling when
+     * `preserveTextString` is set.
+     */
+    readonly quotedEdnSource: string | undefined;
     /**
      * Original source text per `ednParts` entry, aligned by index; `undefined`
      * for parts that were not raw backtick literals.
      */
     readonly ednPartSources: readonly (string | undefined)[] | undefined;
+    /**
+     * `true` at index `i`, aligned with `ednParts`, when that part came from a
+     * byte-string literal on the right of a text-leading `+` concatenation
+     * (decoded as UTF-8 and merged in per §5.1) rather than a double-quoted
+     * `"..."` literal. Both cases leave `ednPartSources[i]` `undefined` (byte
+     * strings have no preserved raw source here, same as an unpreserved
+     * double-quoted literal), so this is what lets `appSeqSourceFeatures`
+     * attribute the part to `byteString` instead of the unpreservable
+     * `textString`.
+     */
+    readonly ednPartIsByteString: readonly boolean[] | undefined;
+    /**
+     * Source span of each `ednParts` entry's own literal token, aligned by
+     * index — used to place a comment sitting between two `+`-joined parts at
+     * the right gap instead of dropping it (there is no per-part AST node for
+     * such a comment to attach to; it lands as `dangling` on this whole node
+     * instead — see `CborByteString.ednParts`'s equivalent doc). `undefined`
+     * for a node not parsed from a `+` chain at all.
+     */
+    readonly ednPartSpans: readonly {
+        start: number;
+        end: number;
+    }[] | undefined;
     constructor(value: string, options?: {
         encodingWidth?: EncodingWidth;
         ednParts?: readonly string[];
         ednSource?: string;
+        quotedEdnSource?: string;
         ednPartSources?: readonly (string | undefined)[];
+        ednPartIsByteString?: readonly boolean[];
+        ednPartSpans?: readonly {
+            start: number;
+            end: number;
+        }[];
     });
     _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void;
     _toCDN(options: ToCDNOptions | undefined, depth: number): string;

package/dist/ast/CborUint.d.ts

@@ -5,8 +5,16 @@ import { CborWriter, EncodingWidth } from '../cbor/encode';
 export declare class CborUint extends CborItem {
     readonly value: bigint;
     encodingWidth: EncodingWidth | undefined;
+    /**
+     * Original CDN digit spelling (base + digits, without the encoding-
+     * indicator suffix), set by the parser when this value came from CDN
+     * text. Used by `_toCDN()` to round-trip the literal's base (`0xff`,
+     * `0o377`, `0b101`, decimal) when `preserveNumberFormat` is set.
+     */
+    readonly ednSource?: string;
     constructor(value: number | bigint, options?: {
         encodingWidth?: EncodingWidth;
+        ednSource?: string;
     });
     _encodeTo(writer: CborWriter, _options?: ToCBOROptions): void;
     _toCDN(options: ToCDNOptions | undefined, _depth: number): string;

package/dist/ast/index.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../mapEntries-BhMlCwYo.cjs");exports.CborArray=e.E,exports.CborBigNint=e.v,exports.CborBigUint=e.y,exports.CborByteString=e.k,exports.CborEmbeddedCBOR=e.C,exports.CborFloat=e.j,exports.CborIndefiniteByteString=e.O,exports.CborIndefiniteTextString=e.D,exports.CborItem=e.F,exports.CborMap=e.T,exports.CborNint=e.N,exports.CborSimple=e.w,exports.CborTag=e.A,exports.CborTextString=e.g,exports.CborUint=e.P;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../mapEntries-BJzyBUH5.cjs");exports.CborArray=e.D,exports.CborBigNint=e._,exports.CborBigUint=e.v,exports.CborByteString=e.A,exports.CborEmbeddedCBOR=e.w,exports.CborFloat=e.M,exports.CborIndefiniteByteString=e.k,exports.CborIndefiniteTextString=e.O,exports.CborItem=e.I,exports.CborMap=e.E,exports.CborNint=e.P,exports.CborSimple=e.T,exports.CborTag=e.j,exports.CborTextString=e.h,exports.CborUint=e.F;

package/dist/ast/index.d.ts

@@ -1,4 +1,5 @@
 export { CborItem } from './CborItem';
+export type { AppSeqEncodingEdit, AppSeqSourceFeatures } from './CborItem';
 export { CborUint } from './CborUint';
 export { CborBigUint, CborBigNint } from './CborBignum';
 export { CborNint } from './CborNint';

package/dist/ast/index.js

@@ -1,2 +1,2 @@
-import { A as e, C as t, D as n, E as r, F as i, N as a, O as o, P as s, T as c, g as l, j as u, k as d, v as f, w as p, y as m } from "../mapEntries-Czxt-cmd.js";
-export { r as CborArray, f as CborBigNint, m as CborBigUint, d as CborByteString, t as CborEmbeddedCBOR, u as CborFloat, o as CborIndefiniteByteString, n as CborIndefiniteTextString, i as CborItem, c as CborMap, a as CborNint, p as CborSimple, e as CborTag, l as CborTextString, s as CborUint };
+import { A as e, D as t, E as n, F as r, I as i, M as a, O as o, P as s, T as c, _ as l, h as u, j as d, k as f, v as p, w as m } from "../mapEntries-Ci_dppP6.js";
+export { t as CborArray, l as CborBigNint, p as CborBigUint, e as CborByteString, m as CborEmbeddedCBOR, a as CborFloat, f as CborIndefiniteByteString, o as CborIndefiniteTextString, i as CborItem, n as CborMap, s as CborNint, c as CborSimple, d as CborTag, u as CborTextString, r as CborUint };

package/dist/cddl/index.cjs

@@ -1,3 +1,3 @@
-Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});const e=require("../schema-BmGsaEaW.cjs");function t(e,t){let n=Math.max(0,Math.min(t,e.length)),r=1,i=0;for(let t=0;t<n;t++)e.charCodeAt(t)===10&&(r++,i=t+1);return{line:r,column:n-i+1}}var n=class{static compile(t,n){return e.n(t,n)}};function r(t){let n=new e.o(t),r=[];for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}function i(t){let n=new e.o(t),r=[];try{for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}catch(i){let a=i instanceof e.l?i:new e.l(i instanceof Error?i.message:String(i)),o=n.lastEndOffset;if(o<t.length){let e=1,n=1;for(let r=0;r<o;r++)t[r]===`
+Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});const e=require("../schema-DgnkH0P6.cjs");function t(e,t){let n=Math.max(0,Math.min(t,e.length)),r=1,i=0;for(let t=0;t<n;t++)e.charCodeAt(t)===10&&(r++,i=t+1);return{line:r,column:n-i+1}}var n=class{static compile(t,n){return e.n(t,n)}};function r(t){let n=new e.o(t),r=[];for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}function i(t){let n=new e.o(t),r=[];try{for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}catch(i){let a=i instanceof e.l?i:new e.l(i instanceof Error?i.message:String(i)),o=n.lastEndOffset;if(o<t.length){let e=1,n=1;for(let r=0;r<o;r++)t[r]===`
 `?(e++,n=1):n++;r.push({type:`ERROR`,value:t.slice(o),raw:t.slice(o),line:e,col:n,offset:o,endOffset:t.length})}return{tokens:r,comments:n.comments,error:a}}}exports.CDDL=n,exports.default=n,exports.CddlMismatchError=e.s,exports.CddlSchema=e.t,exports.CddlSemanticError=e.c,exports.CddlSyntaxError=e.l,exports.PRELUDE_CDDL=e.r,exports.getPreludeRules=e.i,exports.parseCDDL=e.a,exports.positionAt=t,exports.tokenize=r,exports.tokenizeLenient=i;
 //# sourceMappingURL=index.cjs.map

package/dist/cddl/index.js

@@ -1,4 +1,4 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "../schema-BxkgvUY6.js";
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "../schema-y8G5mDIS.js";
 //#region src/cddl/position.ts
 function l(e, t) {
 	let n = Math.max(0, Math.min(t, e.length)), r = 1, i = 0;

package/dist/cdn/index.cjs

@@ -1,3 +1,3 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../tokenizer-EciPlN0n.cjs");function t(t){let n=new e.t(t),r=[];for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}function n(t){let n=new e.t(t),r=[];try{for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}catch(i){let a=i instanceof e.o?i:new e.o(i instanceof Error?i.message:String(i)),o=n.lastEndOffset;if(o<t.length){let e=1,n=1;for(let r=0;r<o;r++)t[r]===`
-`?(e++,n=1):n++;r.push({type:`ERROR`,value:t.slice(o),raw:t.slice(o),line:e,col:n,offset:o,endOffset:t.length})}return{tokens:r,comments:n.comments,error:a}}}exports.CdnSyntaxError=e.o,exports.tokenize=t,exports.tokenizeLenient=n;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("../tokenizer-BD08xbyd.cjs");function t(t){let n=new e.t(t),r=[];for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}function n(t){let n=new e.t(t),r=[];try{for(;;){let e=n.consume();if(e.type===`EOF`)break;r.push(e)}return{tokens:r,comments:n.comments}}catch(i){let a=i instanceof e.D?i:new e.D(i instanceof Error?i.message:String(i)),o=n.lastEndOffset;if(o<t.length){let e=1,n=1;for(let r=0;r<o;r++)t[r]===`
+`?(e++,n=1):n++;r.push({type:`ERROR`,value:t.slice(o),raw:t.slice(o),line:e,col:n,offset:o,endOffset:t.length})}return{tokens:r,comments:n.comments,error:a}}}exports.CdnSyntaxError=e.D,exports.adjustAppSeqIndicator=e.n,exports.adjustRawAppSeqSource=e.r,exports.canonicalEncodingWidth=e.i,exports.decideTaggedAppSeqRendering=e.s,exports.resolveEiSuffix=e._,exports.tokenize=t,exports.tokenizeLenient=n;
 //# sourceMappingURL=index.cjs.map

package/dist/cdn/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../src/cdn/index.ts"],"sourcesContent":["/**\n * Public lower-level CDN tokenization API (`@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.\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 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":"gHAgCA,SAAgB,EAAS,EAA8B,CACrD,IAAM,EAAY,IAAI,EAAA,EAAU,CAAI,EAC9B,EAAkB,CAAC,EACzB,OAAS,CACP,IAAM,EAAM,EAAU,QAAQ,EAC9B,GAAI,EAAI,OAAS,MAAO,MACxB,EAAO,KAAK,CAAG,CACjB,CACA,MAAO,CAAE,SAAQ,SAAU,EAAU,QAAS,CAChD,CAQA,SAAgB,EAAgB,EAAqC,CACnE,IAAM,EAAY,IAAI,EAAA,EAAU,CAAI,EAC9B,EAAkB,CAAC,EACzB,GAAI,CACF,OAAS,CACP,IAAM,EAAM,EAAU,QAAQ,EAC9B,GAAI,EAAI,OAAS,MAAO,MACxB,EAAO,KAAK,CAAG,CACjB,CACA,MAAO,CAAE,SAAQ,SAAU,EAAU,QAAS,CAChD,OAAS,EAAG,CACV,IAAM,EACJ,aAAa,EAAA,EACT,EACA,IAAI,EAAA,EAAe,aAAa,MAAQ,EAAE,QAAU,OAAO,CAAC,CAAC,EAC7D,EAAQ,EAAU,cACxB,GAAI,EAAQ,EAAK,OAAQ,CACvB,IAAI,EAAO,EACP,EAAM,EACV,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,IACrB,EAAK,KAAO;GACd,IACA,EAAM,GAEN,IAGJ,EAAO,KAAK,CACV,KAAM,QACN,MAAO,EAAK,MAAM,CAAK,EACvB,IAAK,EAAK,MAAM,CAAK,EACrB,OACA,MACA,OAAQ,EACR,UAAW,EAAK,MAClB,CAAC,CACH,CACA,MAAO,CAAE,SAAQ,SAAU,EAAU,SAAU,OAAM,CACvD,CACF"}
+{"version":3,"file":"index.cjs","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":"gHAkDA,SAAgB,EAAS,EAA8B,CACrD,IAAM,EAAY,IAAI,EAAA,EAAU,CAAI,EAC9B,EAAkB,CAAC,EACzB,OAAS,CACP,IAAM,EAAM,EAAU,QAAQ,EAC9B,GAAI,EAAI,OAAS,MAAO,MACxB,EAAO,KAAK,CAAG,CACjB,CACA,MAAO,CAAE,SAAQ,SAAU,EAAU,QAAS,CAChD,CAQA,SAAgB,EAAgB,EAAqC,CACnE,IAAM,EAAY,IAAI,EAAA,EAAU,CAAI,EAC9B,EAAkB,CAAC,EACzB,GAAI,CACF,OAAS,CACP,IAAM,EAAM,EAAU,QAAQ,EAC9B,GAAI,EAAI,OAAS,MAAO,MACxB,EAAO,KAAK,CAAG,CACjB,CACA,MAAO,CAAE,SAAQ,SAAU,EAAU,QAAS,CAChD,OAAS,EAAG,CACV,IAAM,EACJ,aAAa,EAAA,EACT,EACA,IAAI,EAAA,EAAe,aAAa,MAAQ,EAAE,QAAU,OAAO,CAAC,CAAC,EAC7D,EAAQ,EAAU,cACxB,GAAI,EAAQ,EAAK,OAAQ,CACvB,IAAI,EAAO,EACP,EAAM,EACV,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,IACrB,EAAK,KAAO;GACd,IACA,EAAM,GAEN,IAGJ,EAAO,KAAK,CACV,KAAM,QACN,MAAO,EAAK,MAAM,CAAK,EACvB,IAAK,EAAK,MAAM,CAAK,EACrB,OACA,MACA,OAAQ,EACR,UAAW,EAAK,MAClB,CAAC,CACH,CACA,MAAO,CAAE,SAAQ,SAAU,EAAU,SAAU,OAAM,CACvD,CACF"}

package/dist/cdn/index.d.ts

@@ -2,6 +2,8 @@ import { Token, EdnComment } from './tokenizer';
 import { CdnSyntaxError } from './errors';
 export type { Token, TokenType, EdnComment } from './tokenizer';
 export { CdnSyntaxError } from './errors';
+export { resolveEiSuffix, canonicalEncodingWidth, decideTaggedAppSeqRendering, adjustRawAppSeqSource, adjustAppSeqIndicator, } from './serialize-utils';
+export type { AppSeqRenderDecision } from './serialize-utils';
 export interface TokenizeResult {
     /** Scanned tokens in source order, excluding the final EOF token. */
     tokens: Token[];

package/dist/cdn/index.js

@@ -1,52 +1,52 @@
-import { o as e, t } from "../tokenizer-CeuixxXi.js";
+import { D as e, _ as t, i as n, n as r, r as i, s as a, t as o } from "../tokenizer-N-vAvRdj.js";
 //#region src/cdn/index.ts
-function n(e) {
-	let n = new t(e), r = [];
+function s(e) {
+	let t = new o(e), n = [];
 	for (;;) {
-		let e = n.consume();
+		let e = t.consume();
 		if (e.type === "EOF") break;
-		r.push(e);
+		n.push(e);
 	}
 	return {
-		tokens: r,
-		comments: n.comments
+		tokens: n,
+		comments: t.comments
 	};
 }
-function r(n) {
-	let r = new t(n), i = [];
+function c(t) {
+	let n = new o(t), r = [];
 	try {
 		for (;;) {
-			let e = r.consume();
+			let e = n.consume();
 			if (e.type === "EOF") break;
-			i.push(e);
+			r.push(e);
 		}
 		return {
-			tokens: i,
-			comments: r.comments
+			tokens: r,
+			comments: n.comments
 		};
-	} catch (t) {
-		let a = t instanceof e ? t : new e(t instanceof Error ? t.message : String(t)), o = r.lastEndOffset;
-		if (o < n.length) {
-			let e = 1, t = 1;
-			for (let r = 0; r < o; r++) n[r] === "\n" ? (e++, t = 1) : t++;
-			i.push({
+	} catch (i) {
+		let a = i instanceof e ? i : new e(i instanceof Error ? i.message : String(i)), o = n.lastEndOffset;
+		if (o < t.length) {
+			let e = 1, n = 1;
+			for (let r = 0; r < o; r++) t[r] === "\n" ? (e++, n = 1) : n++;
+			r.push({
 				type: "ERROR",
-				value: n.slice(o),
-				raw: n.slice(o),
+				value: t.slice(o),
+				raw: t.slice(o),
 				line: e,
-				col: t,
+				col: n,
 				offset: o,
-				endOffset: n.length
+				endOffset: t.length
 			});
 		}
 		return {
-			tokens: i,
-			comments: r.comments,
+			tokens: r,
+			comments: n.comments,
 			error: a
 		};
 	}
 }
 //#endregion
-export { e as CdnSyntaxError, n as tokenize, r as tokenizeLenient };
+export { e as CdnSyntaxError, r as adjustAppSeqIndicator, i as adjustRawAppSeqSource, n as canonicalEncodingWidth, a as decideTaggedAppSeqRendering, t as resolveEiSuffix, s as tokenize, c as tokenizeLenient };
 
 //# sourceMappingURL=index.js.map

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 API (`@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.\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 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":";;AAgCA,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 `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"}

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

@@ -1,5 +1,6 @@
 import { CborComment, CborComments, ToCDNOptions } from '../types';
 import { EncodingWidth } from '../cbor/encode';
+import { AppSeqEncodingEdit, AppSeqSourceFeatures } from '../ast/CborItem';
 /** 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. */
@@ -9,10 +10,18 @@ export declare function indentOf(indentStr: string, depth: number): string;
  *
  * Single-line (` + `) when indent is disabled; otherwise each continuation
  * part starts on its own line, indented one level deeper than the owner.
+ *
+ * `midComments`, when given, holds already-converted comment lines for each
+ * gap between two consecutive parts (`midComments[i]` sits between
+ * `literals[i]` and `literals[i + 1]`) — e.g. a comment between two
+ * `+`-joined byte-string literals, which has nowhere else to attach since
+ * there is no per-part AST node. Ignored in single-line mode, matching every
+ * other comment kind.
  */
-export declare function joinConcatParts(literals: readonly string[], indentStr: string | null, depth: number): string;
+export declare function joinConcatParts(literals: readonly 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;
@@ -29,7 +38,49 @@ export declare function hasContainerLayoutComments(item: Commented): boolean;
  * this (e.g. `/**…*\/` → `/ *…/`).
  */
 export declare function convertCommentText(comment: CborComment, style: 'c-style' | 'cdn-style' | undefined): string;
-export declare function formatLeadingComments(item: Commented, indent: string, style?: 'c-style' | 'cdn-style' | undefined): string[];
+/**
+ * Bucket a flat, source-ordered list of comments (typically a node's own
+ * `comments.dangling`) by which gap between two consecutive `parts` each
+ * one's offset falls into — `result[i]` sits between `parts[i]` and
+ * `parts[i + 1]`, already converted to the requested marker style.
+ *
+ * Used for a comment that sits between two `+`-joined fragments merged into
+ * a single value with no per-fragment AST node of its own to attach to (a
+ * concatenated `CborByteString`'s own `ednParts`, or — inside a bytes
+ * elision — a `CborEllipsis` item's `ednParts`): `attachComments` can only
+ * land such a comment on the merged node as a whole, as `dangling`, so this
+ * re-derives which specific gap it belongs in from each part's own
+ * `start`/`end` span. A comment is dropped (as it already was before this
+ * function existed) when either neighbouring part lacks a known span — a
+ * part merged from a single elided literal's own internal segments, which
+ * cannot have a comment between them anyway (see `_elidedHexAtoms`).
+ *
+ * Returns `undefined` (rather than an all-empty array) when nothing landed
+ * in any gap, so callers can cheaply skip the mid-comment rendering path
+ * entirely in the common case.
+ */
+export declare function danglingCommentsByGap(dangling: readonly CborComment[] | undefined, parts: readonly {
+    start?: number;
+    end?: number;
+}[] | undefined, style: 'c-style' | 'cdn-style' | undefined): string[][] | undefined;
+/**
+ * Split an item's leading comments into ones that get their own line above
+ * it, and a trailing run of comments the parser found on the same source
+ * line as the item itself (`CborComment.sameLine`) — e.g.
+ * `/ protected / << ... >>,` in an RFC 9052-style annotated array. Since
+ * comments and the item they lead up to appear in strictly increasing
+ * source order, `sameLine` comments always form a contiguous run at the end
+ * of the list (nothing can sit between a same-line comment and the item
+ * without itself being on that same line).
+ *
+ * `ownLines` renders like `formatLeadingComments` used to; `inlinePrefix` is
+ * meant to be prepended directly to the item's own rendered line (already
+ * includes a trailing space per comment, or `''` when there is none).
+ */
+export declare function splitLeadingComments(item: Commented, indent: string, style?: 'c-style' | 'cdn-style' | undefined): {
+    ownLines: string[];
+    inlinePrefix: string;
+};
 export declare function formatTrailingComments(item: Commented, style?: 'c-style' | 'cdn-style' | undefined): string;
 export declare function formatDanglingComments(item: Commented, indent: string, style?: 'c-style' | 'cdn-style' | undefined): string[];
 /**
@@ -59,26 +110,46 @@ export declare function resolveSeparators(options: ToCDNOptions | undefined, com
  * comments — line comments can only be terminated by a newline.
  *
  * Entries are accessed through per-index callbacks (not materialised entry
- * objects) so the common no-comments path allocates nothing per entry.
- * `hasEntryComments`, `entryLeadingNode`, and `entryTrailing` are consulted
- * only when `preserveComments` is set.  `renderEntry` receives the resolved
- * `colSep` (': ' or ':' depending on compact mode) for rendering map pairs.
+ * objects) so the common no-comments/no-blank-line path allocates nothing
+ * per entry. `hasEntryComments` and `entryTrailing` are consulted only when
+ * `preserveComments` is set; `entryLeadingNode` is also consulted when
+ * `preserveBlankLines` is set, independently of `preserveComments`, to read
+ * its `blankLineBefore` flag. `renderEntry` receives the resolved `colSep`
+ * (': ' or ':' depending on compact mode) for rendering map pairs.
  */
 export declare function serializeContainer(p: {
     node: Commented;
     options: ToCDNOptions | undefined;
     depth: number;
-    openChar: '[' | '{' | '(';
-    closeChar: ']' | '}' | ')';
+    openChar: string;
+    closeChar: string;
     count: number;
     indefiniteLength: boolean;
     encodingWidth: EncodingWidth | undefined;
+    /**
+     * Where the resolved encoding-indicator suffix is placed.
+     * - `'open'` (default): right after `openChar`, before the content
+     *   (`[_2 1,2,3]`) — the head this indicator describes encodes entry count.
+     * - `'close'`: right after `closeChar`, with no separating space
+     *   (`<<1,2>>_1`) — for `CborEmbeddedCBOR`, whose byte-string head encodes
+     *   content byte length, not entry count.
+     */
+    eiPosition?: 'open' | 'close';
+    /**
+     * Basis for canonical-encoding-width detection (`encodingIndicators:
+     * 'auto'`/`'always'` with no explicit `encodingWidth`). Defaults to
+     * `count`, matching the CBOR array/map head. `CborEmbeddedCBOR` overrides
+     * this to its encoded content's byte length instead.
+     */
+    canonicalCount?: () => bigint;
     hasEntryComments: () => 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.
+     * 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).
      */
     entryIsLeaf?: (i: number) => boolean;
     /** Node whose leading comments are emitted above entry `i` (item / map key). */
@@ -86,7 +157,63 @@ export declare function serializeContainer(p: {
     /** Pre-formatted trailing comment text for entry `i` (starts with ' ', or ''). */
     entryTrailing: (i: number, style: 'c-style' | 'cdn-style' | undefined) => string;
 }): string;
+/**
+ * Single-child counterpart to `serializeContainer`, for a wrapper that
+ * holds exactly one child inside `openChar`/`closeChar` (currently just
+ * `CborTag`'s `(content)`) rather than a comma-separated list of entries.
+ *
+ * Emits the child's own leading/trailing comments, and the wrapper node's
+ * `dangling` comments (a comment positioned after the child but still
+ * inside the brackets, with nothing following it to attach to as leading —
+ * mirroring how `serializeContainer` handles a container's own dangling
+ * comments). Falls back to the plain single-line `(content)` form — the
+ * common, zero-allocation-beyond-string-concat path — when comments aren't
+ * requested/applicable (no indent, no `preserveComments`, or neither the
+ * child nor the wrapper has any).
+ *
+ * `renderChild` is called with the child's depth exactly once, resolved
+ * *before* calling it: `depth + 1` when comments force multi-line
+ * 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).
+ */
+export declare function renderSingleChildWithComments(child: Commented, wrapper: Commented, options: 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;
+/**
+ * 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
+ * host). Set once, at parse time, by whoever actually knows the literal's
+ * real origin (the tokenizer for `h'...'`/`b64'...'`/bare sqstr, or the
+ * parser comparing the resolved extension against the specific built-in
+ * `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'...'`
+ *     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).
+ */
+export type ByteCommentSyntax = 'full' | 'hash-only';
+/**
+ * Strip comments from inside a preserved byte-string literal's raw source,
+ * keeping everything else — case, whitespace, `...` — untouched. Used when
+ * `preserveByteString` is set but `preserveComments` is not: the preserved
+ * spelling should still drop comments, the same as an unpreserved literal
+ * re-derived from its decoded value would. `syntax` selects the comment
+ * rules to apply (see `ByteCommentSyntax`); the caller is responsible for
+ * knowing which one is correct — this function does not guess from `raw`.
+ *
+ * Only scans the quote-delimited content (not the prefix or a trailing
+ * encoding-indicator suffix), and mirrors the tokenizer's own
+ * comment-recognition closely enough for realistic input; a comment
+ * containing a literal copy of the delimiter quote character is not
+ * specially handled (the input is already known-valid, so at worst this
+ * shifts where the content/comment boundary is drawn, never produces
+ * unparseable output).
+ */
+export declare function stripByteLiteralComments(raw: string, syntax: ByteCommentSyntax): string;
 /**
  * Produce a single-quoted EDN app-string content `'...'` from a string value.
  * Exported for use by app-extension `_toCDN` implementations.
@@ -114,3 +241,75 @@ 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`. */
+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`.
+ *
+ * A raw-tag source is recognised by `ednSource !== undefined`: the parser
+ * only ever sets a tag-wrapper's `ednSource` (the tag *number's* digit
+ * spelling) when it was reached via `N(...)`, never via one of the
+ * app-string/-sequence forms. Leaf (non-tag-wrapper) nodes have no raw-tag
+ * form at all — always pass `undefined` for `ednSource` there.
+ *
+ * Returns:
+ * - `'verbatim'`: re-emit `appSeqSource` as-is. Only reachable for a
+ *   raw-tag source: its encoding-indicator suffixes are nested at two
+ *   independent positions (tag number and inner content), so this is only
+ *   safe in `'auto'` mode with no relevant sibling option overridden.
+ * - `'source'`: keep a raw-tag source structurally verbatim, applying
+ *   comment and encoding-indicator changes by their captured source spans.
+ *   This avoids changing unrelated literal spelling or layout.
+ * - `'adjusted'`: for an app-string/-sequence source, strip whatever
+ *   *outer* indicator suffix is already at the end of `appSeqSource` (or,
+ *   under `'never'`, also an *inner* one immediately before `<<...>>`'s
+ *   closing `>>` — the app-sequence's sole item's own indicator) and let
+ *   the caller append one recomputed via `resolveEiSuffix`/`floatSuffix`
+ *   for the current mode via `adjustAppSeqIndicator` — correct in every
+ *   mode, without losing the source's notation family. (An inner indicator
+ *   can only be *stripped*, not *recomputed*: the item's own encoding
+ *   width isn't tracked once resolved to a plain date/address string, so
+ *   `'always'` cannot add a missing one — it is left absent.)
+ * - `'structural'`: keep the raw-tag notation *family* (as opposed to
+ *   upgrading to `prefix'...'`) but re-derive it structurally — via the
+ *   node's own `CborTag` rendering — instead of using `appSeqSource`
+ *   verbatim. Needed whenever verbatim text would ignore a sibling option
+ *   that must apply per nested node: an explicit `preserveNumberFormat` /
+ *   `preserveByteString` / `preserveTextString` / `preserveRawString` /
+ *   `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 `<<...>>`,
+ *   this is also used when replaying its sole inner item would defeat an
+ *   explicitly disabled, relevant literal-preservation option.
+ *
+ * `editsComplete` (from `CborItem.appSeqEncodingEditsComplete`, raw-tag
+ * sources only) is `false` when the tag's content contains a node type
+ * `collectContentEncodingEdits` doesn't cover (e.g. a `CborMap` nested in an
+ * `ip` array's raw-tag content). `'source'` relies on those edits to apply
+ * `encodingIndicators: 'always'`/`'never'`, so incomplete coverage would
+ * silently leave the uncovered node's own indicator unchanged; `'structural'`
+ * is used instead, since it re-derives every nested indicator recursively.
+ */
+export declare function decideTaggedAppSeqRendering(options: ToCDNOptions | undefined, appSeqSource: string | undefined, ednSource: string | undefined, sourceFeatures?: AppSeqSourceFeatures, editsComplete?: boolean): AppSeqRenderDecision;
+/** Apply comment/EI options directly to a preserved raw-tag source. */
+export declare function adjustRawAppSeqSource(appSeqSource: string, options: ToCDNOptions | undefined, comments: readonly CborComment[] | undefined, encodingEdits: readonly AppSeqEncodingEdit[] | undefined): string;
+/**
+ * Adjust an `'adjusted'` app-string/-sequence source: apply requested comment
+ * conversion/removal by captured source span, strip the existing
+ * encoding-indicator suffix(es), then append `newSuffix` (the outer/wrapper
+ * indicator recomputed for the current mode) — see
+ * `decideTaggedAppSeqRendering`.
+ *
+ * Under `encodingIndicators: 'never'`, an inner (item-level) indicator is
+ * also stripped, using
+ * `innerItemEnd` (see `CborItem.appSeqInnerEnd`) to find it by its actual
+ * parsed position rather than by pattern-matching text near the closing
+ * `>>` — whitespace, a trailing comma, and/or a comment can all separate
+ * the two, in any combination, so a position-based cut is the only fully
+ * reliable way to locate it.
+ */
+export declare function adjustAppSeqIndicator(appSeqSource: string, newSuffix: string, options: ToCDNOptions | undefined, innerItemEnd: number | undefined, comments: readonly CborComment[] | undefined): string;

package/dist/extensions/dt.d.ts

@@ -30,6 +30,7 @@ export declare const TAG_EPOCH = 1n;
 export declare class CborEpochDtExtUint extends CborUint {
     constructor(value: number | bigint, options?: {
         encodingWidth?: EncodingWidth;
+        ednSource?: string;
     });
     _toCDN(options: ToCDNOptions | undefined, _depth: number): string;
 }
@@ -40,6 +41,7 @@ export declare class CborEpochDtExtUint extends CborUint {
 export declare class CborEpochDtExtNint extends CborNint {
     constructor(value: number | bigint, options?: {
         encodingWidth?: EncodingWidth;
+        ednSource?: string;
     });
     _toCDN(options: ToCDNOptions | undefined, _depth: number): string;
 }
@@ -50,6 +52,7 @@ export declare class CborEpochDtExtNint extends CborNint {
 export declare class CborEpochDtExtFloat extends CborFloat {
     constructor(value: number, options?: {
         precision?: 'half' | 'single' | 'double';
+        literalSource?: string;
     });
     _toCDN(options: ToCDNOptions | undefined, _depth: number): string;
 }

package/dist/extensions/types.d.ts

@@ -52,17 +52,39 @@ export interface CborExtension {
      */
     parseAppSequence?(prefix: string, items: CborItem[], onError?: (msg: string) => void): CborItem;
     /**
-     * When `true`, the CDN parser wraps the result of `parseAppSequence` in a
-     * `CborAppSeqResult` so that `toCDN()` round-trips the original
-     * `prefix<<...>>` notation when `appStrings !== false`. In single-line
-     * output (no `indent`), a source spelling that spans multiple lines falls
-     * back to serializing the resolved item instead.
+     * Controls how the CDN parser preserves the original application-string
+     * / -sequence / raw-tag source text — `prefix'...'`, `` prefix`...` ``,
+     * `prefix<<...>>`, or a raw tag literal `N(...)` resolved via `parseTag`
+     * — for round-tripping through `toCDN()`.
      *
-     * Extensions whose result is already a subclass that handles source
-     * preservation itself (e.g. `CborFloat` via its `ednSource` property) should
-     * leave this unset.
+     * - `true`: the parser wraps the result of `parseAppSequence` (only —
+     *   `parseAppString` and `parseTag` results are unaffected) in a
+     *   `CborAppSeqResult`, which round-trips the original `<<...>>` notation
+     *   unconditionally whenever `appStrings !== false` (no extra option
+     *   needed). Use this when the result has no dedicated subclass whose
+     *   identity callers rely on (e.g. `instanceof` checks) — the wrapper
+     *   changes the returned node's type.
+     * - `'optional'`: for `parseAppString`, `parseAppSequence`, and `parseTag`
+     *   results alike, the parser instead sets `appSeqSource` directly on the
+     *   *same* result node (preserving its class/identity) and leaves it to
+     *   the node's own `_toCDN()` override to decide whether to use it — by
+     *   convention, only when `ToCDNOptions.preserveAppSequence` is set, so
+     *   the default output keeps regenerating `prefix'...'` form from the
+     *   resolved value. This covers a `` prefix`...` `` (backtick) source, a
+     *   non-canonically-spelled `prefix'...'` source, and a raw tag literal
+     *   (e.g. `1(1749772800)`) that would otherwise be upgraded to
+     *   `prefix'...'` notation — not just `<<...>>`. Use this when the result
+     *   is a dedicated subclass whose default behavior is to regenerate its
+     *   notation from the resolved value on every call.
+     * - `undefined` (default): neither happens. Extensions whose result
+     *   already handles source preservation itself (e.g. `CborFloat` via its
+     *   own `ednSource` property) should leave this unset.
+     *
+     * In single-line output (no `indent`), a source spelling that spans
+     * multiple lines always falls back to serializing the resolved item,
+     * regardless of mode.
      */
-    readonly preserveAppSeqSource?: boolean;
+    readonly preserveAppSeqSource?: boolean | 'optional';
     /**
      * Called when a `CborTag` is encountered during CBOR decode (`fromCBOR`)
      * or EDN integer-tag parsing (`fromCDN`).