@wavehouse/chtypes 0.5.2 → 1.0.2

package/dist/env.js

@@ -0,0 +1,57 @@
+/**
+ * The fetch layer's environment (`docs/guides/fetch-v1.md` §2 and §4): the
+ * variables that configure a fetch without code. `CHTYPES_ARTIFACTS_URL` and
+ * `CHTYPES_CACHE` are read by the fetch layer itself; the rest are read here,
+ * once, and an option the caller passed always wins over its variable.
+ *
+ *   CHTYPES_DOWNLOAD_TOKEN   `token`
+ *   CHTYPES_TRUSTED_KEYS     `trustedKeys`: comma-separated raw ed25519 keys, 64 hex characters each; REPLACES the default list
+ *   CHTYPES_ALLOW_UNSIGNED   `allowUnsigned`: `1`, `true`, `yes` or `on`
+ *   CHTYPES_TARGET           `platform`: one of the three platform keys
+ *   CHTYPES_REGISTRY         retired: one warning, otherwise ignored
+ */
+import { usageError } from './abi1/index.js';
+import { ENV_ALLOW_UNSIGNED_NAME, ENV_BASES_NAME, ENV_CACHE_NAME, ENV_RETIRED, ENV_TARGET_NAME, ENV_TOKEN_NAME, ENV_TRUSTED_KEYS_NAME, PLATFORMS, } from './ocifetch/constants.gen.js';
+import { isPlatformKey, keyIdOfRawKey } from './ocifetch/index.js';
+const RAW_KEY = /^[0-9a-fA-F]{64}$/;
+let warnedRetired = false;
+function flag(name) {
+    const v = process.env[name];
+    return v !== undefined && ['1', 'true', 'yes', 'on'].includes(v.trim().toLowerCase());
+}
+/** Fills each option the caller left unset from its environment variable. Pure over `process.env`, except the one retired-variable warning. */
+export function withEnvironment(options) {
+    const out = { ...options };
+    for (const name of ENV_RETIRED) {
+        const v = process.env[name];
+        if (v !== undefined && v !== '' && !warnedRetired) {
+            warnedRetired = true;
+            process.emitWarning(`${name} is retired and ignored; ${ENV_BASES_NAME} and ${ENV_CACHE_NAME} replace it`, { code: 'CHTYPES_ENV_RETIRED' });
+        }
+    }
+    const token = process.env[ENV_TOKEN_NAME];
+    if (out.token === undefined && token !== undefined && token !== '')
+        out.token = token;
+    if (out.allowUnsigned === undefined && flag(ENV_ALLOW_UNSIGNED_NAME))
+        out.allowUnsigned = true;
+    const keys = process.env[ENV_TRUSTED_KEYS_NAME];
+    if (out.trustedKeys === undefined && keys !== undefined && keys.trim() !== '') {
+        const list = [];
+        for (const k of keys.split(',').map((x) => x.trim()).filter((x) => x !== '')) {
+            if (!RAW_KEY.test(k)) {
+                throw usageError(`${ENV_TRUSTED_KEYS_NAME}: ${JSON.stringify(k)} is not a raw ed25519 public key (64 hex characters)`);
+            }
+            list.push({ keyid: keyIdOfRawKey(k), ed25519Hex: k.toLowerCase() });
+        }
+        out.trustedKeys = list;
+    }
+    const target = process.env[ENV_TARGET_NAME];
+    if (out.platform === undefined && target !== undefined && target !== '') {
+        if (!isPlatformKey(target)) {
+            throw usageError(`${ENV_TARGET_NAME}: ${JSON.stringify(target)} is not a platform; use one of ${PLATFORMS.map((p) => p.key).join(', ')}`);
+        }
+        out.platform = target;
+    }
+    return out;
+}
+//# sourceMappingURL=env.js.map

package/dist/env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.js","sourceRoot":"","sources":["../src/env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACL,uBAAuB,EACvB,cAAc,EACd,cAAc,EACd,WAAW,EACX,eAAe,EACf,cAAc,EACd,qBAAqB,EACrB,SAAS,GACV,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAuB,aAAa,EAAE,aAAa,EAAmB,MAAM,qBAAqB,CAAC;AAEzG,MAAM,OAAO,GAAG,mBAAmB,CAAC;AACpC,IAAI,aAAa,GAAG,KAAK,CAAC;AAE1B,SAAS,IAAI,CAAC,IAAY;IACxB,MAAM,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC5B,OAAO,CAAC,KAAK,SAAS,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;AACxF,CAAC;AAED,+IAA+I;AAC/I,MAAM,UAAU,eAAe,CAA2B,OAAU;IAClE,MAAM,GAAG,GAAiE,EAAE,GAAG,OAAO,EAAE,CAAC;IACzF,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;QAC/B,MAAM,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC;YAClD,aAAa,GAAG,IAAI,CAAC;YACrB,OAAO,CAAC,WAAW,CAAC,GAAG,IAAI,4BAA4B,cAAc,QAAQ,cAAc,aAAa,EAAE,EAAE,IAAI,EAAE,qBAAqB,EAAE,CAAC,CAAC;QAC7I,CAAC;IACH,CAAC;IACD,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IAC1C,IAAI,GAAG,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE;QAAE,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC;IACtF,IAAI,GAAG,CAAC,aAAa,KAAK,SAAS,IAAI,IAAI,CAAC,uBAAuB,CAAC;QAAE,GAAG,CAAC,aAAa,GAAG,IAAI,CAAC;IAC/F,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAC;IAChD,IAAI,GAAG,CAAC,WAAW,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QAC9E,MAAM,IAAI,GAAiB,EAAE,CAAC;QAC9B,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC;YAC7E,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;gBACrB,MAAM,UAAU,CAAC,GAAG,qBAAqB,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,sDAAsD,CAAC,CAAC;YACzH,CAAC;YACD,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;QACtE,CAAC;QACD,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC;IACzB,CAAC;IACD,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;IAC5C,IAAI,GAAG,CAAC,QAAQ,KAAK,SAAS,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,EAAE,EAAE,CAAC;QACxE,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;YAC3B,MAAM,UAAU,CAAC,GAAG,eAAe,KAAK,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,kCAAkC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC5I,CAAC;QACD,GAAG,CAAC,QAAQ,GAAG,MAAM,CAAC;IACxB,CAAC;IACD,OAAO,GAAQ,CAAC;AAClB,CAAC"}

