@striae-org/striae 4.2.1 → 4.3.0

package/app/types/annotations.ts

@@ -22,19 +22,66 @@ export interface ConfirmationData {
   confirmedAt: string;        // ISO timestamp of confirmation
 }
 
+export interface BulletAnnotationData {
+  caliber?: string;
+  mass?: string;
+  diameter?: string;
+  calcDiameter?: string;
+  lgNumber?: number;
+  lgDirection?: string;
+  barrelType?: string;
+  // Width arrays should align with lgNumber:
+  // L1..Ln stored in order at lWidths[0..n-1], G1..Gn at gWidths[0..n-1].
+  lWidths?: string[];
+  gWidths?: string[];
+  jacketMetal?: string;
+  coreMetal?: string;
+  bulletType?: string;
+}
+
+export interface CartridgeCaseAnnotationData {
+  caliber?: string;
+  brand?: string;
+  metal?: string;
+  primerType?: string;
+  fpiShape?: string;
+  apertureShape?: string;
+  hasFpDrag?: boolean;
+  hasExtractorMarks?: boolean;
+  hasEjectorMarks?: boolean;
+  hasChamberMarks?: boolean;
+  hasMagazineLipMarks?: boolean;
+  hasPrimerShear?: boolean;
+  hasEjectionPortMarks?: boolean;
+}
+
+export interface ShotshellAnnotationData {
+  gauge?: string;
+  shotSize?: string;
+  metal?: string;
+  brand?: string;
+  fpiShape?: string;
+  hasExtractorMarks?: boolean;
+  hasEjectorMarks?: boolean;
+  hasChamberMarks?: boolean;
+}
+
 export interface AnnotationData {
   leftCase: string;
   rightCase: string;
   leftItem: string;
   rightItem: string;
   caseFontColor?: string;
-  classType?: 'Bullet' | 'Cartridge Case' | 'Other';
+  classType?: 'Bullet' | 'Cartridge Case' | 'Shotshell' | 'Other';
   customClass?: string;
   classNote?: string;
   indexType?: 'number' | 'color';
   indexNumber?: string;
   indexColor?: string;
   supportLevel?: 'ID' | 'Exclusion' | 'Inconclusive';
+  bulletData?: BulletAnnotationData;
+  cartridgeCaseData?: CartridgeCaseAnnotationData;
+  shotshellData?: ShotshellAnnotationData;
   hasSubclass?: boolean;
   includeConfirmation: boolean;
   confirmationData?: ConfirmationData;

package/app/utils/data/case-filters.ts

@@ -0,0 +1,127 @@
+export type CasesModalSortBy = 'recent' | 'alphabetical';
+
+export type CasesModalConfirmationFilter =
+  | 'all'
+  | 'pending'
+  | 'confirmed'
+  | 'none-requested';
+
+export interface CasesModalPreferences {
+  sortBy: CasesModalSortBy;
+  confirmationFilter: CasesModalConfirmationFilter;
+  showArchivedOnly: boolean;
+}
+
+export interface CasesModalCaseItem {
+  caseNumber: string;
+  createdAt: string;
+  archived: boolean;
+  isReadOnly: boolean;
+}
+
+export interface CaseConfirmationStatusValue {
+  includeConfirmation: boolean;
+  isConfirmed: boolean;
+}
+
+const DEFAULT_CASE_CONFIRMATION_STATUS: CaseConfirmationStatusValue = {
+  includeConfirmation: false,
+  isConfirmed: false,
+};
+
+function compareCaseNumbersAlphabetically(a: string, b: string): number {
+  const getComponents = (value: string) => {
+    const numbers = value.match(/\d+/g)?.map(Number) || [];
+    const letters = value.match(/[A-Za-z]+/g)?.join('') || '';
+    return { numbers, letters };
+  };
+
+  const left = getComponents(a);
+  const right = getComponents(b);
+
+  const maxLength = Math.max(left.numbers.length, right.numbers.length);
+  for (let index = 0; index < maxLength; index += 1) {
+    const leftNumber = left.numbers[index] || 0;
+    const rightNumber = right.numbers[index] || 0;
+
+    if (leftNumber !== rightNumber) {
+      return leftNumber - rightNumber;
+    }
+  }
+
+  return left.letters.localeCompare(right.letters);
+}
+
+function parseTimestamp(value: string): number {
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+
+function matchesConfirmationFilter(
+  caseNumber: string,
+  confirmationFilter: CasesModalConfirmationFilter,
+  caseConfirmationStatus: Record<string, CaseConfirmationStatusValue>
+): boolean {
+  if (confirmationFilter === 'all') {
+    return true;
+  }
+
+  const status = caseConfirmationStatus[caseNumber] || DEFAULT_CASE_CONFIRMATION_STATUS;
+
+  if (confirmationFilter === 'pending') {
+    return status.includeConfirmation && !status.isConfirmed;
+  }
+
+  if (confirmationFilter === 'confirmed') {
+    return status.includeConfirmation && status.isConfirmed;
+  }
+
+  return !status.includeConfirmation;
+}
+
+export function filterCasesForModal(
+  cases: CasesModalCaseItem[],
+  preferences: CasesModalPreferences,
+  caseConfirmationStatus: Record<string, CaseConfirmationStatusValue>
+): CasesModalCaseItem[] {
+  const archiveFilteredCases = preferences.showArchivedOnly
+    ? cases.filter((entry) => entry.archived && !entry.isReadOnly)
+    : cases.filter((entry) => !entry.archived && !entry.isReadOnly);
+
+  return archiveFilteredCases.filter((entry) =>
+    matchesConfirmationFilter(entry.caseNumber, preferences.confirmationFilter, caseConfirmationStatus)
+  );
+}
+
+export function sortCasesForModal(
+  cases: CasesModalCaseItem[],
+  sortBy: CasesModalSortBy
+): CasesModalCaseItem[] {
+  const next = [...cases];
+
+  if (sortBy === 'recent') {
+    return next.sort((left, right) => {
+      const difference = parseTimestamp(right.createdAt) - parseTimestamp(left.createdAt);
+      if (difference !== 0) {
+        return difference;
+      }
+
+      return compareCaseNumbersAlphabetically(left.caseNumber, right.caseNumber);
+    });
+  }
+
+  return next.sort((left, right) =>
+    compareCaseNumbersAlphabetically(left.caseNumber, right.caseNumber)
+  );
+}
+
+export function getCasesForModal(
+  cases: CasesModalCaseItem[],
+  preferences: CasesModalPreferences,
+  caseConfirmationStatus: Record<string, CaseConfirmationStatusValue>
+): CasesModalCaseItem[] {
+  return sortCasesForModal(
+    filterCasesForModal(cases, preferences, caseConfirmationStatus),
+    preferences.sortBy
+  );
+}

package/app/utils/data/confirmation-summary/summary-core.ts

@@ -5,6 +5,7 @@ export interface FileConfirmationSummary {
   includeConfirmation: boolean;
   isConfirmed: boolean;
   updatedAt: string;
+  classType?: 'Bullet' | 'Cartridge Case' | 'Shotshell' | 'Other';
 }
 
 export interface CaseConfirmationSummary {
@@ -194,11 +195,20 @@ function normalizeFileConfirmationSummary(value: unknown): FileConfirmationSumma
     };
   }
 
-  return {
+  const classType = value.classType;
+  const normalizedClassType = typeof classType === 'string' && ['Bullet', 'Cartridge Case', 'Shotshell', 'Other'].includes(classType) ? (classType as 'Bullet' | 'Cartridge Case' | 'Shotshell' | 'Other') : undefined;
+
+  const summary: FileConfirmationSummary = {
     includeConfirmation: value.includeConfirmation === true,
     isConfirmed: value.isConfirmed === true,
     updatedAt: typeof value.updatedAt === 'string' && value.updatedAt.length > 0 ? value.updatedAt : getIsoNow()
   };
+
+  if (normalizedClassType) {
+    summary.classType = normalizedClassType;
+  }
+
+  return summary;
 }
 
 export function isStaleTimestamp(timestamp: string, maxAgeMs: number): boolean {
@@ -228,11 +238,17 @@ export function computeCaseConfirmationAggregate(filesById: Record<string, FileC
 export function toFileConfirmationSummary(annotationData: AnnotationData | null): FileConfirmationSummary {
   const includeConfirmation = annotationData?.includeConfirmation === true;
 
-  return {
+  const summary: FileConfirmationSummary = {
     includeConfirmation,
     isConfirmed: includeConfirmation && !!annotationData?.confirmationData,
     updatedAt: getIsoNow()
   };
+
+  if (annotationData?.classType) {
+    summary.classType = annotationData.classType;
+  }
+
+  return summary;
 }
 
 export function normalizeConfirmationSummaryDocument(payload: unknown): UserConfirmationSummaryDocument {

package/app/utils/data/file-filters.ts

@@ -0,0 +1,201 @@
+import type { FileData } from '~/types';
+import type { FileConfirmationSummary } from '~/utils/data';
+
+export type FilesModalSortBy = 'recent' | 'filename' | 'confirmation' | 'classType';
+
+export type FilesModalConfirmationFilter =
+  | 'all'
+  | 'pending'
+  | 'confirmed'
+  | 'none-requested';
+
+export type FilesModalClassTypeFilter =
+  | 'all'
+  | 'Bullet'
+  | 'Cartridge Case'
+  | 'Shotshell'
+  | 'Other';
+
+export interface FilesModalPreferences {
+  sortBy: FilesModalSortBy;
+  confirmationFilter: FilesModalConfirmationFilter;
+  classTypeFilter: FilesModalClassTypeFilter;
+}
+
+export type FileConfirmationById = Record<string, FileConfirmationSummary>;
+
+const DEFAULT_CONFIRMATION_SUMMARY: FileConfirmationSummary = {
+  includeConfirmation: false,
+  isConfirmed: false,
+  updatedAt: '',
+};
+
+function getFileConfirmationState(fileId: string, statusById: FileConfirmationById): FileConfirmationSummary {
+  return statusById[fileId] || DEFAULT_CONFIRMATION_SUMMARY;
+}
+
+function getConfirmationRank(summary: FileConfirmationSummary): number {
+  if (summary.includeConfirmation && !summary.isConfirmed) {
+    return 0;
+  }
+
+  if (summary.includeConfirmation && summary.isConfirmed) {
+    return 1;
+  }
+
+  return 2;
+}
+
+function getClassTypeRank(classType: FileConfirmationSummary['classType']): number {
+  if (classType === 'Bullet') {
+    return 0;
+  }
+
+  if (classType === 'Cartridge Case') {
+    return 1;
+  }
+
+  if (classType === 'Shotshell') {
+    return 2;
+  }
+
+  if (classType === 'Other') {
+    return 3;
+  }
+
+  return 4;
+}
+
+function parseTimestamp(value: string): number {
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+
+function matchesConfirmationFilter(
+  summary: FileConfirmationSummary,
+  confirmationFilter: FilesModalConfirmationFilter
+): boolean {
+  if (confirmationFilter === 'all') {
+    return true;
+  }
+
+  if (confirmationFilter === 'pending') {
+    return summary.includeConfirmation && !summary.isConfirmed;
+  }
+
+  if (confirmationFilter === 'confirmed') {
+    return summary.includeConfirmation && summary.isConfirmed;
+  }
+
+  return !summary.includeConfirmation;
+}
+
+function matchesClassTypeFilter(
+  summary: FileConfirmationSummary,
+  classTypeFilter: FilesModalClassTypeFilter
+): boolean {
+  if (classTypeFilter === 'all') {
+    return true;
+  }
+
+  if (classTypeFilter === 'Other') {
+    // Treat legacy/unset class types as Other for filtering.
+    return summary.classType === 'Other' || !summary.classType;
+  }
+
+  return summary.classType === classTypeFilter;
+}
+
+function matchesSearch(file: FileData, query: string): boolean {
+  const normalized = query.trim().toLowerCase();
+  if (!normalized) {
+    return true;
+  }
+
+  return file.originalFilename.toLowerCase().includes(normalized);
+}
+
+export function filterFilesForModal(
+  files: FileData[],
+  preferences: FilesModalPreferences,
+  statusById: FileConfirmationById,
+  searchQuery: string
+): FileData[] {
+  return files.filter((file) => {
+    const summary = getFileConfirmationState(file.id, statusById);
+
+    return (
+      matchesSearch(file, searchQuery) &&
+      matchesConfirmationFilter(summary, preferences.confirmationFilter) &&
+      matchesClassTypeFilter(summary, preferences.classTypeFilter)
+    );
+  });
+}
+
+function compareFileNames(a: string, b: string): number {
+  return a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' });
+}
+
+export function sortFilesForModal(
+  files: FileData[],
+  sortBy: FilesModalSortBy,
+  statusById: FileConfirmationById
+): FileData[] {
+  const next = [...files];
+
+  if (sortBy === 'recent') {
+    return next.sort((left, right) => {
+      const difference = parseTimestamp(right.uploadedAt) - parseTimestamp(left.uploadedAt);
+      if (difference !== 0) {
+        return difference;
+      }
+
+      return compareFileNames(left.originalFilename, right.originalFilename);
+    });
+  }
+
+  if (sortBy === 'filename') {
+    return next.sort((left, right) =>
+      compareFileNames(left.originalFilename, right.originalFilename)
+    );
+  }
+
+  if (sortBy === 'confirmation') {
+    return next.sort((left, right) => {
+      const leftSummary = getFileConfirmationState(left.id, statusById);
+      const rightSummary = getFileConfirmationState(right.id, statusById);
+      const difference = getConfirmationRank(leftSummary) - getConfirmationRank(rightSummary);
+
+      if (difference !== 0) {
+        return difference;
+      }
+
+      return compareFileNames(left.originalFilename, right.originalFilename);
+    });
+  }
+
+  return next.sort((left, right) => {
+    const leftSummary = getFileConfirmationState(left.id, statusById);
+    const rightSummary = getFileConfirmationState(right.id, statusById);
+    const difference = getClassTypeRank(leftSummary.classType) - getClassTypeRank(rightSummary.classType);
+
+    if (difference !== 0) {
+      return difference;
+    }
+
+    return compareFileNames(left.originalFilename, right.originalFilename);
+  });
+}
+
+export function getFilesForModal(
+  files: FileData[],
+  preferences: FilesModalPreferences,
+  statusById: FileConfirmationById,
+  searchQuery: string
+): FileData[] {
+  return sortFilesForModal(
+    filterFilesForModal(files, preferences, statusById, searchQuery),
+    preferences.sortBy,
+    statusById
+  );
+}

package/functions/api/image/[[path]].ts

@@ -53,6 +53,10 @@ function extractProxyPath(url: URL): ProxyPathResult {
 
   try {
     const decodedPath = decodeURIComponent(encodedPath);
+    if (decodedPath.includes('?') || decodedPath.includes('#')) {
+      return { ok: false, reason: 'bad-encoding' };
+    }
+
     return { ok: true, path: decodedPath.startsWith('/') ? decodedPath : `/${decodedPath}` };
   } catch {
     return { ok: false, reason: 'bad-encoding' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@striae-org/striae",
-  "version": "4.2.1",
+  "version": "4.3.0",
   "private": false,
   "description": "Striae is a specialized, cloud-native platform designed to streamline forensic firearms identification by providing an intuitive environment for digital comparison image annotation, authenticated confirmations, and automated report generation.",
   "license": "Apache-2.0",
@@ -54,10 +54,9 @@
     "workers/*/src/*.example.ts",
     "workers/*/src/*.example.js",
     "workers/*/src/*.ts",
-    "workers/pdf-worker/scripts/*.js",
-    "workers/pdf-worker/src/assets/icon-256.png",
+    "workers/pdf-worker/scripts/*.js",    
     "!workers/*/src/*worker.ts",
-    "workers/pdf-worker/src/assets/generated-assets.ts",
+    "workers/pdf-worker/src/assets/generated-assets.example.ts",
     "workers/pdf-worker/src/formats/format-striae.ts",
     "workers/pdf-worker/src/report-types.ts",
     "workers/*/wrangler.jsonc.example",

package/workers/audit-worker/wrangler.jsonc.example

@@ -2,7 +2,7 @@
   "name": "AUDIT_WORKER_NAME",
   "account_id": "ACCOUNT_ID",
   "main": "src/audit-worker.ts",
-  "compatibility_date": "2026-03-21",
+  "compatibility_date": "2026-03-22",
   "compatibility_flags": [
     "nodejs_compat"
   ], 

package/workers/data-worker/wrangler.jsonc.example

@@ -3,7 +3,7 @@
   "name": "DATA_WORKER_NAME",
   "account_id": "ACCOUNT_ID",
   "main": "src/data-worker.ts",
-  "compatibility_date": "2026-03-21",
+  "compatibility_date": "2026-03-22",
   "compatibility_flags": [
     "nodejs_compat"
   ], 

package/workers/image-worker/wrangler.jsonc.example

@@ -2,7 +2,7 @@
   "name": "IMAGES_WORKER_NAME",
   "account_id": "ACCOUNT_ID",
   "main": "src/image-worker.ts",
-  "compatibility_date": "2026-03-21",
+  "compatibility_date": "2026-03-22",
   "compatibility_flags": [
     "nodejs_compat"
   ], 

package/workers/keys-worker/wrangler.jsonc.example

@@ -2,7 +2,7 @@
   "name": "KEYS_WORKER_NAME",
   "account_id": "ACCOUNT_ID",
   "main": "src/keys.ts",
-  "compatibility_date": "2026-03-21",
+  "compatibility_date": "2026-03-22",
   "compatibility_flags": [
     "nodejs_compat"
   ],