@memberjunction/cli 6.2.0-edge.0 → 6.2.0-edge.2

package/dist/baseline/cli-helpers.d.ts

@@ -7,6 +7,10 @@
  */
 import type { DbConnectionParams, DbConnectionOverrides } from './connection.js';
 import type { Dialect } from './types.js';
+export declare function ResolveConnection(overrides?: DbConnectionOverrides, dialectFlag?: Dialect): DbConnectionParams;
+/** @deprecated Use {@link ResolveConnection}. */
 export declare function resolveConnection(overrides?: DbConnectionOverrides, dialectFlag?: Dialect): DbConnectionParams;
+export declare function IsTty(): boolean;
+/** @deprecated Use {@link IsTty}. */
 export declare function isTty(): boolean;
 //# sourceMappingURL=cli-helpers.d.ts.map

package/dist/baseline/cli-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-helpers.d.ts","sourceRoot":"","sources":["../../src/baseline/cli-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAEvC,wBAAgB,iBAAiB,CAAC,SAAS,GAAE,qBAA0B,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,kBAAkB,CAwBlH;AAED,wBAAgB,KAAK,IAAI,OAAO,CAE/B"}
+{"version":3,"file":"cli-helpers.d.ts","sourceRoot":"","sources":["../../src/baseline/cli-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAEvC,wBAAgB,iBAAiB,CAAC,SAAS,GAAE,qBAA0B,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,kBAAkB,CAwBlH;AAED,iDAAiD;AACjD,wBAAgB,iBAAiB,CAAC,SAAS,GAAE,qBAA0B,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,kBAAkB,CAElH;AAED,wBAAgB,KAAK,IAAI,OAAO,CAE/B;AAED,qCAAqC;AACrC,wBAAgB,KAAK,IAAI,OAAO,CAE/B"}

package/dist/baseline/cli-helpers.js

@@ -5,12 +5,12 @@
  *   with optional flag overrides (db name, host, etc).
  * - Detect TTY for spinner vs. plain log output.
  */
-import { getValidatedConfig } from '../config.js';
-export function resolveConnection(overrides = {}, dialectFlag) {
-    const config = getValidatedConfig();
+import { GetValidatedConfig } from '../config.js';
+export function ResolveConnection(overrides = {}, dialectFlag) {
+    const config = GetValidatedConfig();
     const dialect = dialectFlag
         ?? (config.dbPlatform === 'postgresql' ? 'postgres' : 'mssql');
-    const host = overrides.host ?? config.dbHost;
+    const host = overrides.Host ?? config.dbHost;
     const port = overrides.port ?? (config.dbPort ? Number(config.dbPort) : undefined);
     const database = overrides.database ?? config.dbDatabase;
     const user = overrides.user ?? config.codeGenLogin;
@@ -24,17 +24,25 @@ export function resolveConnection(overrides = {}, dialectFlag) {
     if (!password)
         throw new Error('No DB password configured (set CODEGEN_DB_PASSWORD).');
     return {
-        dialect,
-        host,
+        Dialect: dialect,
+        Host: host,
         port,
-        database,
-        user,
-        password,
+        Database: database,
+        User: user,
+        Password: password,
         encrypt: overrides.encrypt ?? Boolean(config.dbEncrypt),
         trustServerCertificate: overrides.trustServerCertificate ?? Boolean(config.dbTrustServerCertificate),
     };
 }
-export function isTty() {
+/** @deprecated Use {@link ResolveConnection}. */
+export function resolveConnection(overrides = {}, dialectFlag) {
+    return ResolveConnection(overrides, dialectFlag);
+}
+export function IsTty() {
     return Boolean(process.stdout.isTTY) && process.env.CI !== 'true';
 }
+/** @deprecated Use {@link IsTty}. */
+export function isTty() {
+    return IsTty();
+}
 //# sourceMappingURL=cli-helpers.js.map

package/dist/baseline/cli-helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli-helpers.js","sourceRoot":"","sources":["../../src/baseline/cli-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAI/C,MAAM,UAAU,iBAAiB,CAAC,YAAmC,EAAE,EAAE,WAAqB;IAC5F,MAAM,MAAM,GAAG,kBAAkB,EAAE,CAAC;IACpC,MAAM,OAAO,GAAY,WAAW;WAC/B,CAAC,MAAM,CAAC,UAAU,KAAK,YAAY,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;IAEjE,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC;IAC7C,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IACnF,MAAM,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,MAAM,CAAC,UAAU,CAAC;IACzD,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,IAAK,MAAoC,CAAC,YAAY,CAAC;IAClF,MAAM,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAK,MAAuC,CAAC,eAAe,CAAC;IAChG,IAAI,CAAC,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAC;IAC9F,IAAI,CAAC,QAAQ;QAAE,MAAM,IAAI,KAAK,CAAC,gFAAgF,CAAC,CAAC;IACjH,IAAI,CAAC,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IAC/E,IAAI,CAAC,QAAQ;QAAE,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IACvF,OAAO;QACL,OAAO;QACP,IAAI;QACJ,IAAI;QACJ,QAAQ;QACR,IAAI;QACJ,QAAQ;QACR,OAAO,EAAE,SAAS,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC;QACvD,sBAAsB,EAAE,SAAS,CAAC,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC,wBAAwB,CAAC;KACrG,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,KAAK;IACnB,OAAO,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,EAAE,KAAK,MAAM,CAAC;AACpE,CAAC"}
+{"version":3,"file":"cli-helpers.js","sourceRoot":"","sources":["../../src/baseline/cli-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAI/C,MAAM,UAAU,iBAAiB,CAAC,YAAmC,EAAE,EAAE,WAAqB;IAC5F,MAAM,MAAM,GAAG,kBAAkB,EAAE,CAAC;IACpC,MAAM,OAAO,GAAY,WAAW;WAC/B,CAAC,MAAM,CAAC,UAAU,KAAK,YAAY,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;IAEjE,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC;IAC7C,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IACnF,MAAM,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,MAAM,CAAC,UAAU,CAAC;IACzD,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,IAAK,MAAoC,CAAC,YAAY,CAAC;IAClF,MAAM,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAK,MAAuC,CAAC,eAAe,CAAC;IAChG,IAAI,CAAC,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAC;IAC9F,IAAI,CAAC,QAAQ;QAAE,MAAM,IAAI,KAAK,CAAC,gFAAgF,CAAC,CAAC;IACjH,IAAI,CAAC,IAAI;QAAE,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;IAC/E,IAAI,CAAC,QAAQ;QAAE,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IACvF,OAAO;QACL,OAAO,EAAE,OAAO;QAChB,IAAI,EAAE,IAAI;QACV,IAAI;QACJ,QAAQ,EAAE,QAAQ;QAClB,IAAI,EAAE,IAAI;QACV,QAAQ,EAAE,QAAQ;QAClB,OAAO,EAAE,SAAS,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC;QACvD,sBAAsB,EAAE,SAAS,CAAC,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC,wBAAwB,CAAC;KACrG,CAAC;AACJ,CAAC;AAED,iDAAiD;AACjD,MAAM,UAAU,iBAAiB,CAAC,YAAmC,EAAE,EAAE,WAAqB;IAC5F,OAAO,iBAAiB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;AACnD,CAAC;AAED,MAAM,UAAU,KAAK;IACnB,OAAO,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,EAAE,KAAK,MAAM,CAAC;AACpE,CAAC;AAED,qCAAqC;AACrC,MAAM,UAAU,KAAK;IACnB,OAAO,KAAK,EAAE,CAAC;AACjB,CAAC"}

package/dist/baseline/comparator.d.ts

@@ -10,17 +10,19 @@
  */
 import type { BaselineCompareOptions, DiffReport, SchemaSnapshot, TableDataDump } from './types.js';
 export interface CompareInput {
-    left: {
+    Left: {
         snapshot: SchemaSnapshot;
         data: readonly TableDataDump[];
         label: string;
     };
-    right: {
+    Right: {
         snapshot: SchemaSnapshot;
         data: readonly TableDataDump[];
         label: string;
     };
-    options: BaselineCompareOptions;
+    Options: BaselineCompareOptions;
 }
+export declare function CompareSnapshots(input: CompareInput): DiffReport;
+/** @deprecated Use {@link CompareSnapshots}. */
 export declare function compareSnapshots(input: CompareInput): DiffReport;
 //# sourceMappingURL=comparator.d.ts.map

package/dist/baseline/comparator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"comparator.d.ts","sourceRoot":"","sources":["../../src/baseline/comparator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EACV,sBAAsB,EAGtB,UAAU,EAMV,cAAc,EACd,aAAa,EAKd,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE;QAAE,QAAQ,EAAE,cAAc,CAAC;QAAC,IAAI,EAAE,SAAS,aAAa,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAClF,KAAK,EAAE;QAAE,QAAQ,EAAE,cAAc,CAAC;QAAC,IAAI,EAAE,SAAS,aAAa,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACnF,OAAO,EAAE,sBAAsB,CAAC;CACjC;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,UAAU,CAoMhE"}
+{"version":3,"file":"comparator.d.ts","sourceRoot":"","sources":["../../src/baseline/comparator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EACV,sBAAsB,EAGtB,UAAU,EAMV,cAAc,EACd,aAAa,EAKd,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE;QAAE,QAAQ,EAAE,cAAc,CAAC;QAAC,IAAI,EAAE,SAAS,aAAa,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAClF,KAAK,EAAE;QAAE,QAAQ,EAAE,cAAc,CAAC;QAAC,IAAI,EAAE,SAAS,aAAa,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACnF,OAAO,EAAE,sBAAsB,CAAC;CACjC;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,UAAU,CAoMhE;AAED,gDAAgD;AAChD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,UAAU,CAEhE"}

package/dist/baseline/comparator.js

@@ -8,10 +8,10 @@
  * Row-by-row comparison (when row data is supplied) walks each table's rows
  * in their canonical order and reports value-level diffs.
  */
-import { deepValueEqual, isoUtcSeconds, qname, stableSortBy } from './util.js';
-export function compareSnapshots(input) {
-    const { left, right, options } = input;
-    const ignored = options.ignorePattern;
+import { DeepValueEqual, IsoUtcSeconds, qname, StableSortBy } from './util.js';
+export function CompareSnapshots(input) {
+    const { Left: left, Right: right, Options: options } = input;
+    const ignored = options.IgnorePattern;
     const matchesIgnore = (q) => {
         if (!ignored)
             return false;
@@ -33,10 +33,10 @@ export function compareSnapshots(input) {
         objectDiffs.push(...diffs);
     };
     // Schemas
-    counted(diffNamedSet('schema', left.snapshot.schemas, right.snapshot.schemas, (s) => s.name, matchesIgnore));
+    counted(diffNamedSet('schema', left.snapshot.Schemas, right.snapshot.Schemas, (s) => s.name, matchesIgnore));
     // Tables
-    const leftTables = new Map(left.snapshot.tables.map((t) => [qname(t.schema, t.name), t]));
-    const rightTables = new Map(right.snapshot.tables.map((t) => [qname(t.schema, t.name), t]));
+    const leftTables = new Map(left.snapshot.Tables.map((t) => [qname(t.Schema, t.Name), t]));
+    const rightTables = new Map(right.snapshot.Tables.map((t) => [qname(t.Schema, t.Name), t]));
     const allTableKeys = new Set([...leftTables.keys(), ...rightTables.keys()]);
     for (const key of [...allTableKeys].sort()) {
         if (matchesIgnore(key))
@@ -44,12 +44,12 @@ export function compareSnapshots(input) {
         const leftT = leftTables.get(key);
         const rightT = rightTables.get(key);
         if (!leftT && rightT) {
-            objectDiffs.push({ kind: 'table', diffKind: 'missing-on-left', qualifiedName: key });
+            objectDiffs.push({ Kind: 'table', DiffKind: 'missing-on-left', QualifiedName: key });
             objectsWithDiffs++;
             continue;
         }
         if (leftT && !rightT) {
-            objectDiffs.push({ kind: 'table', diffKind: 'missing-on-right', qualifiedName: key });
+            objectDiffs.push({ Kind: 'table', DiffKind: 'missing-on-right', QualifiedName: key });
             objectsWithDiffs++;
             continue;
         }
@@ -58,19 +58,19 @@ export function compareSnapshots(input) {
         }
     }
     // Views, procedures, functions, triggers, sequences
-    counted(diffNamedSet('view', left.snapshot.views, right.snapshot.views, (v) => `${v.schema}.${v.name}`, matchesIgnore, (l, r) => normalizeBody(l.definition) === normalizeBody(r.definition)
+    counted(diffNamedSet('view', left.snapshot.Views, right.snapshot.Views, (v) => `${v.schema}.${v.name}`, matchesIgnore, (l, r) => normalizeBody(l.definition) === normalizeBody(r.definition)
         ? null
         : `view body differs`));
-    counted(diffNamedSet('procedure', left.snapshot.procedures, right.snapshot.procedures, (p) => `${p.schema}.${p.name}`, matchesIgnore, (l, r) => normalizeBody(l.definition) === normalizeBody(r.definition)
+    counted(diffNamedSet('procedure', left.snapshot.Procedures, right.snapshot.Procedures, (p) => `${p.schema}.${p.name}`, matchesIgnore, (l, r) => normalizeBody(l.definition) === normalizeBody(r.definition)
         ? null
         : `procedure body differs`));
-    counted(diffNamedSet('function', left.snapshot.functions, right.snapshot.functions, (p) => `${p.schema}.${p.name}`, matchesIgnore, (l, r) => normalizeBody(l.definition) === normalizeBody(r.definition)
+    counted(diffNamedSet('function', left.snapshot.Functions, right.snapshot.Functions, (p) => `${p.schema}.${p.name}`, matchesIgnore, (l, r) => normalizeBody(l.definition) === normalizeBody(r.definition)
         ? null
         : `function body differs`));
-    counted(diffNamedSet('trigger', left.snapshot.triggers, right.snapshot.triggers, (t) => `${t.schema}.${t.name}`, matchesIgnore, (l, r) => normalizeBody(l.definition) === normalizeBody(r.definition)
+    counted(diffNamedSet('trigger', left.snapshot.Triggers, right.snapshot.Triggers, (t) => `${t.schema}.${t.name}`, matchesIgnore, (l, r) => normalizeBody(l.definition) === normalizeBody(r.definition)
         ? null
         : `trigger body differs`));
-    counted(diffNamedSet('sequence', left.snapshot.sequences, right.snapshot.sequences, (s) => `${s.schema}.${s.name}`, matchesIgnore, (l, r) => {
+    counted(diffNamedSet('sequence', left.snapshot.Sequences, right.snapshot.Sequences, (s) => `${s.schema}.${s.name}`, matchesIgnore, (l, r) => {
         const fields = [];
         if (l.startValue !== r.startValue)
             fields.push(`startValue: ${l.startValue} vs ${r.startValue}`);
@@ -81,21 +81,21 @@ export function compareSnapshots(input) {
         return fields.length === 0 ? null : fields.join('; ');
     }));
     // User-defined types (table types)
-    counted(diffUserDefinedTypes(left.snapshot.userDefinedTypes, right.snapshot.userDefinedTypes, matchesIgnore));
+    counted(diffUserDefinedTypes(left.snapshot.UserDefinedTypes, right.snapshot.UserDefinedTypes, matchesIgnore));
     // Extended properties (sp_addextendedproperty entries — MS_Description etc.)
-    counted(diffExtendedProperties(left.snapshot.extendedProperties, right.snapshot.extendedProperties));
+    counted(diffExtendedProperties(left.snapshot.ExtendedProperties, right.snapshot.ExtendedProperties));
     // Database principals (users + custom roles)
-    counted(diffPrincipals(left.snapshot.principals, right.snapshot.principals));
+    counted(diffPrincipals(left.snapshot.Principals, right.snapshot.Principals));
     // Role memberships
-    counted(diffRoleMemberships(left.snapshot.roleMemberships, right.snapshot.roleMemberships));
+    counted(diffRoleMemberships(left.snapshot.RoleMemberships, right.snapshot.RoleMemberships));
     // Permissions (GRANT/DENY entries)
-    counted(diffPermissions(left.snapshot.permissions, right.snapshot.permissions));
+    counted(diffPermissions(left.snapshot.Permissions, right.snapshot.Permissions));
     // Row data
     const tableRowDiffs = [];
     let totalRowDiffs = 0;
-    if (options.rowCompareMode !== 'none') {
-        const leftDumps = new Map(left.data.map((d) => [qname(d.schema, d.table), d]));
-        const rightDumps = new Map(right.data.map((d) => [qname(d.schema, d.table), d]));
+    if (options.RowCompareMode !== 'none') {
+        const leftDumps = new Map(left.data.map((d) => [qname(d.Schema, d.Table), d]));
+        const rightDumps = new Map(right.data.map((d) => [qname(d.Schema, d.Table), d]));
         for (const key of [...new Set([...leftDumps.keys(), ...rightDumps.keys()])].sort()) {
             if (matchesIgnore(key))
                 continue;
@@ -104,40 +104,44 @@ export function compareSnapshots(input) {
             if (!leftD || !rightD)
                 continue; // missing tables already reported as objectDiff
             const td = diffTableRows(leftD, rightD, options);
-            if (td.diffCount > 0 || leftD.rowCount !== rightD.rowCount) {
+            if (td.DiffCount > 0 || leftD.RowCount !== rightD.RowCount) {
                 tableRowDiffs.push(td);
-                totalRowDiffs += td.diffCount;
+                totalRowDiffs += td.DiffCount;
             }
         }
     }
     const summary = {
-        schemasChecked: left.snapshot.schemas.length,
+        schemasChecked: left.snapshot.Schemas.length,
         tablesChecked: allTableKeys.size,
-        viewsChecked: Math.max(left.snapshot.views.length, right.snapshot.views.length),
-        proceduresChecked: Math.max(left.snapshot.procedures.length, right.snapshot.procedures.length),
-        functionsChecked: Math.max(left.snapshot.functions.length, right.snapshot.functions.length),
-        triggersChecked: Math.max(left.snapshot.triggers.length, right.snapshot.triggers.length),
-        sequencesChecked: Math.max(left.snapshot.sequences.length, right.snapshot.sequences.length),
-        userDefinedTypesChecked: Math.max(left.snapshot.userDefinedTypes.length, right.snapshot.userDefinedTypes.length),
-        extendedPropertiesChecked: Math.max(left.snapshot.extendedProperties.length, right.snapshot.extendedProperties.length),
-        principalsChecked: Math.max(left.snapshot.principals.length, right.snapshot.principals.length),
-        roleMembershipsChecked: Math.max(left.snapshot.roleMemberships.length, right.snapshot.roleMemberships.length),
-        permissionsChecked: Math.max(left.snapshot.permissions.length, right.snapshot.permissions.length),
+        viewsChecked: Math.max(left.snapshot.Views.length, right.snapshot.Views.length),
+        proceduresChecked: Math.max(left.snapshot.Procedures.length, right.snapshot.Procedures.length),
+        functionsChecked: Math.max(left.snapshot.Functions.length, right.snapshot.Functions.length),
+        triggersChecked: Math.max(left.snapshot.Triggers.length, right.snapshot.Triggers.length),
+        sequencesChecked: Math.max(left.snapshot.Sequences.length, right.snapshot.Sequences.length),
+        userDefinedTypesChecked: Math.max(left.snapshot.UserDefinedTypes.length, right.snapshot.UserDefinedTypes.length),
+        extendedPropertiesChecked: Math.max(left.snapshot.ExtendedProperties.length, right.snapshot.ExtendedProperties.length),
+        principalsChecked: Math.max(left.snapshot.Principals.length, right.snapshot.Principals.length),
+        roleMembershipsChecked: Math.max(left.snapshot.RoleMemberships.length, right.snapshot.RoleMemberships.length),
+        permissionsChecked: Math.max(left.snapshot.Permissions.length, right.snapshot.Permissions.length),
         objectsWithDiffs,
         tablesWithRowDiffs: tableRowDiffs.length,
         totalRowDiffs,
     };
     return {
-        generatedAt: isoUtcSeconds(new Date()),
+        generatedAt: IsoUtcSeconds(new Date()),
         leftLabel: left.label,
         rightLabel: right.label,
-        rowCompareMode: options.rowCompareMode,
+        rowCompareMode: options.RowCompareMode,
         isClean: objectsWithDiffs === 0 && tableRowDiffs.length === 0,
-        objectDiffs: stableSortBy(objectDiffs, (d) => `${d.kind}:${d.qualifiedName}`),
+        objectDiffs: StableSortBy(objectDiffs, (d) => `${d.Kind}:${d.QualifiedName}`),
         tableRowDiffs,
         summary,
     };
 }
+/** @deprecated Use {@link CompareSnapshots}. */
+export function compareSnapshots(input) {
+    return CompareSnapshots(input);
+}
 function diffNamedSet(kind, leftItems, rightItems, qname, ignore, bodyDiff) {
     const leftMap = new Map(leftItems.map((i) => [qname(i).toLowerCase(), i]));
     const rightMap = new Map(rightItems.map((i) => [qname(i).toLowerCase(), i]));
@@ -149,31 +153,31 @@ function diffNamedSet(kind, leftItems, rightItems, qname, ignore, bodyDiff) {
         const l = leftMap.get(key);
         const r = rightMap.get(key);
         if (!l && r)
-            out.push({ kind, diffKind: 'missing-on-left', qualifiedName: key });
+            out.push({ Kind: kind, DiffKind: 'missing-on-left', QualifiedName: key });
         else if (l && !r)
-            out.push({ kind, diffKind: 'missing-on-right', qualifiedName: key });
+            out.push({ Kind: kind, DiffKind: 'missing-on-right', QualifiedName: key });
         else if (l && r && bodyDiff) {
             const detail = bodyDiff(l, r);
             if (detail)
-                out.push({ kind, diffKind: 'changed', qualifiedName: key, details: detail });
+                out.push({ Kind: kind, DiffKind: 'changed', QualifiedName: key, Details: detail });
         }
     }
     return out;
 }
 function diffTable(left, right) {
     const out = [];
-    const tableQ = `${left.schema}.${left.name}`;
+    const tableQ = `${left.Schema}.${left.Name}`;
     // Columns
-    const lCols = new Map(left.columns.map((c) => [c.name.toLowerCase(), c]));
-    const rCols = new Map(right.columns.map((c) => [c.name.toLowerCase(), c]));
+    const lCols = new Map(left.Columns.map((c) => [c.name.toLowerCase(), c]));
+    const rCols = new Map(right.Columns.map((c) => [c.name.toLowerCase(), c]));
     for (const name of new Set([...lCols.keys(), ...rCols.keys()])) {
         const l = lCols.get(name);
         const r = rCols.get(name);
         const q = `${tableQ}.${name}`;
         if (!l && r)
-            out.push({ kind: 'column', diffKind: 'missing-on-left', qualifiedName: q });
+            out.push({ Kind: 'column', DiffKind: 'missing-on-left', QualifiedName: q });
         else if (l && !r)
-            out.push({ kind: 'column', diffKind: 'missing-on-right', qualifiedName: q });
+            out.push({ Kind: 'column', DiffKind: 'missing-on-right', QualifiedName: q });
         else if (l && r) {
             const fields = [];
             if (l.dataType.toLowerCase() !== r.dataType.toLowerCase())
@@ -195,36 +199,36 @@ function diffTable(left, right) {
             if (normalizeDefault(l.defaultExpression) !== normalizeDefault(r.defaultExpression))
                 fields.push(`default: ${l.defaultExpression} vs ${r.defaultExpression}`);
             if (fields.length)
-                out.push({ kind: 'column', diffKind: 'changed', qualifiedName: q, details: fields.join('; ') });
+                out.push({ Kind: 'column', DiffKind: 'changed', QualifiedName: q, Details: fields.join('; ') });
         }
     }
     // Primary key
-    if (!!left.primaryKey !== !!right.primaryKey) {
+    if (!!left.PrimaryKey !== !!right.PrimaryKey) {
         out.push({
-            kind: 'primaryKey',
-            diffKind: left.primaryKey ? 'missing-on-right' : 'missing-on-left',
-            qualifiedName: tableQ,
+            Kind: 'primaryKey',
+            DiffKind: left.PrimaryKey ? 'missing-on-right' : 'missing-on-left',
+            QualifiedName: tableQ,
         });
     }
-    else if (left.primaryKey && right.primaryKey) {
+    else if (left.PrimaryKey && right.PrimaryKey) {
         const reasons = [];
-        if (left.primaryKey.columns.join(',') !== right.primaryKey.columns.join(','))
-            reasons.push(`pk columns: ${left.primaryKey.columns} vs ${right.primaryKey.columns}`);
-        if (left.primaryKey.clustered !== right.primaryKey.clustered)
-            reasons.push(`pk clustered: ${left.primaryKey.clustered} vs ${right.primaryKey.clustered}`);
-        if (left.primaryKey.name !== right.primaryKey.name)
-            reasons.push(`pk name: ${left.primaryKey.name} vs ${right.primaryKey.name}`);
+        if (left.PrimaryKey.Columns.join(',') !== right.PrimaryKey.Columns.join(','))
+            reasons.push(`pk columns: ${left.PrimaryKey.Columns} vs ${right.PrimaryKey.Columns}`);
+        if (left.PrimaryKey.Clustered !== right.PrimaryKey.Clustered)
+            reasons.push(`pk clustered: ${left.PrimaryKey.Clustered} vs ${right.PrimaryKey.Clustered}`);
+        if (left.PrimaryKey.Name !== right.PrimaryKey.Name)
+            reasons.push(`pk name: ${left.PrimaryKey.Name} vs ${right.PrimaryKey.Name}`);
         if (reasons.length) {
             out.push({
-                kind: 'primaryKey',
-                diffKind: 'changed',
-                qualifiedName: tableQ,
-                details: reasons.join('; '),
+                Kind: 'primaryKey',
+                DiffKind: 'changed',
+                QualifiedName: tableQ,
+                Details: reasons.join('; '),
             });
         }
     }
     // Unique constraints (previously uncompared — silent gap)
-    out.push(...diffNamedSet('uniqueConstraint', left.uniqueConstraints, right.uniqueConstraints, (u) => `${tableQ}.${u.name}`, () => false, (l, r) => {
+    out.push(...diffNamedSet('uniqueConstraint', left.UniqueConstraints, right.UniqueConstraints, (u) => `${tableQ}.${u.name}`, () => false, (l, r) => {
         if (l.columns.join(',') !== r.columns.join(','))
             return 'unique constraint columns differ';
         if (l.clustered !== r.clustered)
@@ -232,7 +236,7 @@ function diffTable(left, right) {
         return null;
     }));
     // Indexes
-    out.push(...diffNamedSet('index', left.indexes, right.indexes, (i) => `${tableQ}.${i.name}`, () => false, (l, r) => {
+    out.push(...diffNamedSet('index', left.Indexes, right.Indexes, (i) => `${tableQ}.${i.name}`, () => false, (l, r) => {
         if (l.columns.join(',') !== r.columns.join(','))
             return `index columns differ: ${l.columns} vs ${r.columns}`;
         if (l.includes.join(',') !== r.includes.join(','))
@@ -246,7 +250,7 @@ function diffTable(left, right) {
         return null;
     }));
     // FKs
-    out.push(...diffNamedSet('foreignKey', left.foreignKeys, right.foreignKeys, (f) => `${tableQ}.${f.name}`, () => false, (l, r) => {
+    out.push(...diffNamedSet('foreignKey', left.ForeignKeys, right.ForeignKeys, (f) => `${tableQ}.${f.name}`, () => false, (l, r) => {
         if (l.columns.join(',') !== r.columns.join(','))
             return 'fk columns differ';
         if (l.referencedSchema !== r.referencedSchema || l.referencedTable !== r.referencedTable)
@@ -260,74 +264,74 @@ function diffTable(left, right) {
         return null;
     }));
     // Checks
-    out.push(...diffNamedSet('check', left.checks, right.checks, (c) => `${tableQ}.${c.name}`, () => false, (l, r) => normalizeBody(l.expression) === normalizeBody(r.expression) ? null : 'check expression differs'));
+    out.push(...diffNamedSet('check', left.Checks, right.Checks, (c) => `${tableQ}.${c.name}`, () => false, (l, r) => normalizeBody(l.expression) === normalizeBody(r.expression) ? null : 'check expression differs'));
     return out;
 }
 function diffTableRows(left, right, options) {
     const sample = [];
     let diffCount = 0;
-    const limit = options.rowDiffSampleLimit;
+    const limit = options.RowDiffSampleLimit;
     const cap = (rd) => {
         diffCount++;
         if (sample.length < limit)
             sample.push(rd);
     };
-    if (options.rowCompareMode === 'counts') {
-        if (left.rowCount !== right.rowCount)
-            cap({ diffKind: 'changed', key: '*', columnDiffs: [] });
+    if (options.RowCompareMode === 'counts') {
+        if (left.RowCount !== right.RowCount)
+            cap({ DiffKind: 'changed', Key: '*', ColumnDiffs: [] });
         return {
-            schema: left.schema,
-            table: left.table,
-            leftRowCount: left.rowCount,
-            rightRowCount: right.rowCount,
-            sampleDiffs: sample,
-            truncated: false,
-            diffCount,
+            Schema: left.Schema,
+            Table: left.Table,
+            LeftRowCount: left.RowCount,
+            RightRowCount: right.RowCount,
+            SampleDiffs: sample,
+            Truncated: false,
+            DiffCount: diffCount,
         };
     }
     // Both rows[] are pre-ordered (PK then col order). Walk in lock-step using
     // a stringified row key to align even when the two sides have inserts/deletes.
-    const leftKeys = left.rows.map((r) => keyForRow(r, left.columns));
-    const rightKeys = right.rows.map((r) => keyForRow(r, right.columns));
+    const leftKeys = left.Rows.map((r) => keyForRow(r, left.Columns));
+    const rightKeys = right.Rows.map((r) => keyForRow(r, right.Columns));
     const leftIndex = new Map(leftKeys.map((k, i) => [k, i]));
     const rightIndex = new Map(rightKeys.map((k, i) => [k, i]));
     for (let i = 0; i < leftKeys.length; i++) {
         const k = leftKeys[i];
         const ri = rightIndex.get(k);
         if (ri === undefined) {
-            cap({ diffKind: 'missing-on-right', key: k });
+            cap({ DiffKind: 'missing-on-right', Key: k });
             continue;
         }
-        if (options.rowCompareMode === 'full') {
-            const lRow = left.rows[i];
-            const rRow = right.rows[ri];
+        if (options.RowCompareMode === 'full') {
+            const lRow = left.Rows[i];
+            const rRow = right.Rows[ri];
             const colDiffs = [];
-            for (let c = 0; c < left.columns.length; c++) {
-                const colName = left.columns[c];
-                const rIdx = right.columns.indexOf(colName);
+            for (let c = 0; c < left.Columns.length; c++) {
+                const colName = left.Columns[c];
+                const rIdx = right.Columns.indexOf(colName);
                 if (rIdx === -1)
                     continue;
-                if (!deepValueEqual(lRow[c], rRow[rIdx])) {
-                    colDiffs.push({ column: colName, leftValue: lRow[c], rightValue: rRow[rIdx] });
+                if (!DeepValueEqual(lRow[c], rRow[rIdx])) {
+                    colDiffs.push({ Column: colName, LeftValue: lRow[c], RightValue: rRow[rIdx] });
                 }
             }
             if (colDiffs.length > 0)
-                cap({ diffKind: 'changed', key: k, columnDiffs: colDiffs });
+                cap({ DiffKind: 'changed', Key: k, ColumnDiffs: colDiffs });
         }
     }
     for (let i = 0; i < rightKeys.length; i++) {
         const k = rightKeys[i];
         if (!leftIndex.has(k))
-            cap({ diffKind: 'missing-on-left', key: k });
+            cap({ DiffKind: 'missing-on-left', Key: k });
     }
     return {
-        schema: left.schema,
-        table: left.table,
-        leftRowCount: left.rowCount,
-        rightRowCount: right.rowCount,
-        sampleDiffs: sample,
-        truncated: diffCount > sample.length,
-        diffCount,
+        Schema: left.Schema,
+        Table: left.Table,
+        LeftRowCount: left.RowCount,
+        RightRowCount: right.RowCount,
+        SampleDiffs: sample,
+        Truncated: diffCount > sample.length,
+        DiffCount: diffCount,
     };
 }
 function keyForRow(row, _columns) {
@@ -381,21 +385,21 @@ function normalizeDefault(value) {
 }
 /** Diff user-defined types (table types). Comparison is structural: same columns, same PK, same memory-optimization. */
 function diffUserDefinedTypes(left, right, ignore) {
-    return diffNamedSet('userDefinedType', left, right, (t) => `${t.schema}.${t.name}`, ignore, (l, r) => {
+    return diffNamedSet('userDefinedType', left, right, (t) => `${t.Schema}.${t.Name}`, ignore, (l, r) => {
         const reasons = [];
-        if (l.kind !== r.kind)
-            reasons.push(`kind: ${l.kind} vs ${r.kind}`);
-        if (l.isMemoryOptimized !== r.isMemoryOptimized)
+        if (l.Kind !== r.Kind)
+            reasons.push(`kind: ${l.Kind} vs ${r.Kind}`);
+        if (l.IsMemoryOptimized !== r.IsMemoryOptimized)
             reasons.push('memory-optimized differs');
         // Column-by-column structural diff. Order matters (TVPs have a fixed
         // column ordinal that affects INSERT compatibility).
-        if (l.columns.length !== r.columns.length) {
-            reasons.push(`column count: ${l.columns.length} vs ${r.columns.length}`);
+        if (l.Columns.length !== r.Columns.length) {
+            reasons.push(`column count: ${l.Columns.length} vs ${r.Columns.length}`);
         }
         else {
-            for (let i = 0; i < l.columns.length; i++) {
-                const lc = l.columns[i];
-                const rc = r.columns[i];
+            for (let i = 0; i < l.Columns.length; i++) {
+                const lc = l.Columns[i];
+                const rc = r.Columns[i];
                 if (lc.name !== rc.name)
                     reasons.push(`col[${i}] name: ${lc.name} vs ${rc.name}`);
                 if (lc.dataType.toLowerCase() !== rc.dataType.toLowerCase())
@@ -404,8 +408,8 @@ function diffUserDefinedTypes(left, right, ignore) {
                     reasons.push(`col[${i}] nullable: ${lc.isNullable} vs ${rc.isNullable}`);
             }
         }
-        const lPkCols = l.primaryKey?.columns.join(',') ?? '';
-        const rPkCols = r.primaryKey?.columns.join(',') ?? '';
+        const lPkCols = l.PrimaryKey?.Columns.join(',') ?? '';
+        const rPkCols = r.PrimaryKey?.Columns.join(',') ?? '';
         if (lPkCols !== rPkCols)
             reasons.push(`pk columns: ${lPkCols} vs ${rPkCols}`);
         return reasons.length === 0 ? null : reasons.join('; ');
@@ -417,12 +421,12 @@ function diffUserDefinedTypes(left, right, ignore) {
  */
 function diffExtendedProperties(left, right) {
     const key = (p) => [
-        p.schemaName,
-        p.level1Type ?? '',
-        p.level1Name ?? '',
-        p.level2Type ?? '',
-        p.level2Name ?? '',
-        p.name,
+        p.SchemaName,
+        p.Level1Type ?? '',
+        p.Level1Name ?? '',
+        p.Level2Type ?? '',
+        p.Level2Name ?? '',
+        p.Name,
     ]
         .join('::')
         .toLowerCase();
@@ -434,17 +438,17 @@ function diffExtendedProperties(left, right) {
         const l = leftMap.get(k);
         const r = rightMap.get(k);
         if (!l && r)
-            out.push({ kind: 'extendedProperty', diffKind: 'missing-on-left', qualifiedName: k });
+            out.push({ Kind: 'extendedProperty', DiffKind: 'missing-on-left', QualifiedName: k });
         else if (l && !r)
-            out.push({ kind: 'extendedProperty', diffKind: 'missing-on-right', qualifiedName: k });
-        else if (l && r && l.value !== r.value) {
+            out.push({ Kind: 'extendedProperty', DiffKind: 'missing-on-right', QualifiedName: k });
+        else if (l && r && l.Value !== r.Value) {
             out.push({
-                kind: 'extendedProperty',
-                diffKind: 'changed',
-                qualifiedName: k,
-                details: `value differs`,
-                leftValue: l.value,
-                rightValue: r.value,
+                Kind: 'extendedProperty',
+                DiffKind: 'changed',
+                QualifiedName: k,
+                Details: `value differs`,
+                LeftValue: l.Value,
+                RightValue: r.Value,
             });
         }
     }
@@ -452,18 +456,18 @@ function diffExtendedProperties(left, right) {
 }
 /** Diff database principals (users + custom roles). Matched by name; kind/owner/defaultSchema compared. */
 function diffPrincipals(left, right) {
-    return diffNamedSet('principal', left, right, (p) => p.name, () => false, (l, r) => {
+    return diffNamedSet('principal', left, right, (p) => p.Name, () => false, (l, r) => {
         const reasons = [];
-        if (l.kind !== r.kind)
-            reasons.push(`kind: ${l.kind} vs ${r.kind}`);
+        if (l.Kind !== r.Kind)
+            reasons.push(`kind: ${l.Kind} vs ${r.Kind}`);
         // Owner mismatch is informational only — emitted CREATE ROLE matches the
         // source's AUTHORIZATION clause. Skip if either side is missing the owner
         // (older snapshots / future formats may omit it).
-        if (l.owner && r.owner && l.owner.toLowerCase() !== r.owner.toLowerCase()) {
-            reasons.push(`owner: ${l.owner} vs ${r.owner}`);
+        if (l.Owner && r.Owner && l.Owner.toLowerCase() !== r.Owner.toLowerCase()) {
+            reasons.push(`owner: ${l.Owner} vs ${r.Owner}`);
         }
-        if ((l.defaultSchema || '').toLowerCase() !== (r.defaultSchema || '').toLowerCase()) {
-            reasons.push(`defaultSchema: ${l.defaultSchema} vs ${r.defaultSchema}`);
+        if ((l.DefaultSchema || '').toLowerCase() !== (r.DefaultSchema || '').toLowerCase()) {
+            reasons.push(`defaultSchema: ${l.DefaultSchema} vs ${r.DefaultSchema}`);
         }
         return reasons.length === 0 ? null : reasons.join('; ');
     });
@@ -479,9 +483,9 @@ function diffRoleMemberships(left, right) {
         const inL = leftMap.has(k);
         const inR = rightMap.has(k);
         if (inL && !inR)
-            out.push({ kind: 'roleMembership', diffKind: 'missing-on-right', qualifiedName: k });
+            out.push({ Kind: 'roleMembership', DiffKind: 'missing-on-right', QualifiedName: k });
         else if (!inL && inR)
-            out.push({ kind: 'roleMembership', diffKind: 'missing-on-left', qualifiedName: k });
+            out.push({ Kind: 'roleMembership', DiffKind: 'missing-on-left', QualifiedName: k });
     }
     return out;
 }
@@ -510,15 +514,15 @@ function diffPermissions(left, right) {
         const l = leftMap.get(k);
         const r = rightMap.get(k);
         if (l && !r)
-            out.push({ kind: 'permission', diffKind: 'missing-on-right', qualifiedName: k });
+            out.push({ Kind: 'permission', DiffKind: 'missing-on-right', QualifiedName: k });
         else if (!l && r)
-            out.push({ kind: 'permission', diffKind: 'missing-on-left', qualifiedName: k });
+            out.push({ Kind: 'permission', DiffKind: 'missing-on-left', QualifiedName: k });
         else if (l && r && l.state !== r.state) {
             out.push({
-                kind: 'permission',
-                diffKind: 'changed',
-                qualifiedName: k,
-                details: `state: ${l.state} vs ${r.state}`,
+                Kind: 'permission',
+                DiffKind: 'changed',
+                QualifiedName: k,
+                Details: `state: ${l.state} vs ${r.state}`,
             });
         }
     }