package/dist/index.d.ts

@@ -1,29 +1,24 @@
 /**
- * `@wavehouse/chtypes` — ClickHouse's own type system, per version.
+ * `@wavehouse/chtypes`: ClickHouse's own type system, per version, over the
+ * ABI v1 C layer (`docs/reference/bindings-v1.md` is the contract).
  *
- *   Registry --for(version)--> Library --compileDdl(ddl)--> Schema --rows(...)--> BatchResult
- *                                 |                            |
- *                          validateType(expr)          setEngine / setTtl    row(...) --> RowResult
+ *   setup(...)                                    optional, once, before the first open
+ *   Registry.open() --for(request)--> Library --compileTable(createTable)--> Schema --rows(...)--> BatchResult
+ *                                       |                                      |
+ *                              validateType(expr)               row(...) --> RowResult
  *
- * Nothing here reimplements a coercion rule: every answer comes from ClickHouse's
- * own C++ (`DataTypeFactory`, `ISerialization`, `ReadHelpers`,
- * `evaluateMissingDefaults`, the TTL algorithms, `MergeTreeDataWriter::mergeBlock`)
- * vendored per release behind the frozen `chs_*` C ABI. The one derived answer is
- * `transformed`, and it is the reason the product exists.
+ * Nothing here reimplements a ClickHouse rule: every answer comes from
+ * ClickHouse's own C++, vendored per release behind the C ABI, and every result
+ * is a one-to-one decode of the document the library returned. `Registry.open`,
+ * `for` and `installed` are asynchronous only because the fetch layer is.
  */
