@memberjunction/server 6.1.4 → 6.2.0-edge.1

package/src/resolvers/__tests__/GetDataResolver.tokens.test.ts

@@ -12,22 +12,24 @@ import { describe, it, expect, vi } from 'vitest';
 // vars to even import. Mock those heavy imports out so this file stays a true,
 // isolated unit test of the token-tracking logic (mirrors the mocking convention
 // in RealtimeBridgeResolver.test.ts).
-vi.mock('../../index.js', () => ({ getDbType: vi.fn() }));
+vi.mock('../../index.js', () => ({ GetDbType: vi.fn(),
+    get getDbType() { return this.GetDbType; } }));
 vi.mock('@memberjunction/generic-database-provider', () => ({
   QueryCompositionEngine: vi.fn(() => ({ HasCompositionTokens: vi.fn(() => false) })),
 }));
 vi.mock('../../util.js', () => ({ GetReadOnlyDataSource: vi.fn(), GetReadOnlyProvider: vi.fn() }));
-vi.mock('../../auth/index.js', () => ({ getSystemUser: vi.fn() }));
+vi.mock('../../auth/index.js', () => ({ GetSystemUser: vi.fn(),
+    get getSystemUser() { return this.GetSystemUser; } }));
 vi.mock('mssql', () => ({ default: { Request: vi.fn() } }));
 
 import {
-  registerAccessToken,
-  deleteAccessToken,
-  tokenExists,
-  isTokenValid,
-  recordTokenUse,
-  pruneExpiredTokens,
-  getAccessTokenCount,
+  RegisterAccessToken,
+  DeleteAccessToken,
+  TokenExists,
+  IsTokenValid,
+  RecordTokenUse,
+  PruneExpiredTokens,
+  GetAccessTokenCount,
 } from '../GetDataResolver.js';
 
 // ---------------------------------------------------------------------------