-export { type DiscoveredColumn, parseChangedSettingsResult, parseColumnsResult, parseVersionResult, QUERY_CHANGED_SETTINGS, QUERY_SERVER_VERSION, QUERY_TABLE_COLUMNS, type ServerProfile, } from './discover.js';
-export { type ErrorCodeEntry, ErrorCodeTable } from './error-codes.js';
-export { ABI_REVISION, ArtifactCorruptError, ArtifactError, type ArtifactErrorCode, ArtifactMissingError, ArtifactPinnedError, ArtifactUnpublishedError, ArtifactUntrustedError, artifactMissingMessage, ChtypesError, CODE_ARTIFACT_CORRUPT, CODE_ARTIFACT_MISSING, CODE_ARTIFACT_PINNED, CODE_ARTIFACT_UNPUBLISHED, CODE_ARTIFACT_UNTRUSTED, CODE_SOURCE_UNREACHABLE, CODE_UNSUPPORTED, FETCH_COMMAND, FetchError, InitConflictError, RegistryError, SchemaError, SourceUnreachableError, UnsupportedError, } from './errors.js';
-export { compareVersions, DEFAULT_ARTIFACTS_URL, DEFAULT_LOCK_FILE, DEFAULT_RELEASE_TAG, type EnsureOptions, type EnsureResult, ensure, ensureAll, type FetchEvent, type IndexArtifact, type InstalledArtifact, keyId, type ListResult, LOCK_SCHEMA, type LockEntry, type LockFile, listArtifacts, parseSignatureFile, parseVersionSpelling, RELEASE_KEY_ID, RELEASE_PUBLIC_KEYS, type ReleaseIndex, readLock, resolvePlatform, selectAll, selectArtifact, sha256File, trustedKeys, type VersionRequest, verifyEd25519, verifyInstalled, } from './fetch.js';
-export { nativeStats } from './ffi.js';
-export { DOC_ALL, DOC_DEFAULTS, DOC_TRANSFORMS, DOC_VALUES, EXPORT_NONE, Format, formatName, } from './format.js';
-export { isValidUtf8, Json, type JsonKind, parseDocument, parseJsonValue, rawBytes, rawText, repairBareDenormals, } from './json.js';
-export { CompileMode, type CompileOptions, Library, minorOf } from './library.js';
-export { cacheRegistryDir, ENV_AUTOFETCH, ENV_REGISTRY, fetchDestination, hostPlatform, isPlatformKey, registrySearchPath, systemRegistryDirs, } from './paths.js';
-export { compareMinor, defaultRegistryDir, looksLikeRegistry, type Manifest, Registry, type RegistryOptions, type Resolution, resolveRegistryDir, } from './registry.js';
-export { type BatchResult, type ColumnDoc, type Computed, DefaultKind, FilterOutcome, type FilterResult, type FilterRowError, isAnswer, Outcome, type RowResult, Source, type Span, type Substitution, type Transform, type Value, Verdict, } from './results.js';
-export { Block, type ColumnInfo, type CompileFilterOptions, type EngineOptions, Filter, type RowOptions, type RowsOptions, Schema, } from './schema.js';
-export { encodeSettings, type Settings, type SettingValue } from './settings.js';
-export { type ExtractedEntry, extractTarGz } from './tar.js';
-export { isLossyReason, Reason } from './transform.js';
+export { type BuildInfo, type Capabilities, type BatchOutcome, DefaultKind, DiscoverQueryParam, DocFlags, EXPORT_NONE, FilterOutcome, Format, formatChName, Outcome, Reason, reasonLossy, Source, sourceIsStored, Status, Verdict, verdictAnswered, } from './abi1/index.js';
+export { ArtifactCorruptError, ArtifactError, ArtifactIncompatibleError, CallError, type CallErrorFields, ChtypesError, InternalError, isChtypesError, LoaderCorruptError, type LoaderErrorFields, SchemaError, UnsupportedError, UsageError, } from './abi1/index.js';
+export { type BatchResult, type Column, type Computed, type DiscoveredColumn, type EngineCell, type Discovery, type ErrorCodeEntry, ErrorCodeTable, type FilterResult, type FilterRowError, type Framing, type Header, type RowResult, type SchemaDescription, type Span, type Transform, type Value, } from './documents.js';
+export { Library, openUnverified } from './library.js';
+export { ArtifactMissingError, ArtifactPinnedError, ArtifactUnpublishedError, ArtifactUntrustedError, type Resolved, SourceForbiddenError, SourceIncompatibleError, SourceUnauthorizedError, SourceUnreachableError, } from './ocifetch/index.js';
+export { type FetchOptions, Registry, type RegistryOptions } from './registry.js';
+export { Block, type CompileOptions, type EvalOptions, Filter, type FilterOptions, type RowOptions, type RowsOptions, Schema, } from './schema.js';
+export type { BytesIn, Settings } from './settings.js';
+export { setup, type SetupOptions } from './setup.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACL,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,WAAW,EACX,kBAAkB,EAClB,QAAQ,EACR,WAAW,EACX,aAAa,EACb,MAAM,EACN,YAAY,EACZ,OAAO,EACP,MAAM,EACN,WAAW,EACX,MAAM,EACN,cAAc,EACd,MAAM,EACN,OAAO,EACP,eAAe,GAChB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,oBAAoB,EACpB,aAAa,EACb,yBAAyB,EACzB,SAAS,EACT,KAAK,eAAe,EACpB,YAAY,EACZ,aAAa,EACb,cAAc,EACd,kBAAkB,EAClB,KAAK,iBAAiB,EACtB,WAAW,EACX,gBAAgB,EAChB,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,cAAc,EACd,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,OAAO,EACZ,KAAK,MAAM,EACX,KAAK,SAAS,EACd,KAAK,iBAAiB,EACtB,KAAK,IAAI,EACT,KAAK,SAAS,EACd,KAAK,KAAK,GACX,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,wBAAwB,EACxB,sBAAsB,EACtB,KAAK,QAAQ,EACb,oBAAoB,EACpB,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,YAAY,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAClF,OAAO,EACL,KAAK,EACL,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,MAAM,EACN,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,MAAM,GACP,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,KAAK,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,29 +1,23 @@
 /**
- * `@wavehouse/chtypes` — ClickHouse's own type system, per version.
+ * `@wavehouse/chtypes`: ClickHouse's own type system, per version, over the
+ * ABI v1 C layer (`docs/reference/bindings-v1.md` is the contract).
  *
- *   Registry --for(version)--> Library --compileDdl(ddl)--> Schema --rows(...)--> BatchResult
- *                                 |                            |
- *                          validateType(expr)          setEngine / setTtl    row(...) --> RowResult
+ *   setup(...)                                    optional, once, before the first open
+ *   Registry.open() --for(request)--> Library --compileTable(createTable)--> Schema --rows(...)--> BatchResult
+ *                                       |                                      |
+ *                              validateType(expr)               row(...) --> RowResult
  *
- * Nothing here reimplements a coercion rule: every answer comes from ClickHouse's
- * own C++ (`DataTypeFactory`, `ISerialization`, `ReadHelpers`,
- * `evaluateMissingDefaults`, the TTL algorithms, `MergeTreeDataWriter::mergeBlock`)
- * vendored per release behind the frozen `chs_*` C ABI. The one derived answer is
- * `transformed`, and it is the reason the product exists.
+ * Nothing here reimplements a ClickHouse rule: every answer comes from
+ * ClickHouse's own C++, vendored per release behind the C ABI, and every result
+ * is a one-to-one decode of the document the library returned. `Registry.open`,
+ * `for` and `installed` are asynchronous only because the fetch layer is.
  */
-export { parseChangedSettingsResult, parseColumnsResult, parseVersionResult, QUERY_CHANGED_SETTINGS, QUERY_SERVER_VERSION, QUERY_TABLE_COLUMNS, } from './discover.js';
-export { ErrorCodeTable } from './error-codes.js';
-export { ABI_REVISION, ArtifactCorruptError, ArtifactError, ArtifactMissingError, ArtifactPinnedError, ArtifactUnpublishedError, ArtifactUntrustedError, artifactMissingMessage, ChtypesError, CODE_ARTIFACT_CORRUPT, CODE_ARTIFACT_MISSING, CODE_ARTIFACT_PINNED, CODE_ARTIFACT_UNPUBLISHED, CODE_ARTIFACT_UNTRUSTED, CODE_SOURCE_UNREACHABLE, CODE_UNSUPPORTED, FETCH_COMMAND, FetchError, InitConflictError, RegistryError, SchemaError, SourceUnreachableError, UnsupportedError, } from './errors.js';
-export { compareVersions, DEFAULT_ARTIFACTS_URL, DEFAULT_LOCK_FILE, DEFAULT_RELEASE_TAG, ensure, ensureAll, keyId, LOCK_SCHEMA, listArtifacts, parseSignatureFile, parseVersionSpelling, RELEASE_KEY_ID, RELEASE_PUBLIC_KEYS, readLock, resolvePlatform, selectAll, selectArtifact, sha256File, trustedKeys, verifyEd25519, verifyInstalled, } from './fetch.js';
-export { nativeStats } from './ffi.js';
-export { DOC_ALL, DOC_DEFAULTS, DOC_TRANSFORMS, DOC_VALUES, EXPORT_NONE, Format, formatName, } from './format.js';
-export { isValidUtf8, Json, parseDocument, parseJsonValue, rawBytes, rawText, repairBareDenormals, } from './json.js';
-export { CompileMode, Library, minorOf } from './library.js';
-export { cacheRegistryDir, ENV_AUTOFETCH, ENV_REGISTRY, fetchDestination, hostPlatform, isPlatformKey, registrySearchPath, systemRegistryDirs, } from './paths.js';
-export { compareMinor, defaultRegistryDir, looksLikeRegistry, Registry, resolveRegistryDir, } from './registry.js';
-export { DefaultKind, FilterOutcome, isAnswer, Outcome, Source, Verdict, } from './results.js';
+export { DefaultKind, DiscoverQueryParam, DocFlags, EXPORT_NONE, FilterOutcome, Format, formatChName, Outcome, Reason, reasonLossy, Source, sourceIsStored, Status, Verdict, verdictAnswered, } from './abi1/index.js';
+export { ArtifactCorruptError, ArtifactError, ArtifactIncompatibleError, CallError, ChtypesError, InternalError, isChtypesError, LoaderCorruptError, SchemaError, UnsupportedError, UsageError, } from './abi1/index.js';
+export { ErrorCodeTable, } from './documents.js';
+export { Library, openUnverified } from './library.js';
+export { ArtifactMissingError, ArtifactPinnedError, ArtifactUnpublishedError, ArtifactUntrustedError, SourceForbiddenError, SourceIncompatibleError, SourceUnauthorizedError, SourceUnreachableError, } from './ocifetch/index.js';
+export { Registry } from './registry.js';
 export { Block, Filter, Schema, } from './schema.js';
-export { encodeSettings } from './settings.js';
-export { extractTarGz } from './tar.js';
-export { isLossyReason, Reason } from './transform.js';
+export { setup } from './setup.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAEL,0BAA0B,EAC1B,kBAAkB,EAClB,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,GAEpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAuB,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,aAAa,EAEb,oBAAoB,EACpB,mBAAmB,EACnB,wBAAwB,EACxB,sBAAsB,EACtB,sBAAsB,EACtB,YAAY,EACZ,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,gBAAgB,EAChB,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EAGnB,MAAM,EACN,SAAS,EAIT,KAAK,EAEL,WAAW,EAGX,aAAa,EACb,kBAAkB,EAClB,oBAAoB,EACpB,cAAc,EACd,mBAAmB,EAEnB,QAAQ,EACR,eAAe,EACf,SAAS,EACT,cAAc,EACd,UAAU,EACV,WAAW,EAEX,aAAa,EACb,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,EACL,OAAO,EACP,YAAY,EACZ,cAAc,EACd,UAAU,EACV,WAAW,EACX,MAAM,EACN,UAAU,GACX,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,WAAW,EACX,IAAI,EAEJ,aAAa,EACb,cAAc,EACd,QAAQ,EACR,OAAO,EACP,mBAAmB,GACpB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,WAAW,EAAuB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAClF,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EAEjB,QAAQ,EAGR,kBAAkB,GACnB,MAAM,eAAe,CAAC;AACvB,OAAO,EAIL,WAAW,EACX,aAAa,EAGb,QAAQ,EACR,OAAO,EAEP,MAAM,EAKN,OAAO,GACR,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,KAAK,EAIL,MAAM,EAGN,MAAM,GACP,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,cAAc,EAAoC,MAAM,eAAe,CAAC;AACjF,OAAO,EAAuB,YAAY,EAAE,MAAM,UAAU,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAIL,WAAW,EACX,kBAAkB,EAClB,QAAQ,EACR,WAAW,EACX,aAAa,EACb,MAAM,EACN,YAAY,EACZ,OAAO,EACP,MAAM,EACN,WAAW,EACX,MAAM,EACN,cAAc,EACd,MAAM,EACN,OAAO,EACP,eAAe,GAChB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,oBAAoB,EACpB,aAAa,EACb,yBAAyB,EACzB,SAAS,EAET,YAAY,EACZ,aAAa,EACb,cAAc,EACd,kBAAkB,EAElB,WAAW,EACX,gBAAgB,EAChB,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAQL,cAAc,GAUf,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,wBAAwB,EACxB,sBAAsB,EAEtB,oBAAoB,EACpB,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAqB,QAAQ,EAAwB,MAAM,eAAe,CAAC;AAClF,OAAO,EACL,KAAK,EAGL,MAAM,EAIN,MAAM,GACP,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,KAAK,EAAqB,MAAM,YAAY,CAAC"}