@@ -51,88 +53,88 @@ const uniqueToken = () => `test-token-${Date.now()}-${++seq}`;
 describe('GetDataResolver access-token lifecycle', () => {
   it('registerAccessToken() creates a token that is valid and exists', () => {
     const token = uniqueToken();
-    const created = registerAccessToken(token, 60_000);
+    const created = RegisterAccessToken(token, 60_000);
     expect(created.Token).toBe(token);
-    expect(tokenExists(token)).toBe(true);
-    expect(isTokenValid(token)).toBe(true);
+    expect(TokenExists(token)).toBe(true);
+    expect(IsTokenValid(token)).toBe(true);
   });
 
   it('registerAccessToken() throws when the same custom token is registered twice', () => {
     const token = uniqueToken();
-    registerAccessToken(token, 60_000);
-    expect(() => registerAccessToken(token, 60_000)).toThrow(/already exists/);
+    RegisterAccessToken(token, 60_000);
+    expect(() => RegisterAccessToken(token, 60_000)).toThrow(/already exists/);
   });
 
   it('isTokenValid() is false for an unknown token and for an expired one', () => {
-    expect(isTokenValid('never-registered-token')).toBe(false);
+    expect(IsTokenValid('never-registered-token')).toBe(false);
 
     const token = uniqueToken();
-    registerAccessToken(token, -1); // already expired (ExpiresAt in the past)
-    expect(isTokenValid(token)).toBe(false);
+    RegisterAccessToken(token, -1); // already expired (ExpiresAt in the past)
+    expect(IsTokenValid(token)).toBe(false);
   });
 
   it('deleteAccessToken() removes a token and throws for an unknown one', () => {
     const token = uniqueToken();
-    registerAccessToken(token, 60_000);
-    expect(tokenExists(token)).toBe(true);
+    RegisterAccessToken(token, 60_000);
+    expect(TokenExists(token)).toBe(true);
 
-    deleteAccessToken(token);
-    expect(tokenExists(token)).toBe(false);
-    expect(() => deleteAccessToken(token)).toThrow(/does not exist/);
+    DeleteAccessToken(token);
+    expect(TokenExists(token)).toBe(false);
+    expect(() => DeleteAccessToken(token)).toThrow(/does not exist/);
   });
 
   it('recordTokenUse() appends to TokenUses and throws for an unknown token', () => {
     const token = uniqueToken();
-    registerAccessToken(token, 60_000);
+    RegisterAccessToken(token, 60_000);
 
-    expect(() => recordTokenUse(token, { some: 'payload' })).not.toThrow();
-    expect(() => recordTokenUse('never-registered-token', {})).toThrow(/does not exist/);
+    expect(() => RecordTokenUse(token, { some: 'payload' })).not.toThrow();
+    expect(() => RecordTokenUse('never-registered-token', {})).toThrow(/does not exist/);
   });
 
   it('pruneExpiredTokens() removes only tokens whose ExpiresAt has passed', () => {
     const expiredToken = uniqueToken();
     const liveToken = uniqueToken();
-    registerAccessToken(expiredToken, -1); // already expired
-    registerAccessToken(liveToken, 60_000); // still valid
+    RegisterAccessToken(expiredToken, -1); // already expired
+    RegisterAccessToken(liveToken, 60_000); // still valid
 
-    pruneExpiredTokens();
+    PruneExpiredTokens();
 
-    expect(tokenExists(expiredToken)).toBe(false);
-    expect(tokenExists(liveToken)).toBe(true);
+    expect(TokenExists(expiredToken)).toBe(false);
+    expect(TokenExists(liveToken)).toBe(true);
   });
 
   it('pruneExpiredTokens() accepts an injected "now" for deterministic testing', () => {
     const token = uniqueToken();
     const registeredAt = new Date('2026-01-01T00:00:00Z');
-    registerAccessToken(token, 5 * 60 * 1000); // 5-minute lifespan from real "now"
+    RegisterAccessToken(token, 5 * 60 * 1000); // 5-minute lifespan from real "now"
 
     // Simulate a check far in the future — token should count as expired at that instant.
     const farFuture = new Date(registeredAt.getTime() + 365 * 24 * 60 * 60 * 1000);
-    pruneExpiredTokens(farFuture);
+    PruneExpiredTokens(farFuture);
 
-    expect(tokenExists(token)).toBe(false);
+    expect(TokenExists(token)).toBe(false);
   });
 
   it('the core Round 7 regression: registering many expired tokens does not grow the array without bound', () => {
-    const before = getAccessTokenCount();
+    const before = GetAccessTokenCount();
 
     // Simulate 50 short-lived tokens that all expire immediately (e.g. a burst
     // of external calls with a near-zero lifespan, or tokens whose consumer
     // never came back before expiry — the exact shape of the leak this fix
     // addresses).
     for (let i = 0; i < 50; i++) {
-      registerAccessToken(`${uniqueToken()}-burst-${i}`, -1);
+      RegisterAccessToken(`${uniqueToken()}-burst-${i}`, -1);
     }
 
     // Register one more, healthy token — its registerAccessToken() call sweeps
     // all 50 expired ones out, so the count should NOT have grown by 51; it
     // should only reflect whatever was live before plus this one new token.
     const survivorToken = uniqueToken();
-    registerAccessToken(survivorToken, 60_000);
+    RegisterAccessToken(survivorToken, 60_000);
 
     // The 50 expired burst tokens must be gone — the array self-bounded rather
     // than accumulating every registration for the life of the process.
-    expect(getAccessTokenCount()).toBeLessThan(before + 51);
-    expect(tokenExists(survivorToken)).toBe(true);
+    expect(GetAccessTokenCount()).toBeLessThan(before + 51);
+    expect(TokenExists(survivorToken)).toBe(true);
   });
 });

package/src/resolvers/__tests__/artifact-routing.test.ts

@@ -2,14 +2,14 @@ import { describe, it, expect, vi } from 'vitest';
 import { RouteArtifact, type ArtifactRoutingInput } from '../artifact-routing';
 
 const baseInput = (overrides: Partial<ArtifactRoutingInput> = {}): ArtifactRoutingInput => ({
-    typeDefault: 'Inline',
-    forceToolsOnly: false,
+    TypeDefault: 'Inline',
+    ForceToolsOnly: false,
     mimeType: 'image/png',
-    sizeBytes: 5_000,
-    inlineSizeCap: 100 * 1024,
-    modelSupportsModality: () => true,
-    modelName: 'TestModel',
-    artifactTypeName: 'Image',
+    SizeBytes: 5_000,
+    InlineSizeCap: 100 * 1024,
+    ModelSupportsModality: () => true,
+    ModelName: 'TestModel',
+    ArtifactTypeName: 'Image',
     ...overrides,
 });
 