package/dist/json.d.ts

@@ -1,42 +1,10 @@
 /**
- * Result-document JSON, **over bytes**, with three obligations no `JSON.parse`
- * can meet.
- *
- * 1. **The bytes are the answer.** A ClickHouse `String`, `FixedString` or
- *    `AggregateFunction` value holds arbitrary bytes, and the library emits them
- *    into the result document verbatim (`writeJSONString` escapes the control
- *    bytes and passes everything else through). Decoding that document into a JS
- *    string replaces every invalid byte with U+FFFD, which then reads downstream
- *    as a silent transformation that never happened — an *invented* answer, the
- *    failure mode this product exists to prevent (the C ABI contract §Per-column
- *    fields: "`stored` and `ref` MUST be handled as raw bytes / raw JSON"; the
- *    reference implementation keeps `json.RawMessage`). So the document is parsed
- *    from a `Buffer`, and every value remembers the exact slice it was cut from.
- *
- * 2. **Numbers must keep their exact text.** ClickHouse integers go to 2^256.
- *    `JSON.parse` turns 18446744073709551615 into 18446744073709552000 and an
- *    Int256 into -5.78960446186581e+76 — a value difference no scorer can tell
- *    from a real coercion defect. A number is never converted here: it *is* its
- *    own source bytes.
- *
- * 3. **Duplicate keys and escape spellings survive.** ClickHouse can store a
- *    `Map` with a repeated key (`{"a":1,"a":2}`), and it writes the escape
- *    `\\u000B` where a JS re-serialization writes `\\u000b`. `JSON.parse` collapses
- *    the first and loses the second, and either reports bytes the table does not
- *    hold.
- *    Object members are therefore kept as an ordered key/value list, and nothing
- *    is ever re-rendered: `rawBytes` hands back the library's own slice.
- *
- * The bare-denormal repair is the one edit made to the bytes, and it is
- * required, not optional: ClickHouse's `serializeTextJSON` writes IEEE denormals
- * as the bare tokens `inf`, `-inf` and `nan` unless
- * `output_format_json_quote_denormals` is set. That is faithful ClickHouse
- * output and it is not valid JSON — one QBit column full of infinities took an
- * entire result document down and cost 18 arbiter cases at once.
- * `repairBareDenormals` is the port of `quoteBareDenormals`
- * (go/chtypes/chtypes.go): it quotes the token and changes nothing
- * else, and it runs before any slice is cut, so the reference implementation and
- * this one end up holding the same bytes.
+ * The fetch layer's JSON plumbing: a parser over bytes whose values remember the
+ * exact slice they were cut from, with duplicate keys kept in source order (the
+ * fetch layer's own duplicate-key refusals read them). The result documents of
+ * the C layer no longer use it: they are decoded with the stock `JSON.parse`
+ * (`./documents.ts`), because the library's documents are valid RFC 8259 JSON.
+ * It is kept for the fetch layer's use only.
  */
 /** The six JSON kinds. `number` keeps its text; nothing is ever converted. */
 export type JsonKind = 'null' | 'bool' | 'number' | 'string' | 'array' | 'object';