@@ -20,18 +20,18 @@ describe('RouteArtifact', () => {
     });
 
     it('routes ToolsOnly type default to tools', () => {
-        const result = RouteArtifact(baseInput({ typeDefault: 'ToolsOnly' }));
+        const result = RouteArtifact(baseInput({ TypeDefault: 'ToolsOnly' }));
         expect(result).toEqual({ delivery: 'tools' });
     });
 
     it('routes ForceToolsOnly per-instance override to tools regardless of type default', () => {
-        const result = RouteArtifact(baseInput({ forceToolsOnly: true }));
+        const result = RouteArtifact(baseInput({ ForceToolsOnly: true }));
         expect(result).toEqual({ delivery: 'tools' });
     });
 
     it('returns an error when the model lacks modality support for an Inline type', () => {
         const result = RouteArtifact(baseInput({
-            modelSupportsModality: () => false,
+            ModelSupportsModality: () => false,
         }));
         expect(result.delivery).toBe('error');
         if (result.delivery !== 'error') return;
@@ -46,22 +46,22 @@ describe('RouteArtifact', () => {
 
     it('falls back to tools with annotation when size exceeds the cap', () => {
         const result = RouteArtifact(baseInput({
-            sizeBytes: 200 * 1024,
-            inlineSizeCap: 100 * 1024,
+            SizeBytes: 200 * 1024,
+            InlineSizeCap: 100 * 1024,
         }));
         expect(result.delivery).toBe('tools');
         if (result.delivery !== 'tools') return;
-        expect(result.annotation).toBeDefined();
-        expect(result.annotation).toMatch(/exceeds the inline cap/);
-        expect(result.annotation).toContain('204800');
-        expect(result.annotation).toContain('102400');
+        expect(result.Annotation).toBeDefined();
+        expect(result.Annotation).toMatch(/exceeds the inline cap/);
+        expect(result.Annotation).toContain('204800');
+        expect(result.Annotation).toContain('102400');
     });
 
     it('checks ToolsOnly before modality (modality check is irrelevant when type is ToolsOnly)', () => {
         const modelSupportsModality = vi.fn(() => false);
         const result = RouteArtifact(baseInput({
-            typeDefault: 'ToolsOnly',
-            modelSupportsModality,
+            TypeDefault: 'ToolsOnly',
+            ModelSupportsModality: modelSupportsModality,
         }));
         expect(result).toEqual({ delivery: 'tools' });
         expect(modelSupportsModality).not.toHaveBeenCalled();
@@ -69,8 +69,8 @@ describe('RouteArtifact', () => {
 
     it('checks modality before size (modality error wins over size fallback)', () => {
         const result = RouteArtifact(baseInput({
-            modelSupportsModality: () => false,
-            sizeBytes: 200 * 1024,
+            ModelSupportsModality: () => false,
+            SizeBytes: 200 * 1024,
         }));
         expect(result.delivery).toBe('error');
     });
@@ -78,9 +78,9 @@ describe('RouteArtifact', () => {
     it('ForceToolsOnly bypasses both modality and size checks', () => {
         const modelSupportsModality = vi.fn(() => false);
         const result = RouteArtifact(baseInput({
-            forceToolsOnly: true,
-            modelSupportsModality,
-            sizeBytes: 200 * 1024,
+            ForceToolsOnly: true,
+            ModelSupportsModality: modelSupportsModality,
+            SizeBytes: 200 * 1024,
         }));
         expect(result).toEqual({ delivery: 'tools' });
         expect(modelSupportsModality).not.toHaveBeenCalled();

package/src/resolvers/adhoc-query-helpers.ts

@@ -15,7 +15,7 @@
  * - **Full page** (`pageLength >= maxRows`): more rows may exist — returns `null` to
  *   signal that a `COUNT(*)` is required to know the true total.
  */
-export function exactTotalFromPage(
+export function ExactTotalFromPage(
     startRow: number,
     pageLength: number,
     maxRows: number | null,
@@ -29,13 +29,22 @@ export function exactTotalFromPage(
     return null;
 }
 
+/** @deprecated Use {@link ExactTotalFromPage}. */
+export function exactTotalFromPage(
+    startRow: number,
+    pageLength: number,
+    maxRows: number | null,
+): number | null {
+    return ExactTotalFromPage(startRow, pageLength, maxRows);
+}
+
 /**
  * Reads the total row count from a `COUNT(*)` recordset (`[{ TotalRowCount }]`),
  * falling back to `fallback` when the count is absent, non-numeric, or negative — so
  * an unexpected count shape never yields a misleading total. `fallback` should be a
  * safe lower bound (e.g. `startRow + rowsReturned`).
  */
-export function resolveAdhocTotalRowCount(
+export function ResolveAdhocTotalRowCount(
     countRows: ReadonlyArray<{ TotalRowCount?: unknown }> | null | undefined,
     fallback: number,
 ): number {
@@ -48,3 +57,11 @@ export function resolveAdhocTotalRowCount(
     }
     return fallback;
 }
+
+/** @deprecated Use {@link ResolveAdhocTotalRowCount}. */
+export function resolveAdhocTotalRowCount(
+    countRows: ReadonlyArray<{ TotalRowCount?: unknown }> | null | undefined,
+    fallback: number,
+): number {
+    return ResolveAdhocTotalRowCount(countRows, fallback);
+}

package/src/resolvers/artifact-routing.ts

@@ -12,38 +12,38 @@ export type ArtifactDeliveryMode = 'Inline' | 'ToolsOnly';
 
 export interface ArtifactRoutingInput {
     /** The Artifact Type's DefaultDeliveryMode. */
-    typeDefault: ArtifactDeliveryMode;
+    TypeDefault: ArtifactDeliveryMode;
     /** Per-instance opt-out — `true` forces tools regardless of typeDefault. */
-    forceToolsOnly: boolean;
+    ForceToolsOnly: boolean;
     /** MIME type of the artifact content (e.g. 'image/png'). */
-    mimeType: string;
+    mimeType: string;  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
     /** Size of the content in bytes. */
-    sizeBytes: number;
+    SizeBytes: number;
     /** Maximum inline size in bytes; over this, even Inline-default artifacts go to tools. */
-    inlineSizeCap: number;
+    InlineSizeCap: number;
     /** Predicate: does the active model driver support the given MIME modality inline? */
-    modelSupportsModality: (mimeType: string) => boolean;
+    ModelSupportsModality: (mimeType: string) => boolean;
     /** Model name used in error messages — never used to make decisions. */
-    modelName: string;
+    ModelName: string;
     /** Artifact type name used in error messages. */
-    artifactTypeName: string;
+    ArtifactTypeName: string;
 }
 
 export type ArtifactRoutingDecision =
-    | { delivery: 'inline' }
-    | { delivery: 'tools'; annotation?: string }
-    | { delivery: 'error'; message: string };
+    | { delivery: 'inline' }  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
+    | { delivery: 'tools'; Annotation?: string }  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
+    | { delivery: 'error'; message: string };  // case-violation-ok-legacy-back-compat: the old name is also read off a value typed `any`, where a rename would compile and silently return undefined
 
 export function RouteArtifact(input: ArtifactRoutingInput): ArtifactRoutingDecision {
     const {
-        typeDefault,
-        forceToolsOnly,
+        TypeDefault: typeDefault,
+        ForceToolsOnly: forceToolsOnly,
         mimeType,
-        sizeBytes,
-        inlineSizeCap,
-        modelSupportsModality,
-        modelName,
-        artifactTypeName,
+        SizeBytes: sizeBytes,
+        InlineSizeCap: inlineSizeCap,
+        ModelSupportsModality: modelSupportsModality,
+        ModelName: modelName,
+        ArtifactTypeName: artifactTypeName,
     } = input;
 
     // Path 1: ToolsOnly default or per-instance opt-out — always tools.
@@ -71,7 +71,7 @@ export function RouteArtifact(input: ArtifactRoutingInput): ArtifactRoutingDecis
     if (sizeBytes >= inlineSizeCap) {
         return {
             delivery: 'tools',
-            annotation: `Artifact type "${artifactTypeName}" is configured for Inline delivery but content size (${sizeBytes} bytes) exceeds the inline cap (${inlineSizeCap} bytes); delivered via tools instead.`,
+            Annotation: `Artifact type "${artifactTypeName}" is configured for Inline delivery but content size (${sizeBytes} bytes) exceeds the inline cap (${inlineSizeCap} bytes); delivered via tools instead.`,
         };
     }
 

package/src/resolvers/meetingRecordingRegistration.ts

@@ -81,13 +81,13 @@ export interface MeetingRecordingRegistrationConfig {
    * The `MJ: File Storage Providers` id whose accounts target the egress sink (where LiveKit wrote the
    * MP4). Falls back to `process.env.MJ_MEETING_RECORDING_STORAGE_PROVIDER`.
    */
-  sinkStorageProviderID?: string;
+  SinkStorageProviderID?: string;
   /**
    * OPTIONAL canonical provider id — when set AND different from the sink, the MP4 is copied into it and
    * the Files row points there (the "copy into Box" option). Falls back to
    * `process.env.MJ_MEETING_RECORDING_CANONICAL_STORAGE_PROVIDER`. OFF by default.
    */
-  canonicalStorageProviderID?: string;
+  CanonicalStorageProviderID?: string;
 }
 
 /**
@@ -100,7 +100,7 @@ export interface MeetingRecordingRegistrationConfig {
  * @param provider The metadata provider servicing this request.
  * @param config Optional config overrides (otherwise read from env).
  */
-export async function registerMeetingRecordingFile(
+export async function RegisterMeetingRecordingFile(
   egress: MeetingRecordingEgressResult,
   contextUser: UserInfo,
   provider: IMetadataProvider,
@@ -115,7 +115,7 @@ export async function registerMeetingRecordingFile(
       };
     }
 
-    const sinkProviderID = config?.sinkStorageProviderID ?? process.env.MJ_MEETING_RECORDING_STORAGE_PROVIDER;
+    const sinkProviderID = config?.SinkStorageProviderID ?? process.env.MJ_MEETING_RECORDING_STORAGE_PROVIDER;
     if (!sinkProviderID) {
       return {
         Success: false,
@@ -138,7 +138,7 @@ export async function registerMeetingRecordingFile(
       };
     }
 
-    const conversationID = await resolveMeetingConversation(egress, contextUser, provider);
+    const conversationID = await ResolveMeetingConversation(egress, contextUser, provider);
     if (!conversationID) {
       return { Success: false, ErrorMessage: 'Could not resolve or create the Meeting-Room Conversation for the recording.' };
     }
@@ -175,6 +175,16 @@ export async function registerMeetingRecordingFile(
   }
 }
 
+/** @deprecated Use {@link RegisterMeetingRecordingFile}. */
+export async function registerMeetingRecordingFile(
+  egress: MeetingRecordingEgressResult,
+  contextUser: UserInfo,
+  provider: IMetadataProvider,
+  config?: MeetingRecordingRegistrationConfig,
+): Promise<MeetingRecordingRegistrationResult> {
+  return RegisterMeetingRecordingFile(egress, contextUser, provider, config);
+}
+
 /**
  * Best-effort correlation when a recording STARTS: stamps `Conversation.EgressID` onto the room's
  * Meeting-Room Conversation (if it already exists) so a live recording is tracked against the room. If the
@@ -187,7 +197,7 @@ export async function registerMeetingRecordingFile(
  * @param provider The metadata provider.
  * @returns `true` when an existing conversation was stamped, else `false`.
  */
-export async function correlateRecordingStart(roomName: string, egressID: string, contextUser: UserInfo, provider: IMetadataProvider): Promise<boolean> {
+export async function CorrelateRecordingStart(roomName: string, egressID: string, contextUser: UserInfo, provider: IMetadataProvider): Promise<boolean> {
   try {
     const conversationID = await findConversationByRoomName(roomName, contextUser, provider);
     if (!conversationID) {
@@ -210,12 +220,17 @@ export async function correlateRecordingStart(roomName: string, egressID: string
   }
 }
 
+/** @deprecated Use {@link CorrelateRecordingStart}. */
+export async function correlateRecordingStart(roomName: string, egressID: string, contextUser: UserInfo, provider: IMetadataProvider): Promise<boolean> {
+  return CorrelateRecordingStart(roomName, egressID, contextUser, provider);
+}
+
 /**
  * Resolves the Meeting-Room Conversation for a completed recording: prefer matching by `EgressID` (set on
  * start), fall back to the room name (`ExternalID` + `Type`), else create one following the transcript
  * sink's pattern (scoped `Application` so it stays out of the normal chat list).
  */
-export async function resolveMeetingConversation(
+export async function ResolveMeetingConversation(
   egress: MeetingRecordingEgressResult,
   contextUser: UserInfo,
   provider: IMetadataProvider,
@@ -231,6 +246,15 @@ export async function resolveMeetingConversation(
   return createMeetingConversation(egress.RoomName, contextUser, provider);
 }
 
+/** @deprecated Use {@link ResolveMeetingConversation}. */
+export async function resolveMeetingConversation(
+  egress: MeetingRecordingEgressResult,
+  contextUser: UserInfo,
+  provider: IMetadataProvider,
+): Promise<string | null> {
+  return ResolveMeetingConversation(egress, contextUser, provider);
+}
+
 /** Finds a non-archived Meeting-Room Conversation by its `EgressID`. */
 async function findConversationByEgressID(egressID: string, contextUser: UserInfo, provider: IMetadataProvider): Promise<string | null> {
   if (!egressID) {
@@ -310,7 +334,7 @@ async function resolveFileLocation(
   config?: MeetingRecordingRegistrationConfig,
 ): Promise<FileLocationResult> {
   const outputLocation = egress.OutputLocation!;
-  const canonicalProviderID = config?.canonicalStorageProviderID ?? process.env.MJ_MEETING_RECORDING_CANONICAL_STORAGE_PROVIDER;
+  const canonicalProviderID = config?.CanonicalStorageProviderID ?? process.env.MJ_MEETING_RECORDING_CANONICAL_STORAGE_PROVIDER;
 
   // Default (v1): point directly at the sink output — playback streams straight from it, no byte copy.
   if (!canonicalProviderID || canonicalProviderID === sinkProviderID) {
@@ -319,7 +343,7 @@ async function resolveFileLocation(
 
   // OPTIONAL "copy into Box": a separate canonical provider IS configured and differs from the sink —
   // read the bytes from the sink and upload them into the canonical provider, then point there.
-  const canonicalKey = await copyEgressOutputToCanonical(outputLocation, sinkAccountID, canonicalProviderID, contextUser);
+  const canonicalKey = await CopyEgressOutputToCanonical(outputLocation, sinkAccountID, canonicalProviderID, contextUser);
   if (!canonicalKey.Success) {
     return { Success: false, ErrorMessage: canonicalKey.ErrorMessage, ProviderID: '', ProviderKey: '' };
   }
@@ -338,7 +362,7 @@ interface CanonicalCopyResult {
  * into Box" option). Reads the bytes via the sink driver's `GetObject({ fullPath })` and re-uploads them
  * into the canonical provider via `FileStorageEngine.UploadFile`. Returns the canonical `ProviderKey`.
  */
-export async function copyEgressOutputToCanonical(
+export async function CopyEgressOutputToCanonical(
   outputLocation: string,
   sinkAccountID: string,
   canonicalProviderID: string,
@@ -369,6 +393,16 @@ export async function copyEgressOutputToCanonical(
   return { Success: true, ProviderKey: uploaded.StoragePath };
 }
 
+/** @deprecated Use {@link CopyEgressOutputToCanonical}. */
+export async function copyEgressOutputToCanonical(
+  outputLocation: string,
+  sinkAccountID: string,
+  canonicalProviderID: string,
+  contextUser: UserInfo,
+): Promise<CanonicalCopyResult> {
+  return CopyEgressOutputToCanonical(outputLocation, sinkAccountID, canonicalProviderID, contextUser);
+}
+
 /** Creates the `MJ: Files` row pointing at the recording (no byte copy in the default v1 path). */
 async function createRecordingFileRow(
   egress: MeetingRecordingEgressResult,

package/src/resolvers/peaksSidecar.ts

@@ -15,7 +15,7 @@
  * @example deriveSidecarPath('realtime-recordings/sess-1/recording.wav') === 'realtime-recordings/sess-1/peaks.json'
  * @example deriveSidecarPath('recording.wav') === 'peaks.json'
  */
-export function deriveSidecarPath(providerKey: string | null | undefined): string | null {
+export function DeriveSidecarPath(providerKey: string | null | undefined): string | null {
     if (!providerKey) {
         return null;
     }
@@ -23,6 +23,11 @@ export function deriveSidecarPath(providerKey: string | null | undefined): strin
     return lastSlash >= 0 ? `${providerKey.slice(0, lastSlash)}/peaks.json` : 'peaks.json';
 }
 
+/** @deprecated Use {@link DeriveSidecarPath}. */
+export function deriveSidecarPath(providerKey: string | null | undefined): string | null {
+    return DeriveSidecarPath(providerKey);
+}
+
 /** Generous ceiling on the number of peaks returned — matches the capture-side cap. */
 export const MAX_PEAKS = 4096;
 
@@ -35,7 +40,7 @@ export const MAX_PEAKS = 4096;
  * @param bytes The raw sidecar bytes (e.g. from a storage `GetObject`).
  * @returns Sanitized `0..1` peaks, or `undefined`.
  */
-export function parsePeaksSidecar(bytes: Buffer): number[] | undefined {
+export function ParsePeaksSidecar(bytes: Buffer): number[] | undefined {
     try {
         const parsed: unknown = JSON.parse(bytes.toString('utf8'));
         if (!Array.isArray(parsed) || parsed.length === 0) {
@@ -50,3 +55,8 @@ export function parsePeaksSidecar(bytes: Buffer): number[] | undefined {
         return undefined;
     }
 }
+
+/** @deprecated Use {@link ParsePeaksSidecar}. */
+export function parsePeaksSidecar(bytes: Buffer): number[] | undefined {
+    return ParsePeaksSidecar(bytes);
+}

package/src/rest/EntityCRUDHandler.ts

@@ -11,7 +11,7 @@ export class EntityCRUDHandler {
     /**
      * Create a new entity
      */
-    static async createEntity(entityName: string, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
+    static async CreateEntity(entityName: string, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
         try {
             // Get entity object
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -77,11 +77,16 @@ export class EntityCRUDHandler {
             return { success: false, error: error?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link CreateEntity}. */
+    static async createEntity(entityName: string, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
+        return this.CreateEntity(entityName, data, user);
+    }
     
     /**
      * Read an entity by ID
      */
-    static async getEntity(entityName: string, id: string | number, relatedEntities: string[] = null, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string }> {
+    static async GetEntity(entityName: string, id: string | number, relatedEntities: string[] = null, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string }> {
         try {
             // Get entity object
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -116,11 +121,16 @@ export class EntityCRUDHandler {
             return { success: false, error: error?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link GetEntity}. */
+    static async getEntity(entityName: string, id: string | number, relatedEntities: string[] = null, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string }> {
+        return this.GetEntity(entityName, id, relatedEntities, user);
+    }
     
     /**
      * Update an existing entity
      */
-    static async updateEntity(entityName: string, id: string | number, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
+    static async UpdateEntity(entityName: string, id: string | number, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
         try {
             // Get entity object
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -203,11 +213,16 @@ export class EntityCRUDHandler {
             return { success: false, error: error?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link UpdateEntity}. */
+    static async updateEntity(entityName: string, id: string | number, data: any, user: UserInfo): Promise<{ success: boolean, entity?: any, error?: string, details?: any, validationErrors?: any[] }> {
+        return this.UpdateEntity(entityName, id, data, user);
+    }
     
     /**
      * Delete an entity
      */
-    static async deleteEntity(entityName: string, id: string | number, options: EntityDeleteOptions, user: UserInfo): Promise<{ success: boolean, error?: string, details?: any }> {
+    static async DeleteEntity(entityName: string, id: string | number, options: EntityDeleteOptions, user: UserInfo): Promise<{ success: boolean, error?: string, details?: any }> {
         try {
             // Get entity object
             const md = new Metadata(); // global-provider-ok: REST endpoint — no per-request provider injection in REST middleware yet
@@ -252,6 +267,11 @@ export class EntityCRUDHandler {
             return { success: false, error: error?.message || 'Unknown error' };
         }
     }
+
+    /** @deprecated Use {@link DeleteEntity}. */
+    static async deleteEntity(entityName: string, id: string | number, options: EntityDeleteOptions, user: UserInfo): Promise<{ success: boolean, error?: string, details?: any }> {
+        return this.DeleteEntity(entityName, id, options, user);
+    }
     
     /**
      * Build the record key from the `:id` path segment. A single-column key (any column name) is