@@ -60,68 +28,22 @@ export declare class Json {
 /** True when these bytes are valid UTF-8 — i.e. when their text is exact. */
 export declare function isValidUtf8(bytes: Uint8Array): boolean;
 /**
- * Parse a `chs_row` / `chs_rows` document: denormals repaired, every value
- * carrying the exact bytes the library wrote.
- */
-export declare function parseDocument(bytes: Buffer): Json;
-/**
- * Is this supplied text **one JSON value**? A spec rule rather than a language
- * default (docs/reference/bindings.md §detectors, measured 2026-08-17): the text is a JSON
- * value only if a strict parse consumes **all** of it, with whitespace being
- * exactly JSON's four (space, tab, LF, CR).
- *
- * Both edges cost real false transforms. A numeric *prefix* must not count —
- * `1.2.3.4` is not `1.2` — and U+FEFF is **not** whitespace: JS's own
- * `String.prototype.trim()` counts `<ZWNBSP>` as `WhiteSpace`, so a
- * `trim()`-then-`JSON.parse` reading took a BOM-prefixed CSV field for the
- * number after it and reported 12 `reformat` transforms that never happened.
- * Deciding over bytes with this grammar makes both impossible.
+ * Is this byte string **one JSON value**? It is only if a strict parse consumes
+ * **all** of it, with whitespace being exactly JSON's four (space, tab, LF, CR).
+ * A numeric *prefix* does not count (`1.2.3.4` is not `1.2`), and U+FEFF is
+ * **not** whitespace, though JS's own `String.prototype.trim()` counts it as one.
  *
- * Returns `null` when the bytes are not a single JSON value (a TSV field, a bare
- * CSV token, raw bytes).
+ * Returns `null` when the bytes are not a single JSON value.
  */
 export declare function parseJsonValue(bytes: Buffer): Json | null;
-/**
- * Quote the bare `inf` / `-inf` / `nan` tokens ClickHouse writes outside JSON
- * strings. Port of `quoteBareDenormals`; the stored text is preserved exactly and
- * only the quoting is added, so the slices this module hands out are the bytes
- * ClickHouse would have written.
- */
-export declare function repairBareDenormals(text: Buffer): Buffer;
 /**
  * One member of an object, by key. The **last** wins, which is what a JS object,
  * a Go map and the arbiter's own `json.loads` all do — a document field is never
  * repeated, and a stored value is read through `rawBytes`, never by key.
  */
 export declare function field(value: Json | undefined, key: string): Json | undefined;
-/** Is this key present at all? `"stored": null` is a value; absence is not. */
-export declare function hasField(value: Json | undefined, key: string): boolean;
 /** The elements of an array (or an object's values); `[]` for anything else. */
 export declare function items(value: Json | undefined): readonly Json[];
 /** A JSON string's text, decoded as UTF-8. `''` for any other kind. */
 export declare function asString(value: Json | undefined): string;
-/** A JSON string's **unescaped bytes** — authoritative where `asString` is not. */
-export declare function asBytes(value: Json | undefined): Buffer;
-export declare function asStringArray(value: Json | undefined): string[];
-export declare function asInt(value: Json | undefined): number;
-export declare function asBool(value: Json | undefined): boolean;
-/**
- * The exact source bytes of a value — the equivalent of holding a
- * `json.RawMessage`. Duplicate keys, escape spellings and 256-bit digits all
- * survive, because nothing is re-rendered.
- *
- * Not the same thing as `asBytes`, and the difference decides correctness: for
- * the string `"a\\u000Bb"` this returns all nine bytes **including the quotes and
- * the escape**, which is what a stored value's rendering is, while `asBytes`
- * returns the three bytes the escape stands for, which is what a *field of the
- * document* (`input`, `name`, `err`) means.
- */
-export declare function rawBytes(value: Json | undefined): Buffer;
-/**
- * `rawBytes` decoded as UTF-8, for logs, comparisons and messages. **Lossy when
- * the value is not valid UTF-8** — a ClickHouse `String` column holds arbitrary
- * bytes, `isValidUtf8(rawBytes(v))` says whether this text is exact, and
- * `rawBytes` is the authority.
- */
-export declare function rawText(value: Json | undefined): string;
 //# sourceMappingURL=json.d.ts.map

package/dist/json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAKH,8EAA8E;AAC9E,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;AAMlF;;;;;;;;GAQG;AACH,qBAAa,IAAI;IAEb,QAAQ,CAAC,IAAI,EAAE,QAAQ;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE;IAC/B,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE;IALlC,YACW,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,MAAM,EACX,KAAK,GAAE,MAAc,EACrB,KAAK,GAAE,SAAS,IAAI,EAAa,EACjC,IAAI,GAAE,SAAS,MAAM,EAAY,EACxC;CACL;AAED,6EAA6E;AAC7E,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAEtD;AA0SD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAMjD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAUzD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAwDxD;AASD;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,IAAI,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAO5E;AAoBD,+EAA+E;AAC/E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAEtE;AAED,gFAAgF;AAChF,wBAAgB,KAAK,CAAC,KAAK,EAAE,IAAI,GAAG,SAAS,GAAG,SAAS,IAAI,EAAE,CAE9D;AAED,uEAAuE;AACvE,wBAAgB,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,SAAS,GAAG,MAAM,CAExD;AAED,mFAAmF;AACnF,wBAAgB,OAAO,CAAC,KAAK,EAAE,IAAI,GAAG,SAAS,GAAG,MAAM,CAEvD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,IAAI,GAAG,SAAS,GAAG,MAAM,EAAE,CAE/D;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,IAAI,GAAG,SAAS,GAAG,MAAM,CAMrD;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,IAAI,GAAG,SAAS,GAAG,OAAO,CAEvD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,SAAS,GAAG,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,IAAI,GAAG,SAAS,GAAG,MAAM,CAEvD"}
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,8EAA8E;AAC9E,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAC;AAMlF;;;;;;;;GAQG;AACH,qBAAa,IAAI;IAEb,QAAQ,CAAC,IAAI,EAAE,QAAQ;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM;IACtB,QAAQ,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE;IAC/B,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE;IALlC,YACW,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,MAAM,EACX,KAAK,GAAE,MAAc,EACrB,KAAK,GAAE,SAAS,IAAI,EAAa,EACjC,IAAI,GAAE,SAAS,MAAM,EAAY,EACxC;CACL;AAED,6EAA6E;AAC7E,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAEtD;AAySD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAUzD;AASD;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,IAAI,GAAG,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAO5E;AAoBD,gFAAgF;AAChF,wBAAgB,KAAK,CAAC,KAAK,EAAE,IAAI,GAAG,SAAS,GAAG,SAAS,IAAI,EAAE,CAE9D;AAED,uEAAuE;AACvE,wBAAgB,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,SAAS,GAAG,MAAM,CAExD"}

package/dist/json.js

@@ -1,45 +1,13 @@
 /**
- * Result-document JSON, **over bytes**, with three obligations no `JSON.parse`
- * can meet.
- *
- * 1. **The bytes are the answer.** A ClickHouse `String`, `FixedString` or
- *    `AggregateFunction` value holds arbitrary bytes, and the library emits them
- *    into the result document verbatim (`writeJSONString` escapes the control
- *    bytes and passes everything else through). Decoding that document into a JS
- *    string replaces every invalid byte with U+FFFD, which then reads downstream
- *    as a silent transformation that never happened — an *invented* answer, the
- *    failure mode this product exists to prevent (the C ABI contract §Per-column
- *    fields: "`stored` and `ref` MUST be handled as raw bytes / raw JSON"; the
- *    reference implementation keeps `json.RawMessage`). So the document is parsed
- *    from a `Buffer`, and every value remembers the exact slice it was cut from.
- *
- * 2. **Numbers must keep their exact text.** ClickHouse integers go to 2^256.
- *    `JSON.parse` turns 18446744073709551615 into 18446744073709552000 and an
- *    Int256 into -5.78960446186581e+76 — a value difference no scorer can tell
- *    from a real coercion defect. A number is never converted here: it *is* its
- *    own source bytes.
- *
- * 3. **Duplicate keys and escape spellings survive.** ClickHouse can store a
- *    `Map` with a repeated key (`{"a":1,"a":2}`), and it writes the escape
- *    `\\u000B` where a JS re-serialization writes `\\u000b`. `JSON.parse` collapses
- *    the first and loses the second, and either reports bytes the table does not
- *    hold.
- *    Object members are therefore kept as an ordered key/value list, and nothing
- *    is ever re-rendered: `rawBytes` hands back the library's own slice.
- *
- * The bare-denormal repair is the one edit made to the bytes, and it is
- * required, not optional: ClickHouse's `serializeTextJSON` writes IEEE denormals
- * as the bare tokens `inf`, `-inf` and `nan` unless
- * `output_format_json_quote_denormals` is set. That is faithful ClickHouse
- * output and it is not valid JSON — one QBit column full of infinities took an
- * entire result document down and cost 18 arbiter cases at once.
- * `repairBareDenormals` is the port of `quoteBareDenormals`
- * (go/chtypes/chtypes.go): it quotes the token and changes nothing
- * else, and it runs before any slice is cut, so the reference implementation and
- * this one end up holding the same bytes.
+ * The fetch layer's JSON plumbing: a parser over bytes whose values remember the
+ * exact slice they were cut from, with duplicate keys kept in source order (the
+ * fetch layer's own duplicate-key refusals read them). The result documents of
+ * the C layer no longer use it: they are decoded with the stock `JSON.parse`
+ * (`./documents.ts`), because the library's documents are valid RFC 8259 JSON.
+ * It is kept for the fetch layer's use only.
  */
 import { isUtf8 } from 'node:buffer';
-import { ChtypesError } from './errors.js';
+import { ArtifactCorruptError } from './ocifetch/errors.js';
 const EMPTY = Buffer.alloc(0);
 const NO_ITEMS = [];
 const NO_KEYS = [];
@@ -115,7 +83,7 @@ class Parser {
         this.b = b;
     }
     fail(what) {
-        throw new ChtypesError(`chtypes: bad result document: ${what} at offset ${this.i}`);
+        throw new ArtifactCorruptError(`chtypes: bad result document: ${what} at offset ${this.i}`);
     }
     skipSpace() {
         while (this.i < this.b.length && isSpace(this.b[this.i]))
@@ -161,10 +129,9 @@ class Parser {
     }
     /**
      * A JSON number, strictly: no leading `+`, no bare `.5`, no `1.`, no leading
-     * zeros. The strictness is load-bearing rather than pedantic — `parseJsonValue`
-     * decides with this grammar whether a supplied CSV/TSV field *is* a JSON
-     * value, and a lenient reading invents transformations (docs/reference/bindings.md
-     * §detectors).
+     * zeros. The strictness is load-bearing rather than pedantic: the fetch layer
+     * reads signed statements and manifests with this grammar, and a lenient reading
+     * would accept bytes the signature never covered.
      */
     number() {
         const start = this.i;
@@ -374,32 +341,12 @@ class Parser {
     }
 }
 /**
- * Parse a `chs_row` / `chs_rows` document: denormals repaired, every value
- * carrying the exact bytes the library wrote.
- */
-export function parseDocument(bytes) {
-    const p = new Parser(repairBareDenormals(bytes));
-    const v = p.value();
-    p.skipSpace();
-    if (!p.atEnd())
-        p.fail('unexpected data after the document');
-    return v;
-}
-/**
- * Is this supplied text **one JSON value**? A spec rule rather than a language
- * default (docs/reference/bindings.md §detectors, measured 2026-08-17): the text is a JSON
- * value only if a strict parse consumes **all** of it, with whitespace being
- * exactly JSON's four (space, tab, LF, CR).
- *
- * Both edges cost real false transforms. A numeric *prefix* must not count —
- * `1.2.3.4` is not `1.2` — and U+FEFF is **not** whitespace: JS's own
- * `String.prototype.trim()` counts `<ZWNBSP>` as `WhiteSpace`, so a
- * `trim()`-then-`JSON.parse` reading took a BOM-prefixed CSV field for the
- * number after it and reported 12 `reformat` transforms that never happened.
- * Deciding over bytes with this grammar makes both impossible.
+ * Is this byte string **one JSON value**? It is only if a strict parse consumes
+ * **all** of it, with whitespace being exactly JSON's four (space, tab, LF, CR).
+ * A numeric *prefix* does not count (`1.2.3.4` is not `1.2`), and U+FEFF is
+ * **not** whitespace, though JS's own `String.prototype.trim()` counts it as one.
  *
- * Returns `null` when the bytes are not a single JSON value (a TSV field, a bare
- * CSV token, raw bytes).
+ * Returns `null` when the bytes are not a single JSON value.
  */
 export function parseJsonValue(bytes) {
     if (bytes.length === 0)
@@ -414,73 +361,6 @@ export function parseJsonValue(bytes) {
         return null;
     }
 }
-/**
- * Quote the bare `inf` / `-inf` / `nan` tokens ClickHouse writes outside JSON
- * strings. Port of `quoteBareDenormals`; the stored text is preserved exactly and
- * only the quoting is added, so the slices this module hands out are the bytes
- * ClickHouse would have written.
- */
-export function repairBareDenormals(text) {
-    // Fast path: nothing that could be a bare denormal token.
-    if (!text.includes('inf') && !text.includes('nan'))
-        return text;
-    const startsWith = (word, at) => {
-        for (let k = 0; k < word.length; k++) {
-            if (text[at + k] !== word.charCodeAt(k))
-                return false;
-        }
-        return true;
-    };
-    const out = [];
-    let inString = false;
-    for (let i = 0; i < text.length; i++) {
-        const c = text[i];
-        if (inString) {
-            out.push(c);
-            if (c === BACKSLASH && i + 1 < text.length) {
-                i++;
-                out.push(text[i]);
-            }
-            else if (c === QUOTE) {
-                inString = false;
-            }
-            continue;
-        }
-        if (c === QUOTE) {
-            inString = true;
-            out.push(c);
-            continue;
-        }
-        // A value can only start right after one of these structural bytes.
-        if (out.length > 0) {
-            const prev = out[out.length - 1];
-            if (prev !== COLON && prev !== COMMA && prev !== ARRAY_OPEN && !isSpace(prev)) {
-                out.push(c);
-                continue;
-            }
-        }
-        let token = 0;
-        if (startsWith('-inf', i))
-            token = 4;
-        else if (startsWith('inf', i))
-            token = 3;
-        else if (startsWith('nan', i))
-            token = 3;
-        if (token > 0) {
-            const after = text[i + token];
-            if (after === undefined || after === COMMA || after === OBJECT_CLOSE || after === ARRAY_CLOSE) {
-                out.push(QUOTE);
-                for (let k = 0; k < token; k++)
-                    out.push(text[i + k]);
-                out.push(QUOTE);
-                i += token - 1;
-                continue;
-            }
-        }
-        out.push(c);
-    }
-    return Buffer.from(out);
-}
 // ------------------------------------------------------------------ accessors
 //
 // Every field of a result document is optional: a rejected row's document omits
@@ -522,10 +402,6 @@ function keyIs(key, want) {
     }
     return true;
 }
-/** Is this key present at all? `"stored": null` is a value; absence is not. */
-export function hasField(value, key) {
-    return field(value, key) !== undefined;
-}
 /** The elements of an array (or an object's values); `[]` for anything else. */
 export function items(value) {
     return value === undefined ? NO_ITEMS : value.items;
@@ -534,44 +410,4 @@ export function items(value) {
 export function asString(value) {
     return value !== undefined && value.kind === 'string' ? value.bytes.toString('utf8') : '';
 }
-/** A JSON string's **unescaped bytes** — authoritative where `asString` is not. */
-export function asBytes(value) {
-    return value !== undefined && value.kind === 'string' ? value.bytes : EMPTY;
-}
-export function asStringArray(value) {
-    return items(value).map((v) => asString(v));
-}
-export function asInt(value) {
-    if (value !== undefined && value.kind === 'number') {
-        const n = Number(value.raw.toString('utf8'));
-        return Number.isFinite(n) ? n : 0;
-    }
-    return 0;
-}
-export function asBool(value) {
-    return value !== undefined && value.kind === 'bool' && value.raw[0] === LOWER_T;
-}
-/**
- * The exact source bytes of a value — the equivalent of holding a
- * `json.RawMessage`. Duplicate keys, escape spellings and 256-bit digits all
- * survive, because nothing is re-rendered.
- *
- * Not the same thing as `asBytes`, and the difference decides correctness: for
- * the string `"a\\u000Bb"` this returns all nine bytes **including the quotes and
- * the escape**, which is what a stored value's rendering is, while `asBytes`
- * returns the three bytes the escape stands for, which is what a *field of the
- * document* (`input`, `name`, `err`) means.
- */
-export function rawBytes(value) {
-    return value === undefined ? EMPTY : value.raw;
-}
-/**
- * `rawBytes` decoded as UTF-8, for logs, comparisons and messages. **Lossy when
- * the value is not valid UTF-8** — a ClickHouse `String` column holds arbitrary
- * bytes, `isValidUtf8(rawBytes(v))` says whether this text is exact, and
- * `rawBytes` is the authority.
- */
-export function rawText(value) {
-    return rawBytes(value).toString('utf8');
-}
 //# sourceMappingURL=json.js.map