@surveilr/bootstrap-sql 0.0.3 → 0.0.4

package/dist/index.js

@@ -1,118 +1,2027 @@
+// ../../drizzle/models.ts
 import {
-  codeNotebookCellLatest,
-  codeNotebookCellVersions,
-  codeNotebookMigrationSql,
-  codeNotebookSqlCellMigratable,
-  codeNotebookSqlCellMigratableNotExecuted,
-  codeNotebookSqlCellMigratableState,
-  codeNotebookSqlCellMigratableVersion,
-  consoleContentTabular,
-  consoleInformationSchemaTable,
-  consoleInformationSchemaTableColFkey,
-  consoleInformationSchemaTableColIndex,
-  consoleInformationSchemaView,
-  deviceGraphAnalytics,
-  deviceGraphCorrelations,
-  deviceGraphOverview,
-  emailMessagesWithTimezone,
-  filesystemGraph,
-  imapGraph,
-  networkDeviceTopology,
-  orchestrationExecutionSuccessRateByType,
-  orchestrationExecutionsByType,
-  orchestrationIssueRemediation,
-  orchestrationLogsBySession,
-  orchestrationSessionByDevice,
-  orchestrationSessionDuration,
-  orchestrationSessionScript,
-  orchestrationSessionSummary,
-  orchestrationSuccessRate,
-  rssdStatisticsOverview,
-  rssdTableStatistic,
-  snmpCollectionSummary,
-  snmpDeviceInventory,
-  snmpOidPerformance,
-  uniformResourceFile,
-  uniformResourceImap,
-  uniformResourceImapContent,
-  urIngestSessionFileIssue,
-  urIngestSessionFilesStats,
-  urIngestSessionFilesStatsLatest,
-  urIngestSessionTasksStats,
-  urIngestSessionTasksStatsLatest
-} from "./chunk-QTY32BJY.js";
-import {
-  assuranceSchema,
-  behavior,
-  checkJSON,
-  codeNotebookCell,
-  codeNotebookKernel,
-  codeNotebookState,
-  device,
-  devicePartyRelationship,
-  genderType,
-  housekeeping,
-  orchestrationNature,
-  orchestrationSession,
-  orchestrationSessionEntry,
-  orchestrationSessionExec,
-  orchestrationSessionIssue,
-  orchestrationSessionIssueRelation,
-  orchestrationSessionLog,
-  orchestrationSessionState,
-  organization,
-  organizationRole,
-  organizationRoleType,
-  osqueryPolicy,
-  party,
-  partyRelation,
-  partyRelationType,
-  partyType,
-  person,
-  personType,
-  sexType,
-  sqleanDefine,
-  sqlpageAideNavigation,
-  sqlpageFiles,
-  surveilrFunctionDoc,
-  surveilrOsqueryMsCarve,
-  surveilrOsqueryMsCarvedExtractedFile,
-  surveilrOsqueryMsDistributedQuery,
-  surveilrOsqueryMsDistributedResult,
-  surveilrOsqueryMsNode,
-  surveilrSnmpCollection,
-  surveilrSnmpDevice,
-  surveilrTableSize,
-  uniformResource,
-  uniformResourceEdge,
-  uniformResourceGraph,
-  uniformResourceTransform,
-  urIngestResourcePathMatchRule,
-  urIngestResourcePathRewriteRule,
-  urIngestSession,
-  urIngestSessionAttachment,
-  urIngestSessionFsPath,
-  urIngestSessionFsPathEntry,
-  urIngestSessionImapAccount,
-  urIngestSessionImapAcctFolder,
-  urIngestSessionImapAcctFolderMessage,
-  urIngestSessionOsqueryMsLog,
-  urIngestSessionPlmAccount,
-  urIngestSessionPlmAcctLabel,
-  urIngestSessionPlmAcctProject,
-  urIngestSessionPlmAcctProjectIssue,
-  urIngestSessionPlmAcctRelationship,
-  urIngestSessionPlmComment,
-  urIngestSessionPlmIssueReaction,
-  urIngestSessionPlmIssueType,
-  urIngestSessionPlmMilestone,
-  urIngestSessionPlmReaction,
-  urIngestSessionPlmUser,
-  urIngestSessionTask,
-  urIngestSessionUdiPgpSql
-} from "./chunk-HZLAQ5XF.js";
+  blob,
+  check,
+  customType,
+  foreignKey,
+  index,
+  integer,
+  numeric,
+  real,
+  sqliteTable as table,
+  text,
+  unique
+} from "drizzle-orm/sqlite-core";
+import { sql } from "drizzle-orm";
+var timestamptz = customType({
+  dataType() {
+    return "TIMESTAMPTZ";
+  },
+  fromDriver(value) {
+    return value;
+  },
+  toDriver(value) {
+    return value;
+  }
+});
+var date = customType({
+  dataType() {
+    return "DATE";
+  },
+  fromDriver(value) {
+    return value;
+  },
+  toDriver(value) {
+    return value;
+  }
+});
+var ulid = customType({
+  dataType() {
+    return "ULID";
+  },
+  fromDriver(value) {
+    return value;
+  },
+  toDriver(value) {
+    return value;
+  }
+});
+var varchar = customType({
+  dataType() {
+    return "VARCHAR";
+  },
+  fromDriver(value) {
+    return value;
+  },
+  toDriver(value) {
+    return value;
+  }
+});
+var textArray = customType({
+  dataType() {
+    return "TEXT[]";
+  },
+  fromDriver(value) {
+    return JSON.parse(value);
+  },
+  toDriver(value) {
+    return JSON.stringify(value);
+  }
+});
+var housekeeping = {
+  createdAt: timestamptz("created_at").default(sql`CURRENT_TIMESTAMP`),
+  createdBy: text("created_by").default("UNKNOWN"),
+  updatedAt: timestamptz("updated_at"),
+  updatedBy: text("updated_by"),
+  deletedAt: timestamptz("deleted_at"),
+  deletedBy: text("deleted_by"),
+  activityLog: text("activity_log")
+};
+var sqleanDefine = table("sqlean_define", {
+  name: text().primaryKey(),
+  type: text(),
+  body: text()
+}, (table2) => []);
+var checkJSON = (c) => check(`${c.name}_check_valid_json`, sql`json_valid(${c}) OR ${c} IS NULL`);
+var assuranceSchema = table("assurance_schema", {
+  assuranceSchemaId: varchar("assurance_schema_id").primaryKey().notNull(),
+  assuranceType: text("assurance_type").notNull(),
+  code: text().notNull(),
+  codeJson: text("code_json", { mode: "json" }),
+  governance: text(),
+  ...housekeeping
+}, (table2) => [
+  checkJSON(table2.codeJson),
+  checkJSON(table2.governance)
+]);
+var device = table("device", {
+  deviceId: varchar("device_id").primaryKey().notNull(),
+  name: text().notNull(),
+  state: text().notNull(),
+  boundary: text().notNull(),
+  segmentation: text(),
+  stateSysinfo: text("state_sysinfo"),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  index("idx_device__name__state").on(table2.name, table2.state),
+  unique().on(table2.name, table2.state, table2.boundary),
+  checkJSON(table2.state),
+  checkJSON(table2.segmentation),
+  checkJSON(table2.stateSysinfo),
+  checkJSON(table2.elaboration)
+]);
+var codeNotebookKernel = table("code_notebook_kernel", {
+  codeNotebookKernelId: varchar("code_notebook_kernel_id").primaryKey().notNull(),
+  kernelName: text("kernel_name").notNull(),
+  description: text(),
+  mimeType: text("mime_type"),
+  fileExtn: text("file_extn"),
+  elaboration: text(),
+  governance: text(),
+  ...housekeeping
+}, (table2) => [
+  unique().on(table2.kernelName),
+  checkJSON(table2.elaboration),
+  checkJSON(table2.governance)
+]);
+var codeNotebookCell = table("code_notebook_cell", {
+  codeNotebookCellId: varchar("code_notebook_cell_id").primaryKey().notNull(),
+  notebookKernelId: varchar("notebook_kernel_id").notNull().references(
+    () => codeNotebookKernel.codeNotebookKernelId
+  ),
+  notebookName: text("notebook_name").notNull(),
+  cellName: text("cell_name").notNull(),
+  cellGovernance: text("cell_governance"),
+  interpretableCode: text("interpretable_code").notNull(),
+  interpretableCodeHash: text("interpretable_code_hash").notNull(),
+  description: text(),
+  arguments: text(),
+  ...housekeeping
+}, (table2) => [
+  unique().on(table2.notebookName, table2.cellName, table2.interpretableCodeHash),
+  checkJSON(table2.cellGovernance),
+  checkJSON(table2.arguments)
+]);
+var codeNotebookState = table("code_notebook_state", {
+  codeNotebookStateId: varchar("code_notebook_state_id").primaryKey().notNull(),
+  codeNotebookCellId: varchar("code_notebook_cell_id").notNull().references(
+    () => codeNotebookCell.codeNotebookCellId
+  ),
+  fromState: text("from_state").notNull(),
+  toState: text("to_state").notNull(),
+  transitionResult: text("transition_result"),
+  transitionReason: text("transition_reason"),
+  transitionedAt: timestamptz("transitioned_at"),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  unique().on(table2.codeNotebookCellId, table2.fromState, table2.toState),
+  checkJSON(table2.transitionResult),
+  checkJSON(table2.elaboration)
+]);
+var sqlpageFiles = table("sqlpage_files", {
+  path: text().primaryKey().notNull(),
+  contents: text().notNull(),
+  lastModified: numeric("last_modified").default(sql`(CURRENT_TIMESTAMP)`)
+}, (table2) => []);
+var surveilrTableSize = table("surveilr_table_size", {
+  tableName: text("table_name").primaryKey(),
+  tableSizeMb: real("table_size_mb")
+}, (table2) => []);
+var sqlpageAideNavigation = table("sqlpage_aide_navigation", {
+  path: text().notNull(),
+  caption: text().notNull(),
+  namespace: text().notNull(),
+  parentPath: text("parent_path"),
+  siblingOrder: integer("sibling_order"),
+  url: text(),
+  title: text(),
+  abbreviatedCaption: text("abbreviated_caption"),
+  description: text(),
+  elaboration: text()
+}, (table2) => [
+  unique("unq_ns_path").on(table2.namespace, table2.parentPath, table2.path)
+]);
+var partyType = table("party_type", {
+  partyTypeId: ulid("party_type_id").primaryKey().notNull(),
+  code: text().notNull(),
+  value: text().notNull(),
+  ...housekeeping
+}, (table2) => [
+  unique("unq_party_type_code").on(table2.code)
+]);
+var party = table("party", {
+  partyId: varchar("party_id").primaryKey().notNull(),
+  partyTypeId: ulid("party_type_id").notNull().references(
+    () => partyType.partyTypeId
+  ).$type(),
+  // ULID
+  partyName: text("party_name").notNull(),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  index("idx_party__party_type_id__party_name").on(
+    table2.partyTypeId,
+    table2.partyName
+  )
+]);
+var partyRelationType = table("party_relation_type", {
+  partyRelationTypeId: text("party_relation_type_id").primaryKey().notNull().$type(),
+  // ULID
+  code: text().notNull(),
+  value: text().notNull(),
+  ...housekeeping
+}, (table2) => [
+  unique().on(table2.code)
+]);
+var partyRelation = table("party_relation", {
+  partyRelationId: varchar("party_relation_id").primaryKey().notNull(),
+  partyId: text("party_id").notNull().references(() => party.partyId),
+  relatedPartyId: text("related_party_id").notNull().references(
+    () => party.partyId
+  ),
+  relationTypeId: text("relation_type_id").notNull().references(
+    () => partyRelationType.partyRelationTypeId
+  ).$type(),
+  // ULID
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  index("idx_party_relation__party_id__related_party_id__relation_type_id").on(
+    table2.partyId,
+    table2.relatedPartyId,
+    table2.relationTypeId
+  ),
+  unique().on(table2.partyId, table2.relatedPartyId, table2.relationTypeId),
+  checkJSON(table2.elaboration)
+]);
+var genderType = table("gender_type", {
+  genderTypeId: ulid("gender_type_id").primaryKey().notNull(),
+  code: text().notNull(),
+  value: text().notNull(),
+  ...housekeeping
+}, (table2) => [
+  unique().on(table2.code)
+]);
+var sexType = table("sex_type", {
+  sexTypeId: ulid("sex_type_id").primaryKey().notNull(),
+  code: text().notNull(),
+  value: text().notNull(),
+  ...housekeeping
+}, (table2) => [
+  unique().on(table2.code)
+]);
+var personType = table("person_type", {
+  personTypeId: ulid("person_type_id").primaryKey().notNull(),
+  code: text().notNull(),
+  value: text().notNull(),
+  ...housekeeping
+}, (table2) => [
+  unique().on(table2.code)
+]);
+var person = table("person", {
+  personId: ulid("person_id").primaryKey().notNull(),
+  partyId: text("party_id").notNull().references(() => party.partyId),
+  personTypeId: ulid("person_type_id").notNull().references(
+    () => personType.personTypeId
+  ),
+  personFirstName: text("person_first_name").notNull(),
+  personMiddleName: text("person_middle_name"),
+  personLastName: text("person_last_name").notNull(),
+  previousName: text("previous_name"),
+  honorificPrefix: text("honorific_prefix"),
+  honorificSuffix: text("honorific_suffix"),
+  genderId: ulid("gender_id").notNull().references(
+    () => genderType.genderTypeId
+  ),
+  sexId: ulid("sex_id").notNull().references(() => sexType.sexTypeId),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  checkJSON(table2.elaboration)
+]);
+var organization = table("organization", {
+  organizationId: ulid("organization_id").primaryKey().notNull(),
+  partyId: text("party_id").notNull().references(() => party.partyId),
+  name: text().notNull(),
+  alias: text(),
+  description: text(),
+  license: text().notNull(),
+  federalTaxIdNum: text("federal_tax_id_num"),
+  registrationDate: date("registration_date").notNull(),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  checkJSON(table2.elaboration)
+]);
+var organizationRoleType = table("organization_role_type", {
+  organizationRoleTypeId: ulid("organization_role_type_id").primaryKey().notNull(),
+  code: text().notNull(),
+  value: text().notNull(),
+  ...housekeeping
+}, (table2) => [
+  unique().on(table2.code)
+]);
+var organizationRole = table("organization_role", {
+  organizationRoleId: text("organization_role_id").primaryKey().notNull(),
+  personId: text("person_id").notNull().references(() => party.partyId),
+  organizationId: text("organization_id").notNull().references(
+    () => party.partyId
+  ),
+  organizationRoleTypeId: ulid("organization_role_type_id").notNull().references(() => organizationRoleType.organizationRoleTypeId),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  index(
+    "idx_organization_role__person_id__organization_id__organization_role_type_id"
+  ).on(table2.personId, table2.organizationId, table2.organizationRoleTypeId),
+  unique().on(table2.personId, table2.organizationId, table2.organizationRoleTypeId),
+  checkJSON(table2.elaboration)
+]);
+var devicePartyRelationship = table("device_party_relationship", {
+  devicePartyRelationshipId: text("device_party_relationship_id").primaryKey().notNull(),
+  deviceId: text("device_id").notNull().references(() => device.deviceId),
+  partyId: text("party_id").notNull().references(() => party.partyId),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  index("idx_device_party_relationship__device_id__party_id").on(
+    table2.deviceId,
+    table2.partyId
+  ),
+  unique().on(table2.deviceId, table2.partyId),
+  checkJSON(table2.elaboration)
+]);
+var behavior = table("behavior", {
+  behaviorId: varchar("behavior_id").primaryKey().notNull(),
+  deviceId: text("device_id").notNull(),
+  behaviorName: text("behavior_name").notNull(),
+  behaviorConfJson: text("behavior_conf_json").notNull(),
+  assuranceSchemaId: text("assurance_schema_id"),
+  governance: text(),
+  ...housekeeping
+}, (table2) => [
+  unique().on(table2.deviceId, table2.behaviorName),
+  checkJSON(table2.behaviorConfJson),
+  checkJSON(table2.governance)
+]);
+var urIngestResourcePathMatchRule = table(
+  "ur_ingest_resource_path_match_rule",
+  {
+    urIngestResourcePathMatchRuleId: text(
+      "ur_ingest_resource_path_match_rule_id"
+    ).primaryKey().notNull(),
+    namespace: text().notNull(),
+    regex: text().notNull(),
+    flags: text().notNull(),
+    nature: text(),
+    priority: text(),
+    description: text(),
+    includeGlobPatterns: textArray("include_glob_patterns"),
+    excludeGlobPatterns: textArray("exclude_glob_patterns"),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    checkJSON(table2.elaboration),
+    unique("unq_path_match_regex").on(table2.namespace, table2.regex)
+  ]
+);
+var urIngestResourcePathRewriteRule = table(
+  "ur_ingest_resource_path_rewrite_rule",
+  {
+    urIngestResourcePathRewriteRuleId: text(
+      "ur_ingest_resource_path_rewrite_rule_id"
+    ).primaryKey().notNull(),
+    namespace: text().notNull(),
+    regex: text().notNull(),
+    replace: text().notNull(),
+    priority: text(),
+    description: text(),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    unique().on(table2.namespace, table2.regex, table2.replace),
+    checkJSON(table2.elaboration)
+  ]
+);
+var urIngestSession = table("ur_ingest_session", {
+  urIngestSessionId: text("ur_ingest_session_id").primaryKey().notNull(),
+  deviceId: text("device_id").notNull().references(() => device.deviceId),
+  behaviorId: text("behavior_id").references(() => behavior.behaviorId),
+  behaviorJson: text("behavior_json"),
+  ingestStartedAt: timestamptz("ingest_started_at").notNull(),
+  ingestFinishedAt: timestamptz("ingest_finished_at"),
+  sessionAgent: text("session_agent").notNull(),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  unique().on(table2.deviceId, table2.createdAt),
+  checkJSON(table2.behaviorJson),
+  checkJSON(table2.sessionAgent),
+  checkJSON(table2.elaboration)
+]);
+var urIngestSessionFsPath = table("ur_ingest_session_fs_path", {
+  urIngestSessionFsPathId: text("ur_ingest_session_fs_path_id").primaryKey().notNull(),
+  ingestSessionId: text("ingest_session_id").notNull().references(
+    () => urIngestSession.urIngestSessionId
+  ),
+  rootPath: text("root_path").notNull(),
+  includeGlobPatterns: textArray("include_glob_patterns"),
+  excludeGlobPatterns: textArray("exclude_glob_patterns"),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  index("idx_ur_ingest_session_fs_path__ingest_session_id__root_path").on(
+    table2.ingestSessionId,
+    table2.rootPath
+  ),
+  unique().on(table2.ingestSessionId, table2.rootPath, table2.createdAt),
+  checkJSON(table2.elaboration)
+]);
+var uniformResource = table("uniform_resource", {
+  uniformResourceId: text("uniform_resource_id").primaryKey().notNull(),
+  deviceId: text("device_id").notNull().references(() => device.deviceId),
+  ingestSessionId: text("ingest_session_id").notNull().references(
+    () => urIngestSession.urIngestSessionId
+  ),
+  ingestFsPathId: text("ingest_fs_path_id").references(
+    () => urIngestSessionFsPath.urIngestSessionFsPathId
+  ),
+  ingestSessionImapAcctFolderMessage: text(
+    "ingest_session_imap_acct_folder_message"
+  ).references(
+    () => urIngestSessionImapAcctFolderMessage.urIngestSessionImapAcctFolderMessageId
+  ),
+  ingestIssueAcctProjectId: text("ingest_issue_acct_project_id").references(
+    () => urIngestSessionPlmAcctProject.urIngestSessionPlmAcctProjectId
+  ),
+  uri: text().notNull(),
+  contentDigest: text("content_digest").notNull(),
+  content: blob(),
+  nature: text(),
+  sizeBytes: integer("size_bytes"),
+  lastModifiedAt: timestamptz("last_modified_at"),
+  contentFmBodyAttrs: text("content_fm_body_attrs"),
+  frontmatter: text(),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  index("idx_uniform_resource__device_id__uri").on(table2.deviceId, table2.uri),
+  unique().on(table2.deviceId, table2.contentDigest, table2.uri, table2.sizeBytes),
+  checkJSON(table2.contentFmBodyAttrs),
+  checkJSON(table2.frontmatter),
+  checkJSON(table2.elaboration)
+]);
+var uniformResourceTransform = table("uniform_resource_transform", {
+  uniformResourceTransformId: text("uniform_resource_transform_id").primaryKey().notNull(),
+  uniformResourceId: text("uniform_resource_id").notNull().references(
+    () => uniformResource.uniformResourceId
+  ),
+  uri: text().notNull(),
+  contentDigest: text("content_digest").notNull(),
+  content: text(),
+  nature: text(),
+  sizeBytes: integer("size_bytes"),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  index("idx_uniform_resource_transform__uniform_resource_id__content_digest").on(table2.uniformResourceId, table2.contentDigest),
+  unique().on(table2.uniformResourceId, table2.contentDigest, table2.nature, table2.sizeBytes),
+  checkJSON(table2.elaboration)
+]);
+var urIngestSessionFsPathEntry = table(
+  "ur_ingest_session_fs_path_entry",
+  {
+    urIngestSessionFsPathEntryId: text("ur_ingest_session_fs_path_entry_id").primaryKey().notNull(),
+    ingestSessionId: text("ingest_session_id").notNull().references(
+      () => urIngestSession.urIngestSessionId
+    ),
+    ingestFsPathId: text("ingest_fs_path_id").notNull().references(
+      () => urIngestSessionFsPath.urIngestSessionFsPathId
+    ),
+    uniformResourceId: text("uniform_resource_id").references(
+      () => uniformResource.uniformResourceId
+    ),
+    filePathAbs: text("file_path_abs").notNull(),
+    filePathRelParent: text("file_path_rel_parent").notNull(),
+    filePathRel: text("file_path_rel").notNull(),
+    fileBasename: text("file_basename").notNull(),
+    fileExtn: text("file_extn"),
+    capturedExecutable: text("captured_executable"),
+    urStatus: text("ur_status"),
+    urDiagnostics: text("ur_diagnostics"),
+    urTransformations: text("ur_transformations"),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    index(
+      "idx_ur_ingest_session_fs_path_entry__ingest_session_id__file_path_abs"
+    ).on(table2.ingestSessionId, table2.filePathAbs),
+    unique(
+      "uq_ur_ingest_session_fs_path_entry__ingest_session_id__ingest_fs_path_id__file_path_abs"
+    ).on(table2.ingestSessionId, table2.ingestFsPathId, table2.filePathAbs),
+    checkJSON(table2.capturedExecutable),
+    checkJSON(table2.urDiagnostics),
+    checkJSON(table2.urTransformations),
+    checkJSON(table2.elaboration)
+  ]
+);
+var urIngestSessionTask = table("ur_ingest_session_task", {
+  urIngestSessionTaskId: text("ur_ingest_session_task_id").primaryKey().notNull(),
+  ingestSessionId: text("ingest_session_id").notNull().references(
+    () => urIngestSession.urIngestSessionId
+  ),
+  uniformResourceId: text("uniform_resource_id").references(
+    () => uniformResource.uniformResourceId
+  ),
+  capturedExecutable: text("captured_executable").notNull(),
+  urStatus: text("ur_status"),
+  urDiagnostics: text("ur_diagnostics"),
+  urTransformations: text("ur_transformations"),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  index("idx_ur_ingest_session_task__ingest_session_id").on(
+    table2.ingestSessionId
+  ),
+  checkJSON(table2.capturedExecutable),
+  checkJSON(table2.urDiagnostics),
+  checkJSON(table2.urTransformations),
+  checkJSON(table2.elaboration)
+]);
+var urIngestSessionImapAccount = table(
+  "ur_ingest_session_imap_account",
+  {
+    urIngestSessionImapAccountId: text("ur_ingest_session_imap_account_id").primaryKey().notNull(),
+    ingestSessionId: text("ingest_session_id").notNull().references(
+      () => urIngestSession.urIngestSessionId
+    ),
+    email: text(),
+    password: text(),
+    host: text(),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    index("idx_ur_ingest_session_imap_account__ingest_session_id__email").on(
+      table2.ingestSessionId,
+      table2.email
+    ),
+    unique().on(table2.ingestSessionId, table2.email)
+  ]
+);
+var urIngestSessionImapAcctFolder = table(
+  "ur_ingest_session_imap_acct_folder",
+  {
+    urIngestSessionImapAcctFolderId: text(
+      "ur_ingest_session_imap_acct_folder_id"
+    ).primaryKey().notNull(),
+    ingestSessionId: text("ingest_session_id").notNull().references(
+      () => urIngestSession.urIngestSessionId
+    ),
+    ingestAccountId: text("ingest_account_id").notNull().references(
+      () => urIngestSessionImapAccount.urIngestSessionImapAccountId
+    ),
+    folderName: text("folder_name").notNull(),
+    includeSenders: textArray("include_senders"),
+    excludeSenders: textArray("exclude_senders"),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    index(
+      "idx_ur_ingest_session_imap_acct_folder__ingest_session_id__folder_name"
+    ).on(table2.ingestSessionId, table2.folderName),
+    unique().on(table2.ingestAccountId, table2.folderName)
+  ]
+);
+var urIngestSessionImapAcctFolderMessage = table(
+  "ur_ingest_session_imap_acct_folder_message",
+  {
+    urIngestSessionImapAcctFolderMessageId: text(
+      "ur_ingest_session_imap_acct_folder_message_id"
+    ).primaryKey().notNull(),
+    ingestSessionId: text("ingest_session_id").notNull().references(
+      () => urIngestSession.urIngestSessionId
+    ),
+    ingestImapAcctFolderId: text("ingest_imap_acct_folder_id").notNull().references(
+      () => urIngestSessionImapAcctFolder.urIngestSessionImapAcctFolderId
+    ),
+    message: text().notNull(),
+    messageId: text("message_id").notNull(),
+    subject: text().notNull(),
+    from: text().notNull(),
+    cc: text().notNull(),
+    bcc: text().notNull(),
+    status: textArray().notNull(),
+    date: date(),
+    emailReferences: text("email_references").notNull(),
+    ...housekeeping
+  },
+  (table2) => [
+    index("idx_ur_ingest_session_imap_acct_folder_message__ingest_session_id").on(table2.ingestSessionId),
+    unique().on(table2.message, table2.messageId),
+    checkJSON(table2.cc),
+    checkJSON(table2.bcc),
+    checkJSON(table2.emailReferences)
+  ]
+);
+var urIngestSessionPlmAccount = table(
+  "ur_ingest_session_plm_account",
+  {
+    urIngestSessionPlmAccountId: varchar("ur_ingest_session_plm_account_id").primaryKey().notNull(),
+    ingestSessionId: text("ingest_session_id").notNull().references(
+      () => urIngestSession.urIngestSessionId
+    ),
+    provider: text().notNull(),
+    orgName: text("org_name").notNull(),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    unique().on(table2.provider, table2.orgName),
+    checkJSON(table2.elaboration)
+  ]
+);
+var urIngestSessionPlmAcctProject = table(
+  "ur_ingest_session_plm_acct_project",
+  {
+    urIngestSessionPlmAcctProjectId: varchar(
+      "ur_ingest_session_plm_acct_project_id"
+    ).primaryKey().notNull(),
+    ingestSessionId: text("ingest_session_id").notNull().references(
+      () => urIngestSession.urIngestSessionId
+    ),
+    ingestAccountId: text("ingest_account_id").notNull().references(
+      () => urIngestSessionPlmAccount.urIngestSessionPlmAccountId
+    ),
+    parentProjectId: text("parent_project_id"),
+    name: text().notNull(),
+    description: text(),
+    id: text(),
+    key: text(),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    unique().on(table2.name, table2.description),
+    checkJSON(table2.elaboration)
+  ]
+);
+var urIngestSessionPlmUser = table("ur_ingest_session_plm_user", {
+  urIngestSessionPlmUserId: varchar("ur_ingest_session_plm_user_id").primaryKey().notNull(),
+  userId: text("user_id").notNull(),
+  login: text().notNull(),
+  email: text(),
+  name: text(),
+  url: text().notNull(),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  unique().on(table2.userId, table2.login),
+  checkJSON(table2.elaboration)
+]);
+var urIngestSessionPlmIssueType = table(
+  "ur_ingest_session_plm_issue_type",
+  {
+    urIngestSessionPlmIssueTypeId: varchar("ur_ingest_session_plm_issue_type_id").primaryKey().notNull(),
+    avatarId: text("avatar_id"),
+    description: text().notNull(),
+    iconUrl: text("icon_url").notNull(),
+    id: text().notNull(),
+    name: text().notNull(),
+    subtask: integer().notNull(),
+    url: text().notNull(),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    unique().on(table2.id, table2.name),
+    checkJSON(table2.elaboration)
+  ]
+);
+var urIngestSessionPlmAcctProjectIssue = table(
+  "ur_ingest_session_plm_acct_project_issue",
+  {
+    urIngestSessionPlmAcctProjectIssueId: varchar(
+      "ur_ingest_session_plm_acct_project_issue_id"
+    ).primaryKey().notNull(),
+    ingestSessionId: text("ingest_session_id").notNull().references(
+      () => urIngestSession.urIngestSessionId
+    ),
+    urIngestSessionPlmAcctProjectId: text(
+      "ur_ingest_session_plm_acct_project_id"
+    ).notNull().references(
+      () => urIngestSessionPlmAcctProject.urIngestSessionPlmAcctProjectId
+    ),
+    uniformResourceId: text("uniform_resource_id").references(
+      () => uniformResource.uniformResourceId
+    ),
+    issueId: text("issue_id").notNull(),
+    issueNumber: integer("issue_number"),
+    parentIssueId: text("parent_issue_id"),
+    title: text().notNull(),
+    body: text(),
+    bodyText: text("body_text"),
+    bodyHtml: text("body_html"),
+    state: text().notNull(),
+    assignedTo: text("assigned_to"),
+    user: text().notNull().references(
+      () => urIngestSessionPlmUser.urIngestSessionPlmUserId
+    ),
+    url: text().notNull(),
+    closedAt: text("closed_at"),
+    issueTypeId: text("issue_type_id").references(
+      () => urIngestSessionPlmIssueType.urIngestSessionPlmIssueTypeId
+    ),
+    timeEstimate: integer("time_estimate"),
+    aggregateTimeEstimate: integer("aggregate_time_estimate"),
+    timeOriginalEstimate: integer("time_original_estimate"),
+    timeSpent: integer("time_spent"),
+    aggregateTimeSpent: integer("aggregate_time_spent"),
+    aggregateTimeOriginalEstimate: integer("aggregate_time_original_estimate"),
+    workratio: integer(),
+    currentProgress: integer("current_progress"),
+    totalProgress: integer("total_progress"),
+    resolutionName: text("resolution_name"),
+    resolutionDate: text("resolution_date"),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    unique().on(table2.title, table2.issueId, table2.state, table2.assignedTo),
+    checkJSON(table2.elaboration)
+  ]
+);
+var urIngestSessionPlmAcctLabel = table(
+  "ur_ingest_session_plm_acct_label",
+  {
+    urIngestSessionPlmAcctLabelId: varchar("ur_ingest_session_plm_acct_label_id").primaryKey().notNull(),
+    urIngestSessionPlmAcctProjectId: text(
+      "ur_ingest_session_plm_acct_project_id"
+    ).notNull().references(
+      () => urIngestSessionPlmAcctProject.urIngestSessionPlmAcctProjectId
+    ),
+    urIngestSessionPlmAcctProjectIssueId: text(
+      "ur_ingest_session_plm_acct_project_issue_id"
+    ).notNull().references(
+      () => urIngestSessionPlmAcctProjectIssue.urIngestSessionPlmAcctProjectIssueId
+    ),
+    label: text().notNull(),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    checkJSON(table2.elaboration)
+  ]
+);
+var urIngestSessionPlmMilestone = table(
+  "ur_ingest_session_plm_milestone",
+  {
+    urIngestSessionPlmMilestoneId: varchar("ur_ingest_session_plm_milestone_id").primaryKey().notNull(),
+    urIngestSessionPlmAcctProjectId: text(
+      "ur_ingest_session_plm_acct_project_id"
+    ).notNull().references(
+      () => urIngestSessionPlmAcctProject.urIngestSessionPlmAcctProjectId
+    ),
+    title: text().notNull(),
+    milestoneId: text("milestone_id").notNull(),
+    url: text().notNull(),
+    htmlUrl: text("html_url").notNull(),
+    openIssues: integer("open_issues"),
+    closedIssues: integer("closed_issues"),
+    dueOn: timestamptz("due_on"),
+    closedAt: timestamptz("closed_at"),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    checkJSON(table2.elaboration)
+  ]
+);
+var urIngestSessionPlmAcctRelationship = table(
+  "ur_ingest_session_plm_acct_relationship",
+  {
+    urIngestSessionPlmAcctRelationshipId: varchar(
+      "ur_ingest_session_plm_acct_relationship_id"
+    ).primaryKey().notNull(),
+    urIngestSessionPlmAcctProjectIdPrime: text(
+      "ur_ingest_session_plm_acct_project_id_prime"
+    ).notNull().references(
+      () => urIngestSessionPlmAcctProject.urIngestSessionPlmAcctProjectId
+    ),
+    urIngestSessionPlmAcctProjectIdRelated: text(
+      "ur_ingest_session_plm_acct_project_id_related"
+    ).notNull(),
+    urIngestSessionPlmAcctProjectIssueIdPrime: text(
+      "ur_ingest_session_plm_acct_project_issue_id_prime"
+    ).notNull().references(
+      () => urIngestSessionPlmAcctProjectIssue.urIngestSessionPlmAcctProjectIssueId
+    ),
+    urIngestSessionPlmAcctProjectIssueIdRelated: text(
+      "ur_ingest_session_plm_acct_project_issue_id_related"
+    ).notNull(),
+    relationship: text(),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    checkJSON(table2.elaboration)
+  ]
+);
+var urIngestSessionPlmComment = table(
+  "ur_ingest_session_plm_comment",
+  {
+    urIngestSessionPlmCommentId: varchar("ur_ingest_session_plm_comment_id").primaryKey().notNull(),
+    urIngestSessionPlmAcctProjectIssueId: text(
+      "ur_ingest_session_plm_acct_project_issue_id"
+    ).notNull().references(
+      () => urIngestSessionPlmAcctProjectIssue.urIngestSessionPlmAcctProjectIssueId
+    ),
+    commentId: text("comment_id").notNull(),
+    nodeId: text("node_id").notNull(),
+    url: text().notNull(),
+    body: text(),
+    bodyText: text("body_text"),
+    bodyHtml: text("body_html"),
+    user: text().notNull().references(
+      () => urIngestSessionPlmUser.urIngestSessionPlmUserId
+    ),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    unique().on(table2.commentId, table2.url, table2.body),
+    checkJSON(table2.elaboration)
+  ]
+);
+var urIngestSessionPlmReaction = table(
+  "ur_ingest_session_plm_reaction",
+  {
+    urIngestSessionPlmReactionId: varchar("ur_ingest_session_plm_reaction_id").primaryKey().notNull(),
+    reactionId: text("reaction_id").notNull(),
+    reactionType: text("reaction_type").notNull(),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    unique().on(table2.reactionType),
+    checkJSON(table2.elaboration)
+  ]
+);
+var urIngestSessionPlmIssueReaction = table(
+  "ur_ingest_session_plm_issue_reaction",
+  {
+    urIngestSessionPlmIssueReactionId: varchar(
+      "ur_ingest_session_plm_issue_reaction_id"
+    ).primaryKey().notNull(),
+    urIngestPlmReactionId: text("ur_ingest_plm_reaction_id").notNull().references(() => urIngestSessionPlmReaction.urIngestSessionPlmReactionId),
+    urIngestPlmIssueId: text("ur_ingest_plm_issue_id").notNull().references(
+      () => urIngestSessionPlmAcctProjectIssue.urIngestSessionPlmAcctProjectIssueId
+    ),
+    count: integer().default(1),
+    elaboration: text(),
+    ...housekeeping
+  },
+  (table2) => [
+    unique().on(table2.urIngestPlmIssueId, table2.urIngestPlmReactionId),
+    checkJSON(table2.elaboration)
+  ]
+);
+var urIngestSessionAttachment = table("ur_ingest_session_attachment", {
+  urIngestSessionAttachmentId: text("ur_ingest_session_attachment_id").primaryKey().notNull(),
+  uniformResourceId: text("uniform_resource_id").references(
+    () => uniformResource.uniformResourceId
+  ),
+  name: text(),
+  uri: text().notNull(),
+  content: blob(),
+  nature: text(),
+  size: integer(),
+  checksum: text(),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  index("idx_ur_ingest_session_attachment__uniform_resource_id__content").on(
+    table2.uniformResourceId,
+    table2.content
+  ),
+  unique().on(table2.uniformResourceId, table2.checksum, table2.nature, table2.size)
+]);
+var urIngestSessionUdiPgpSql = table("ur_ingest_session_udi_pgp_sql", {
+  urIngestSessionUdiPgpSqlId: text("ur_ingest_session_udi_pgp_sql_id").primaryKey().notNull(),
+  sql: text().notNull(),
+  nature: text().notNull(),
+  content: blob(),
+  behaviour: text(),
+  queryError: text("query_error"),
+  uniformResourceId: text("uniform_resource_id").references(
+    () => uniformResource.uniformResourceId
+  ),
+  ingestSessionId: text("ingest_session_id").references(
+    () => urIngestSession.urIngestSessionId
+  ),
+  ...housekeeping
+}, (table2) => [
+  index("idx_ur_ingest_session_udi_pgp_sql__ingest_session_id").on(
+    table2.ingestSessionId
+  ),
+  unique().on(table2.sql, table2.ingestSessionId),
+  checkJSON(table2.behaviour)
+]);
+var orchestrationNature = table("orchestration_nature", {
+  orchestrationNatureId: text("orchestration_nature_id").primaryKey().notNull(),
+  nature: text().notNull(),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  index("idx_orchestration_nature__orchestration_nature_id__nature").on(
+    table2.orchestrationNatureId,
+    table2.nature
+  ),
+  unique().on(table2.orchestrationNatureId, table2.nature)
+]);
+var orchestrationSession = table("orchestration_session", {
+  orchestrationSessionId: text("orchestration_session_id").primaryKey().notNull(),
+  deviceId: text("device_id").notNull().references(() => device.deviceId),
+  orchestrationNatureId: text("orchestration_nature_id").notNull().references(
+    () => orchestrationNature.orchestrationNatureId
+  ),
+  version: text().notNull(),
+  orchStartedAt: timestamptz("orch_started_at"),
+  orchFinishedAt: timestamptz("orch_finished_at"),
+  elaboration: text(),
+  argsJson: text("args_json"),
+  diagnosticsJson: text("diagnostics_json"),
+  diagnosticsMd: text("diagnostics_md")
+}, (table2) => [
+  checkJSON(table2.elaboration),
+  checkJSON(table2.argsJson),
+  checkJSON(table2.diagnosticsJson)
+]);
+var orchestrationSessionEntry = table("orchestration_session_entry", {
+  orchestrationSessionEntryId: text("orchestration_session_entry_id").primaryKey().notNull(),
+  sessionId: text("session_id").notNull().references(
+    () => orchestrationSession.orchestrationSessionId
+  ),
+  ingestSrc: text("ingest_src").notNull(),
+  ingestTableName: text("ingest_table_name"),
+  elaboration: text()
+}, (table2) => []);
+var orchestrationSessionState = table("orchestration_session_state", {
+  orchestrationSessionStateId: text("orchestration_session_state_id").primaryKey().notNull(),
+  sessionId: text("session_id").notNull().references(
+    () => orchestrationSession.orchestrationSessionId
+  ),
+  sessionEntryId: text("session_entry_id").references(
+    () => orchestrationSessionEntry.orchestrationSessionEntryId
+  ),
+  fromState: text("from_state").notNull(),
+  toState: text("to_state").notNull(),
+  transitionResult: text("transition_result"),
+  transitionReason: text("transition_reason"),
+  transitionedAt: timestamptz("transitioned_at"),
+  elaboration: text()
+}, (table2) => [
+  unique().on(table2.orchestrationSessionStateId, table2.fromState, table2.toState)
+]);
+var orchestrationSessionExec = table("orchestration_session_exec", {
+  orchestrationSessionExecId: text("orchestration_session_exec_id").primaryKey().notNull(),
+  execNature: text("exec_nature").notNull(),
+  sessionId: text("session_id").notNull().references(
+    () => orchestrationSession.orchestrationSessionId
+  ),
+  sessionEntryId: text("session_entry_id").references(
+    () => orchestrationSessionEntry.orchestrationSessionEntryId
+  ),
+  parentExecId: text("parent_exec_id"),
+  namespace: text(),
+  execIdentity: text("exec_identity"),
+  execCode: text("exec_code").notNull(),
+  execStatus: integer("exec_status").notNull(),
+  inputText: text("input_text"),
+  execErrorText: text("exec_error_text"),
+  outputText: text("output_text"),
+  outputNature: text("output_nature"),
+  narrativeMd: text("narrative_md"),
+  elaboration: text()
+}, (table2) => [
+  foreignKey(() => ({
+    columns: [table2.parentExecId],
+    foreignColumns: [table2.orchestrationSessionExecId],
+    name: "orchestration_session_exec_parent_exec_id_orchestration_session_exec_orchestration_session_exec_id_fk"
+  }))
+]);
+var orchestrationSessionIssue = table("orchestration_session_issue", {
+  orchestrationSessionIssueId: numeric("orchestration_session_issue_id").primaryKey().notNull(),
+  sessionId: text("session_id").notNull().references(
+    () => orchestrationSession.orchestrationSessionId
+  ),
+  sessionEntryId: text("session_entry_id").references(
+    () => orchestrationSessionEntry.orchestrationSessionEntryId
+  ),
+  issueType: text("issue_type").notNull(),
+  issueMessage: text("issue_message").notNull(),
+  issueRow: integer("issue_row"),
+  issueColumn: text("issue_column"),
+  invalidValue: text("invalid_value"),
+  remediation: text(),
+  elaboration: text()
+}, (table2) => []);
+var orchestrationSessionIssueRelation = table(
+  "orchestration_session_issue_relation",
+  {
+    orchestrationSessionIssueRelationId: numeric(
+      "orchestration_session_issue_relation_id"
+    ).primaryKey().notNull(),
+    issueIdPrime: numeric("issue_id_prime").notNull().references(
+      () => orchestrationSessionIssue.orchestrationSessionIssueId
+    ),
+    issueIdRel: text("issue_id_rel").notNull(),
+    relationshipNature: text("relationship_nature").notNull(),
+    elaboration: text()
+  },
+  (table2) => []
+);
+var orchestrationSessionLog = table("orchestration_session_log", {
+  orchestrationSessionLogId: numeric("orchestration_session_log_id").primaryKey().notNull(),
+  category: text(),
+  parentExecId: numeric("parent_exec_id"),
+  content: text().notNull(),
+  siblingOrder: integer("sibling_order"),
+  elaboration: text()
+}, (table2) => [
+  foreignKey(() => ({
+    columns: [table2.parentExecId],
+    foreignColumns: [table2.orchestrationSessionLogId],
+    name: "orchestration_session_log_parent_exec_id_orchestration_session_log_orchestration_session_log_id_fk"
+  }))
+]);
+var uniformResourceGraph = table("uniform_resource_graph", {
+  name: text().primaryKey().notNull(),
+  elaboration: text()
+}, (table2) => []);
+var uniformResourceEdge = table("uniform_resource_edge", {
+  graphName: text("graph_name").notNull().references(
+    () => uniformResourceGraph.name
+  ),
+  nature: text().notNull(),
+  nodeId: text("node_id").notNull(),
+  uniformResourceId: text("uniform_resource_id").notNull().references(
+    () => uniformResource.uniformResourceId
+  ),
+  elaboration: text()
+}, (table2) => [
+  index("idx_uniform_resource_edge__uniform_resource_id").on(
+    table2.uniformResourceId
+  ),
+  unique().on(table2.graphName, table2.nature, table2.nodeId, table2.uniformResourceId)
+]);
+var surveilrOsqueryMsNode = table("surveilr_osquery_ms_node", {
+  surveilrOsqueryMsNodeId: text("surveilr_osquery_ms_node_id").primaryKey().notNull(),
+  nodeKey: text("node_key").notNull(),
+  hostIdentifier: text("host_identifier").notNull(),
+  tlsCertSubject: text("tls_cert_subject"),
+  osVersion: text("os_version").notNull(),
+  platform: text().notNull(),
+  lastSeen: numeric("last_seen").notNull(),
+  status: text().default("active").notNull(),
+  osqueryVersion: text("osquery_version"),
+  osqueryBuildPlatform: text("osquery_build_platform").notNull(),
+  deviceId: text("device_id").notNull().references(() => device.deviceId),
+  behaviorId: text("behavior_id").references(() => behavior.behaviorId),
+  accelerate: integer().default(60).notNull(),
+  ...housekeeping
+}, (table2) => [
+  index("idx_surveilr_osquery_ms_node__node_key").on(table2.nodeKey),
+  unique().on(table2.hostIdentifier, table2.osVersion),
+  unique().on(table2.nodeKey)
+]);
+var urIngestSessionOsqueryMsLog = table(
+  "ur_ingest_session_osquery_ms_log",
+  {
+    urIngestSessionOsqueryMsLogId: text("ur_ingest_session_osquery_ms_log_id").primaryKey().notNull(),
+    nodeKey: text("node_key").notNull().references(
+      () => surveilrOsqueryMsNode.nodeKey
+    ),
+    logType: text("log_type").notNull(),
+    logData: text("log_data").notNull(),
+    appliedJqFilters: text("applied_jq_filters"),
+    ...housekeeping
+  },
+  (table2) => [
+    unique().on(table2.nodeKey, table2.logType, table2.logData)
+  ]
+);
+var osqueryPolicy = table("osquery_policy", {
+  osqueryPolicyId: text("osquery_policy_id").primaryKey().notNull(),
+  policyGroup: text("policy_group"),
+  policyName: text("policy_name").notNull(),
+  osqueryCode: text("osquery_code").notNull(),
+  policyDescription: text("policy_description").notNull(),
+  policyPassLabel: text("policy_pass_label").default("Pass").notNull(),
+  policyFailLabel: text("policy_fail_label").default("Fail").notNull(),
+  policyPassRemarks: text("policy_pass_remarks"),
+  policyFailRemarks: text("policy_fail_remarks"),
+  osqueryPlatforms: text("osquery_platforms"),
+  ...housekeeping
+}, (table2) => [
+  unique().on(table2.policyName, table2.osqueryCode)
+]);
+var surveilrOsqueryMsDistributedQuery = table(
+  "surveilr_osquery_ms_distributed_query",
+  {
+    queryId: text("query_id").primaryKey().notNull(),
+    nodeKey: text("node_key").notNull().references(
+      () => surveilrOsqueryMsNode.nodeKey
+    ),
+    queryName: text("query_name").notNull(),
+    querySql: text("query_sql").notNull(),
+    discoveryQuery: text("discovery_query"),
+    status: text().notNull(),
+    elaboration: text(),
+    interval: integer().notNull(),
+    ...housekeeping
+  },
+  (table2) => []
+);
+var surveilrOsqueryMsDistributedResult = table(
+  "surveilr_osquery_ms_distributed_result",
+  {
+    surveilrOsqueryMsDistributedResultId: text(
+      "surveilr_osquery_ms_distributed_result_id"
+    ).primaryKey().notNull(),
+    queryId: text("query_id").notNull().references(
+      () => surveilrOsqueryMsDistributedQuery.queryId
+    ),
+    nodeKey: text("node_key").notNull().references(
+      () => surveilrOsqueryMsNode.nodeKey
+    ),
+    results: text().notNull(),
+    statusCode: integer("status_code").notNull(),
+    ...housekeeping
+  },
+  (table2) => []
+);
+var surveilrOsqueryMsCarve = table("surveilr_osquery_ms_carve", {
+  surveilrOsqueryMsCarveId: text("surveilr_osquery_ms_carve_id").primaryKey().notNull(),
+  nodeKey: text("node_key").notNull().references(
+    () => surveilrOsqueryMsNode.nodeKey
+  ),
+  sessionId: text("session_id").notNull(),
+  carveGuid: text("carve_guid").notNull(),
+  carveSize: integer("carve_size").notNull(),
+  blockCount: integer("block_count").notNull(),
+  blockSize: integer("block_size").notNull(),
+  receivedBlocks: integer("received_blocks").default(0).notNull(),
+  carvePath: text("carve_path"),
+  status: text().notNull(),
+  startTime: numeric("start_time").notNull(),
+  completionTime: numeric("completion_time"),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  unique().on(table2.sessionId),
+  unique().on(table2.carveGuid)
+]);
+var surveilrOsqueryMsCarvedExtractedFile = table(
+  "surveilr_osquery_ms_carved_extracted_file",
+  {
+    surveilrOsqueryMsCarvedExtractedFileId: text(
+      "surveilr_osquery_ms_carved_extracted_file_id"
+    ).primaryKey().notNull(),
+    carveGuid: text("carve_guid").notNull().references(
+      () => surveilrOsqueryMsCarve.carveGuid
+    ),
+    path: text().notNull(),
+    sizeBytes: integer("size_bytes").notNull(),
+    contentDigest: text("content_digest").notNull(),
+    nature: text(),
+    extractedAt: timestamptz("extracted_at").notNull(),
+    ...housekeeping
+  },
+  (table2) => [
+    index("idx_surveilr_osquery_ms_carved_extracted_file__path__carve_guid").on(
+      table2.path,
+      table2.carveGuid
+    )
+  ]
+);
+var surveilrSnmpDevice = table("surveilr_snmp_device", {
+  surveilrSnmpDeviceId: text("surveilr_snmp_device_id").primaryKey().notNull(),
+  deviceKey: text("device_key").notNull(),
+  snmpHost: text("snmp_host").notNull(),
+  snmpPort: integer("snmp_port").default(161).notNull(),
+  snmpCommunity: text("snmp_community").notNull(),
+  snmpVersion: text("snmp_version").default("2c").notNull(),
+  snmpTimeout: integer("snmp_timeout").default(5).notNull(),
+  snmpRetries: integer("snmp_retries").default(3).notNull(),
+  deviceType: text("device_type"),
+  deviceDescription: text("device_description"),
+  lastSeen: numeric("last_seen").notNull(),
+  status: text().default("active").notNull(),
+  deviceId: text("device_id").notNull().references(() => device.deviceId),
+  behaviorId: text("behavior_id").references(() => behavior.behaviorId),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  index("idx_surveilr_snmp_device__device_key").on(table2.deviceKey),
+  unique().on(table2.snmpHost, table2.snmpPort),
+  unique().on(table2.deviceKey),
+  checkJSON(table2.elaboration)
+]);
+var surveilrSnmpCollection = table("surveilr_snmp_collection", {
+  surveilrSnmpCollectionId: text("surveilr_snmp_collection_id").primaryKey().notNull(),
+  deviceKey: text("device_key").notNull().references(
+    () => surveilrSnmpDevice.deviceKey
+  ),
+  oid: text().notNull(),
+  oidValue: text("oid_value").notNull(),
+  oidType: text("oid_type").notNull(),
+  collectedAt: timestamptz("collected_at").notNull(),
+  elaboration: text(),
+  ...housekeeping
+}, (table2) => [
+  index("idx_surveilr_snmp_collection__device_key__oid").on(
+    table2.deviceKey,
+    table2.oid
+  ),
+  index("idx_surveilr_snmp_collection__collected_at").on(table2.collectedAt),
+  checkJSON(table2.elaboration)
+]);
+var surveilrFunctionDoc = table("surveilr_function_doc", {
+  name: text().primaryKey(),
+  description: text(),
+  parameters: text({ mode: "json" }),
+  returnType: text("return_type"),
+  version: text()
+}, (table2) => [
+  checkJSON(table2.parameters)
+]);
+
+// ../../drizzle/views.ts
+import { sqliteView as sqliteView2 } from "drizzle-orm/sqlite-core";
+import { sql as sql2, count, min, max, sum, eq, and } from "drizzle-orm";
+var codeNotebookCellVersions = sqliteView2("code_notebook_cell_versions").as((qb) => {
+  return qb.select({
+    notebookName: codeNotebookCell.notebookName,
+    notebookKernelId: codeNotebookCell.notebookKernelId,
+    cellName: codeNotebookCell.cellName,
+    versions: sql2`COUNT(*) OVER(PARTITION BY ${codeNotebookCell.notebookName}, ${codeNotebookCell.cellName})`.as("versions"),
+    codeNotebookCellId: codeNotebookCell.codeNotebookCellId
+  }).from(codeNotebookCell).orderBy(codeNotebookCell.notebookName, codeNotebookCell.cellName);
+});
+var codeNotebookCellLatest = sqliteView2("code_notebook_cell_latest").as((qb) => {
+  return qb.select({
+    codeNotebookCellId: codeNotebookCell.codeNotebookCellId,
+    notebookKernelId: codeNotebookCell.notebookKernelId,
+    notebookName: codeNotebookCell.notebookName,
+    cellName: codeNotebookCell.cellName,
+    interpretableCode: codeNotebookCell.interpretableCode,
+    interpretableCodeHash: codeNotebookCell.interpretableCodeHash,
+    description: codeNotebookCell.description,
+    cellGovernance: codeNotebookCell.cellGovernance,
+    arguments: codeNotebookCell.arguments,
+    activityLog: codeNotebookCell.activityLog,
+    versionTimestamp: sql2`COALESCE(${codeNotebookCell.updatedAt}, ${codeNotebookCell.createdAt})`.as("version_timestamp")
+  }).from(codeNotebookCell).where(sql2`${codeNotebookCell.codeNotebookCellId} IN (
+      SELECT code_notebook_cell_id 
+      FROM (
+        SELECT code_notebook_cell_id,
+               ROW_NUMBER() OVER (
+                 PARTITION BY code_notebook_cell_id
+                 ORDER BY COALESCE(updated_at, created_at) DESC
+               ) AS rn
+        FROM code_notebook_cell
+      ) ranked WHERE rn = 1
+    )`);
+});
+var codeNotebookSqlCellMigratableVersion = sqliteView2("code_notebook_sql_cell_migratable_version").as((qb) => {
+  return qb.select({
+    codeNotebookCellId: codeNotebookCell.codeNotebookCellId,
+    notebookName: codeNotebookCell.notebookName,
+    cellName: codeNotebookCell.cellName,
+    interpretableCode: codeNotebookCell.interpretableCode,
+    interpretableCodeHash: codeNotebookCell.interpretableCodeHash,
+    isIdempotent: sql2`CASE WHEN ${codeNotebookCell.cellName} LIKE '%_once_%' THEN FALSE ELSE TRUE END`.as("is_idempotent"),
+    versionTimestamp: sql2`COALESCE(${codeNotebookCell.updatedAt}, ${codeNotebookCell.createdAt})`.as("version_timestamp")
+  }).from(codeNotebookCell).where(eq(codeNotebookCell.notebookName, "ConstructionSqlNotebook")).orderBy(codeNotebookCell.cellName);
+});
+var codeNotebookSqlCellMigratable = sqliteView2("code_notebook_sql_cell_migratable").as((qb) => {
+  return qb.select({
+    codeNotebookCellId: codeNotebookCell.codeNotebookCellId,
+    notebookKernelId: codeNotebookCell.notebookKernelId,
+    notebookName: codeNotebookCell.notebookName,
+    cellName: codeNotebookCell.cellName,
+    interpretableCode: codeNotebookCell.interpretableCode,
+    interpretableCodeHash: codeNotebookCell.interpretableCodeHash,
+    description: codeNotebookCell.description,
+    cellGovernance: codeNotebookCell.cellGovernance,
+    arguments: codeNotebookCell.arguments,
+    activityLog: codeNotebookCell.activityLog,
+    isIdempotent: sql2`CASE WHEN ${codeNotebookCell.cellName} LIKE '%_once_%' THEN FALSE ELSE TRUE END`.as("is_idempotent")
+  }).from(codeNotebookCell).where(eq(codeNotebookCell.notebookName, "ConstructionSqlNotebook")).orderBy(codeNotebookCell.cellName);
+});
+var codeNotebookSqlCellMigratableState = sqliteView2("code_notebook_sql_cell_migratable_state").as((qb) => {
+  return qb.select({
+    codeNotebookCellId: codeNotebookCell.codeNotebookCellId,
+    notebookKernelId: codeNotebookCell.notebookKernelId,
+    notebookName: codeNotebookCell.notebookName,
+    cellName: codeNotebookCell.cellName,
+    interpretableCode: codeNotebookCell.interpretableCode,
+    interpretableCodeHash: codeNotebookCell.interpretableCodeHash,
+    description: codeNotebookCell.description,
+    cellGovernance: codeNotebookCell.cellGovernance,
+    arguments: codeNotebookCell.arguments,
+    activityLog: codeNotebookCell.activityLog,
+    fromState: codeNotebookState.fromState,
+    toState: codeNotebookState.toState,
+    transitionReason: codeNotebookState.transitionReason,
+    transitionResult: codeNotebookState.transitionResult,
+    transitionedAt: codeNotebookState.transitionedAt
+  }).from(codeNotebookCell).innerJoin(codeNotebookState, eq(codeNotebookCell.codeNotebookCellId, codeNotebookState.codeNotebookCellId)).where(eq(codeNotebookCell.notebookName, "ConstructionSqlNotebook")).orderBy(codeNotebookCell.cellName);
+});
+var codeNotebookSqlCellMigratableNotExecuted = sqliteView2("code_notebook_sql_cell_migratable_not_executed").as((qb) => {
+  return qb.select({
+    codeNotebookCellId: codeNotebookCell.codeNotebookCellId,
+    notebookKernelId: codeNotebookCell.notebookKernelId,
+    notebookName: codeNotebookCell.notebookName,
+    cellName: codeNotebookCell.cellName,
+    interpretableCode: codeNotebookCell.interpretableCode,
+    interpretableCodeHash: codeNotebookCell.interpretableCodeHash,
+    description: codeNotebookCell.description,
+    cellGovernance: codeNotebookCell.cellGovernance,
+    arguments: codeNotebookCell.arguments,
+    activityLog: codeNotebookCell.activityLog
+  }).from(codeNotebookCell).leftJoin(codeNotebookState, and(
+    eq(codeNotebookCell.codeNotebookCellId, codeNotebookState.codeNotebookCellId),
+    eq(codeNotebookState.toState, "EXECUTED")
+  )).where(
+    and(
+      eq(codeNotebookCell.notebookName, "ConstructionSqlNotebook"),
+      sql2`${codeNotebookState.codeNotebookCellId} IS NULL`
+    )
+  ).orderBy(codeNotebookCell.cellName);
+});
+var codeNotebookMigrationSql = sqliteView2("code_notebook_migration_sql", {}).as(sql2`
+  SELECT 'BEGIN TRANSACTION;
+
+  ' ||
+        'CREATE TEMP TABLE IF NOT EXISTS "session_state_ephemeral" (
+      "key" TEXT PRIMARY KEY NOT NULL,
+      "value" TEXT NOT NULL
+    );
+
+    ' ||
+        GROUP_CONCAT(
+          CASE
+            -- Case 1: Non-idempotent and already executed
+            WHEN c.is_idempotent = FALSE AND s.code_notebook_cell_id IS NOT NULL THEN
+              '-- ' || c.notebook_name || '.' || c.cell_name || ' not included because it is non-idempotent and was already executed on ' || s.transitioned_at || '
+
+  '
+            -- Case 2: Idempotent and not yet executed, idempotent and being reapplied, or non-idempotent and being run for the first time
+            ELSE
+              '-- ' || c.notebook_name || '.' || c.cell_name || '
+  ' ||
+              CASE
+                -- First execution (non-idempotent or idempotent)
+                WHEN s.code_notebook_cell_id IS NULL THEN
+                  '-- Executing for the first time.
+  '
+                -- Reapplying execution (idempotent)
+                ELSE
+                  '-- Reapplying execution. Last executed on ' || s.transitioned_at || '
+  '
+              END ||
+              c.interpretable_code || '
+  ' ||
+              'INSERT INTO code_notebook_state (code_notebook_state_id, code_notebook_cell_id, from_state, to_state, transition_reason, created_at) ' ||
+              'VALUES (' ||
+              '''' || c.code_notebook_cell_id || '__' || strftime('%Y%m%d%H%M%S', 'now') || '''' || ', ' ||
+              '''' || c.code_notebook_cell_id || '''' || ', ' ||
+              '''MIGRATION_CANDIDATE''' || ', ' ||
+              '''EXECUTED''' || ', ' ||
+              CASE
+                WHEN s.code_notebook_cell_id IS NULL THEN '''Migration'''
+                ELSE '''Reapplication'''
+              END || ', ' ||
+              'CURRENT_TIMESTAMP' || ')' || '
+  ' ||
+              'ON CONFLICT(code_notebook_cell_id, from_state, to_state) DO UPDATE SET updated_at = CURRENT_TIMESTAMP, ' ||
+                'transition_reason = ''Reapplied ' || datetime('now', 'localtime') || ''';' || '
+  '
+          END,
+          '
+  '
+        ) || '
+
+  COMMIT;' as migration_sql 
+  FROM code_notebook_sql_cell_migratable c
+  LEFT JOIN code_notebook_state s
+    ON c.code_notebook_cell_id = s.code_notebook_cell_id AND s.to_state = 'EXECUTED'
+  ORDER BY c.cell_name`);
+var imapGraph = sqliteView2("imap_graph").as((qb) => {
+  return qb.select({
+    graphName: uniformResourceEdge.graphName,
+    uniformResourceId: uniformResource.uniformResourceId,
+    nature: uniformResource.nature,
+    uri: uniformResource.uri,
+    content: uniformResource.content,
+    urIngestSessionImapAcctFolderMessageId: urIngestSessionImapAcctFolderMessage.urIngestSessionImapAcctFolderMessageId,
+    ingestImapAcctFolderId: urIngestSessionImapAcctFolderMessage.ingestImapAcctFolderId,
+    messageId: urIngestSessionImapAcctFolderMessage.messageId
+  }).from(uniformResourceEdge).innerJoin(uniformResource, eq(uniformResourceEdge.uniformResourceId, uniformResource.uniformResourceId)).innerJoin(urIngestSessionImapAcctFolderMessage, eq(uniformResourceEdge.nodeId, urIngestSessionImapAcctFolderMessage.urIngestSessionImapAcctFolderMessageId)).where(eq(uniformResourceEdge.graphName, "imap"));
+});
+var filesystemGraph = sqliteView2("filesystem_graph").as((qb) => {
+  return qb.select({
+    graphName: uniformResourceEdge.graphName,
+    uniformResourceId: uniformResource.uniformResourceId,
+    nature: uniformResource.nature,
+    uri: uniformResource.uri,
+    urIngestSessionFsPathId: urIngestSessionFsPath.urIngestSessionFsPathId,
+    rootPath: urIngestSessionFsPath.rootPath
+  }).from(uniformResourceEdge).innerJoin(uniformResource, eq(uniformResourceEdge.uniformResourceId, uniformResource.uniformResourceId)).innerJoin(urIngestSessionFsPath, eq(uniformResourceEdge.nodeId, urIngestSessionFsPath.urIngestSessionFsPathId)).where(eq(uniformResourceEdge.graphName, "filesystem"));
+});
+var consoleInformationSchemaTable = sqliteView2("console_information_schema_table", {}).as(sql2`
+  SELECT
+    tbl.name AS table_name,
+    col.name AS column_name,
+    col.type AS data_type,
+    CASE WHEN col.pk = 1 THEN 'Yes' ELSE 'No' END AS is_primary_key,
+    CASE WHEN col."notnull" = 1 THEN 'Yes' ELSE 'No' END AS is_not_null,
+    col.dflt_value AS default_value,
+    'console/info-schema/table.sql?name=' || tbl.name || '&stats=yes' as info_schema_web_ui_path,
+    '[Content](console/info-schema/table.sql?name=' || tbl.name || '&stats=yes)' as info_schema_link_abbrev_md,
+    '[' || tbl.name || ' (table) Schema](console/info-schema/table.sql?name=' || tbl.name || '&stats=yes)' as info_schema_link_full_md,
+    'console/content/table/' || tbl.name || '.sql?stats=yes' as content_web_ui_path,
+    '[Content]($SITE_PREFIX_URL/console/content/table/' || tbl.name || '.sql?stats=yes)' as content_web_ui_link_abbrev_md,
+    '[' || tbl.name || ' (table) Content](console/content/table/' || tbl.name || '.sql?stats=yes)' as content_web_ui_link_full_md,
+    tbl.sql as sql_ddl
+  FROM sqlite_master tbl
+  JOIN pragma_table_info(tbl.name) col
+  WHERE tbl.type = 'table' AND tbl.name NOT LIKE 'sqlite_%'
+`);
+var consoleInformationSchemaView = sqliteView2("console_information_schema_view", {}).as(sql2`
+  SELECT
+    vw.name AS view_name,
+    col.name AS column_name,
+    col.type AS data_type,
+    '/console/info-schema/view.sql?name=' || vw.name || '&stats=yes' as info_schema_web_ui_path,
+    '[Content](console/info-schema/view.sql?name=' || vw.name || '&stats=yes)' as info_schema_link_abbrev_md,
+    '[' || vw.name || ' (view) Schema](console/info-schema/view.sql?name=' || vw.name || '&stats=yes)' as info_schema_link_full_md,
+    '/console/content/view/' || vw.name || '.sql?stats=yes' as content_web_ui_path,
+    '[Content]($SITE_PREFIX_URL/console/content/view/' || vw.name || '.sql?stats=yes)' as content_web_ui_link_abbrev_md,
+    '[' || vw.name || ' (view) Content](console/content/view/' || vw.name || '.sql?stats=yes)' as content_web_ui_link_full_md,
+    vw.sql as sql_ddl
+  FROM sqlite_master vw
+  JOIN pragma_table_info(vw.name) col
+  WHERE vw.type = 'view' AND vw.name NOT LIKE 'sqlite_%'
+`);
+var consoleContentTabular = sqliteView2("console_content_tabular").as((qb) => {
+  const tableQuery = qb.select({
+    tabularNature: sql2`'table'`.as("tabular_nature"),
+    tabularName: sql2`table_name`.as("tabular_name"),
+    infoSchemaWebUiPath: sql2`info_schema_web_ui_path`.as("info_schema_web_ui_path"),
+    infoSchemaLinkAbbrevMd: sql2`info_schema_link_abbrev_md`.as("info_schema_link_abbrev_md"),
+    infoSchemaLinkFullMd: sql2`info_schema_link_full_md`.as("info_schema_link_full_md"),
+    contentWebUiPath: sql2`content_web_ui_path`.as("content_web_ui_path"),
+    contentWebUiLinkAbbrevMd: sql2`content_web_ui_link_abbrev_md`.as("content_web_ui_link_abbrev_md"),
+    contentWebUiLinkFullMd: sql2`content_web_ui_link_full_md`.as("content_web_ui_link_full_md")
+  }).from(consoleInformationSchemaTable);
+  const viewQuery = qb.select({
+    tabularNature: sql2`'view'`.as("tabular_nature"),
+    tabularName: sql2`view_name`.as("tabular_name"),
+    infoSchemaWebUiPath: sql2`info_schema_web_ui_path`.as("info_schema_web_ui_path"),
+    infoSchemaLinkAbbrevMd: sql2`info_schema_link_abbrev_md`.as("info_schema_link_abbrev_md"),
+    infoSchemaLinkFullMd: sql2`info_schema_link_full_md`.as("info_schema_link_full_md"),
+    contentWebUiPath: sql2`content_web_ui_path`.as("content_web_ui_path"),
+    contentWebUiLinkAbbrevMd: sql2`content_web_ui_link_abbrev_md`.as("content_web_ui_link_abbrev_md"),
+    contentWebUiLinkFullMd: sql2`content_web_ui_link_full_md`.as("content_web_ui_link_full_md")
+  }).from(consoleInformationSchemaView);
+  return tableQuery.unionAll(viewQuery);
+});
+var consoleInformationSchemaTableColFkey = sqliteView2("console_information_schema_table_col_fkey", {}).as(sql2`
+  SELECT
+    tbl.name AS table_name,
+    f."from" AS column_name,
+    f."from" || ' references ' || f."table" || '.' || f."to" AS foreign_key
+  FROM sqlite_master tbl
+  JOIN pragma_foreign_key_list(tbl.name) f
+  WHERE tbl.type = 'table' AND tbl.name NOT LIKE 'sqlite_%'
+`);
+var consoleInformationSchemaTableColIndex = sqliteView2("console_information_schema_table_col_index", {}).as(sql2`
+  SELECT
+    tbl.name AS table_name,
+    pi.name AS column_name,
+    idx.name AS index_name
+  FROM sqlite_master tbl
+  JOIN pragma_index_list(tbl.name) idx
+  JOIN pragma_index_info(idx.name) pi
+  WHERE tbl.type = 'table' AND tbl.name NOT LIKE 'sqlite_%'
+`);
+var rssdStatisticsOverview = sqliteView2("rssd_statistics_overview").as((qb) => {
+  return qb.select({
+    dbSizeMb: sql2`(SELECT ROUND(page_count * page_size / (1024.0 * 1024), 2) FROM pragma_page_count(), pragma_page_size())`.as("db_size_mb"),
+    dbSizeGb: sql2`(SELECT ROUND(page_count * page_size / (1024.0 * 1024 * 1024), 4) FROM pragma_page_count(), pragma_page_size())`.as("db_size_gb"),
+    totalTables: sql2`(SELECT COUNT(*) FROM sqlite_master WHERE type = 'table')`.as("total_tables"),
+    totalIndexes: sql2`(SELECT COUNT(*) FROM sqlite_master WHERE type = 'index')`.as("total_indexes"),
+    totalRows: sql2`(SELECT SUM(tbl_rows) FROM (SELECT name, (SELECT COUNT(*) FROM sqlite_master sm WHERE sm.type='table' AND sm.name=t.name) AS tbl_rows FROM sqlite_master t WHERE type='table'))`.as("total_rows"),
+    pageSize: sql2`(SELECT page_size FROM pragma_page_size())`.as("page_size"),
+    totalPages: sql2`(SELECT page_count FROM pragma_page_count())`.as("total_pages")
+  }).from(sql2`(SELECT 1) AS dummy`);
+});
+var rssdTableStatistic = sqliteView2("rssd_table_statistic", {}).as(sql2`
+  SELECT 
+    m.name AS table_name,
+    (SELECT COUNT(*) FROM pragma_table_info(m.name)) AS total_columns,
+    (SELECT COUNT(*) FROM pragma_index_list(m.name)) AS total_indexes,
+    (SELECT COUNT(*) FROM pragma_foreign_key_list(m.name)) AS foreign_keys,
+    (SELECT COUNT(*) FROM pragma_table_info(m.name) WHERE pk != 0) AS primary_keys,
+    (SELECT table_size_mb FROM surveilr_table_size WHERE table_name = m.name) AS table_size_mb
+  FROM sqlite_master m
+  WHERE m.type = 'table'
+`);
+var uniformResourceFile = sqliteView2("uniform_resource_file").as((qb) => {
+  return qb.select({
+    uniformResourceId: uniformResource.uniformResourceId,
+    nature: uniformResource.nature,
+    sourcePath: urIngestSessionFsPath.rootPath,
+    filePathRel: urIngestSessionFsPathEntry.filePathRel,
+    sizeBytes: uniformResource.sizeBytes
+  }).from(uniformResource).leftJoin(
+    uniformResourceEdge,
+    and(
+      eq(uniformResource.uniformResourceId, uniformResourceEdge.uniformResourceId),
+      eq(uniformResourceEdge.nature, "ingest_fs_path")
+    )
+  ).leftJoin(urIngestSessionFsPath, eq(uniformResourceEdge.nodeId, urIngestSessionFsPath.urIngestSessionFsPathId)).leftJoin(urIngestSessionFsPathEntry, eq(uniformResource.uniformResourceId, urIngestSessionFsPathEntry.uniformResourceId));
+});
+var uniformResourceImap = sqliteView2("uniform_resource_imap").as((qb) => {
+  return qb.select({
+    uniformResourceId: uniformResource.uniformResourceId,
+    graphName: uniformResourceGraph.name,
+    urIngestSessionImapAccountId: urIngestSessionImapAccount.urIngestSessionImapAccountId,
+    email: urIngestSessionImapAccount.email,
+    host: urIngestSessionImapAccount.host,
+    subject: urIngestSessionImapAcctFolderMessage.subject,
+    from: urIngestSessionImapAcctFolderMessage.from,
+    message: urIngestSessionImapAcctFolderMessage.message,
+    date: urIngestSessionImapAcctFolderMessage.date,
+    urIngestSessionImapAcctFolderId: urIngestSessionImapAcctFolder.urIngestSessionImapAcctFolderId,
+    ingestAccountId: urIngestSessionImapAcctFolder.ingestAccountId,
+    folderName: urIngestSessionImapAcctFolder.folderName,
+    sizeBytes: uniformResource.sizeBytes,
+    nature: uniformResource.nature,
+    content: uniformResource.content
+  }).from(uniformResource).innerJoin(uniformResourceEdge, eq(uniformResourceEdge.uniformResourceId, uniformResource.uniformResourceId)).innerJoin(uniformResourceGraph, eq(uniformResourceGraph.name, uniformResourceEdge.graphName)).innerJoin(urIngestSessionImapAcctFolderMessage, eq(urIngestSessionImapAcctFolderMessage.urIngestSessionImapAcctFolderMessageId, uniformResourceEdge.nodeId)).innerJoin(urIngestSessionImapAcctFolder, eq(urIngestSessionImapAcctFolderMessage.ingestImapAcctFolderId, urIngestSessionImapAcctFolder.urIngestSessionImapAcctFolderId)).leftJoin(urIngestSessionImapAccount, eq(urIngestSessionImapAccount.urIngestSessionImapAccountId, urIngestSessionImapAcctFolder.ingestAccountId)).where(and(
+    eq(uniformResource.nature, "text"),
+    eq(uniformResourceGraph.name, "imap"),
+    sql2`${uniformResource.ingestSessionImapAcctFolderMessage} IS NOT NULL`
+  ));
+});
+var uniformResourceImapContent = sqliteView2("uniform_resource_imap_content").as((qb) => {
+  return qb.select({
+    uniformResourceId: uniformResourceImap.uniformResourceId,
+    baseId: sql2`base_ur.uniform_resource_id`.as("base_id"),
+    extId: sql2`ext_ur.uniform_resource_id`.as("ext_id"),
+    baseUri: sql2`base_ur.uri`.as("base_uri"),
+    extUri: sql2`ext_ur.uri`.as("ext_uri"),
+    baseNature: sql2`base_ur.nature`.as("base_nature"),
+    extNature: sql2`ext_ur.nature`.as("ext_nature"),
+    htmlContent: sql2`json_extract(part.value, '$.body.Html')`.as("html_content")
+  }).from(uniformResourceImap).innerJoin(sql2`uniform_resource base_ur`, sql2`base_ur.uniform_resource_id = ${uniformResourceImap.uniformResourceId}`).innerJoin(sql2`uniform_resource ext_ur`, sql2`ext_ur.uri = base_ur.uri || '/json' AND ext_ur.nature = 'json'`).crossJoin(sql2`json_each(ext_ur.content, '$.parts') AS part`).where(and(
+    sql2`ext_ur.nature = 'json'`,
+    sql2`json_extract(part.value, '$.body.Html') IS NOT NULL`
+  ));
+});
+var urIngestSessionFilesStats = sqliteView2("ur_ingest_session_files_stats").as((qb) => {
+  return qb.select({
+    deviceId: device.deviceId,
+    ingestSessionId: urIngestSession.urIngestSessionId,
+    ingestSessionStartedAt: urIngestSession.ingestStartedAt,
+    ingestSessionFinishedAt: urIngestSession.ingestFinishedAt,
+    fileExtension: sql2`COALESCE(${urIngestSessionFsPathEntry.fileExtn}, '')`.as("file_extension"),
+    ingestSessionFsPathId: urIngestSessionFsPath.urIngestSessionFsPathId,
+    ingestSessionRootFsPath: urIngestSessionFsPath.rootPath,
+    totalFileCount: count(urIngestSessionFsPathEntry.uniformResourceId).as("total_file_count"),
+    fileCountWithContent: sum(sql2`CASE WHEN ${uniformResource.content} IS NOT NULL THEN 1 ELSE 0 END`).as("file_count_with_content"),
+    fileCountWithFrontmatter: sum(sql2`CASE WHEN ${uniformResource.frontmatter} IS NOT NULL THEN 1 ELSE 0 END`).as("file_count_with_frontmatter"),
+    minFileSizeBytes: min(uniformResource.sizeBytes).as("min_file_size_bytes"),
+    averageFileSizeBytes: sql2`CAST(ROUND(AVG(${uniformResource.sizeBytes})) AS INTEGER)`.as("average_file_size_bytes"),
+    maxFileSizeBytes: max(uniformResource.sizeBytes).as("max_file_size_bytes"),
+    oldestFileLastModifiedDatetime: min(uniformResource.lastModifiedAt).as("oldest_file_last_modified_datetime"),
+    youngestFileLastModifiedDatetime: max(uniformResource.lastModifiedAt).as("youngest_file_last_modified_datetime")
+  }).from(urIngestSession).innerJoin(device, eq(urIngestSession.deviceId, device.deviceId)).leftJoin(urIngestSessionFsPath, eq(urIngestSession.urIngestSessionId, urIngestSessionFsPath.ingestSessionId)).leftJoin(urIngestSessionFsPathEntry, eq(urIngestSessionFsPath.urIngestSessionFsPathId, urIngestSessionFsPathEntry.ingestFsPathId)).leftJoin(uniformResource, eq(urIngestSessionFsPathEntry.uniformResourceId, uniformResource.uniformResourceId)).groupBy(
+    device.deviceId,
+    urIngestSession.urIngestSessionId,
+    urIngestSession.ingestStartedAt,
+    urIngestSession.ingestFinishedAt,
+    urIngestSessionFsPathEntry.fileExtn,
+    urIngestSessionFsPath.rootPath
+  ).orderBy(device.deviceId, urIngestSession.ingestFinishedAt, urIngestSessionFsPathEntry.fileExtn);
+});
+var urIngestSessionFilesStatsLatest = sqliteView2("ur_ingest_session_files_stats_latest").as((qb) => {
+  return qb.select({
+    deviceId: urIngestSessionFilesStats.deviceId,
+    ingestSessionId: urIngestSessionFilesStats.ingestSessionId,
+    ingestSessionStartedAt: urIngestSessionFilesStats.ingestSessionStartedAt,
+    ingestSessionFinishedAt: urIngestSessionFilesStats.ingestSessionFinishedAt,
+    fileExtension: urIngestSessionFilesStats.fileExtension,
+    ingestSessionFsPathId: urIngestSessionFilesStats.ingestSessionFsPathId,
+    ingestSessionRootFsPath: urIngestSessionFilesStats.ingestSessionRootFsPath,
+    totalFileCount: urIngestSessionFilesStats.totalFileCount,
+    fileCountWithContent: urIngestSessionFilesStats.fileCountWithContent,
+    fileCountWithFrontmatter: urIngestSessionFilesStats.fileCountWithFrontmatter,
+    minFileSizeBytes: urIngestSessionFilesStats.minFileSizeBytes,
+    averageFileSizeBytes: urIngestSessionFilesStats.averageFileSizeBytes,
+    maxFileSizeBytes: urIngestSessionFilesStats.maxFileSizeBytes,
+    oldestFileLastModifiedDatetime: urIngestSessionFilesStats.oldestFileLastModifiedDatetime,
+    youngestFileLastModifiedDatetime: urIngestSessionFilesStats.youngestFileLastModifiedDatetime
+  }).from(urIngestSessionFilesStats).where(sql2`${urIngestSessionFilesStats.ingestSessionId} IN (
+      SELECT ${urIngestSession.urIngestSessionId}
+      FROM ${urIngestSession}
+      ORDER BY ${urIngestSession.ingestFinishedAt} DESC
+      LIMIT 1
+    )`);
+});
+var urIngestSessionTasksStats = sqliteView2("ur_ingest_session_tasks_stats").as((qb) => {
+  return qb.select({
+    deviceId: device.deviceId,
+    ingestSessionId: urIngestSession.urIngestSessionId,
+    ingestSessionStartedAt: urIngestSession.ingestStartedAt,
+    ingestSessionFinishedAt: urIngestSession.ingestFinishedAt,
+    urStatus: sql2`COALESCE(${urIngestSessionTask.urStatus}, 'Ok')`.as("ur_status"),
+    nature: sql2`COALESCE(${uniformResource.nature}, 'UNKNOWN')`.as("nature"),
+    totalFileCount: count(urIngestSessionTask.uniformResourceId).as("total_file_count"),
+    fileCountWithContent: sum(sql2`CASE WHEN ${uniformResource.content} IS NOT NULL THEN 1 ELSE 0 END`).as("file_count_with_content"),
+    fileCountWithFrontmatter: sum(sql2`CASE WHEN ${uniformResource.frontmatter} IS NOT NULL THEN 1 ELSE 0 END`).as("file_count_with_frontmatter"),
+    minFileSizeBytes: min(uniformResource.sizeBytes).as("min_file_size_bytes"),
+    averageFileSizeBytes: sql2`CAST(ROUND(AVG(${uniformResource.sizeBytes})) AS INTEGER)`.as("average_file_size_bytes"),
+    maxFileSizeBytes: max(uniformResource.sizeBytes).as("max_file_size_bytes"),
+    oldestFileLastModifiedDatetime: min(uniformResource.lastModifiedAt).as("oldest_file_last_modified_datetime"),
+    youngestFileLastModifiedDatetime: max(uniformResource.lastModifiedAt).as("youngest_file_last_modified_datetime")
+  }).from(urIngestSession).innerJoin(device, eq(urIngestSession.deviceId, device.deviceId)).leftJoin(urIngestSessionTask, eq(urIngestSession.urIngestSessionId, urIngestSessionTask.ingestSessionId)).leftJoin(uniformResource, eq(urIngestSessionTask.uniformResourceId, uniformResource.uniformResourceId)).groupBy(
+    device.deviceId,
+    urIngestSession.urIngestSessionId,
+    urIngestSession.ingestStartedAt,
+    urIngestSession.ingestFinishedAt,
+    urIngestSessionTask.capturedExecutable
+  ).orderBy(device.deviceId, urIngestSession.ingestFinishedAt, urIngestSessionTask.urStatus);
+});
+var urIngestSessionTasksStatsLatest = sqliteView2("ur_ingest_session_tasks_stats_latest").as((qb) => {
+  return qb.select({
+    deviceId: urIngestSessionTasksStats.deviceId,
+    ingestSessionId: urIngestSessionTasksStats.ingestSessionId,
+    ingestSessionStartedAt: urIngestSessionTasksStats.ingestSessionStartedAt,
+    ingestSessionFinishedAt: urIngestSessionTasksStats.ingestSessionFinishedAt,
+    urStatus: urIngestSessionTasksStats.urStatus,
+    nature: urIngestSessionTasksStats.nature,
+    totalFileCount: urIngestSessionTasksStats.totalFileCount,
+    fileCountWithContent: urIngestSessionTasksStats.fileCountWithContent,
+    fileCountWithFrontmatter: urIngestSessionTasksStats.fileCountWithFrontmatter,
+    minFileSizeBytes: urIngestSessionTasksStats.minFileSizeBytes,
+    averageFileSizeBytes: urIngestSessionTasksStats.averageFileSizeBytes,
+    maxFileSizeBytes: urIngestSessionTasksStats.maxFileSizeBytes,
+    oldestFileLastModifiedDatetime: urIngestSessionTasksStats.oldestFileLastModifiedDatetime,
+    youngestFileLastModifiedDatetime: urIngestSessionTasksStats.youngestFileLastModifiedDatetime
+  }).from(urIngestSessionTasksStats).where(sql2`${urIngestSessionTasksStats.ingestSessionId} IN (
+      SELECT ${urIngestSession.urIngestSessionId}
+      FROM ${urIngestSession}
+      ORDER BY ${urIngestSession.ingestFinishedAt} DESC
+      LIMIT 1
+    )`);
+});
+var urIngestSessionFileIssue = sqliteView2("ur_ingest_session_file_issue").as((qb) => {
+  return qb.select({
+    deviceId: urIngestSession.deviceId,
+    urIngestSessionId: urIngestSession.urIngestSessionId,
+    urIngestSessionFsPathId: urIngestSessionFsPath.urIngestSessionFsPathId,
+    rootPath: urIngestSessionFsPath.rootPath,
+    urIngestSessionFsPathEntryId: urIngestSessionFsPathEntry.urIngestSessionFsPathEntryId,
+    filePathAbs: urIngestSessionFsPathEntry.filePathAbs,
+    urStatus: urIngestSessionFsPathEntry.urStatus,
+    urDiagnostics: urIngestSessionFsPathEntry.urDiagnostics
+  }).from(urIngestSessionFsPathEntry).innerJoin(urIngestSessionFsPath, eq(urIngestSessionFsPathEntry.ingestFsPathId, urIngestSessionFsPath.urIngestSessionFsPathId)).innerJoin(urIngestSession, eq(urIngestSessionFsPath.ingestSessionId, urIngestSession.urIngestSessionId)).where(sql2`${urIngestSessionFsPathEntry.urStatus} IS NOT NULL`).groupBy(
+    urIngestSession.deviceId,
+    urIngestSession.urIngestSessionId,
+    urIngestSessionFsPath.urIngestSessionFsPathId,
+    urIngestSessionFsPath.rootPath,
+    urIngestSessionFsPathEntry.urIngestSessionFsPathEntryId,
+    urIngestSessionFsPathEntry.filePathAbs,
+    urIngestSessionFsPathEntry.urStatus,
+    urIngestSessionFsPathEntry.urDiagnostics
+  );
+});
+var orchestrationSessionByDevice = sqliteView2("orchestration_session_by_device").as((qb) => {
+  return qb.select({
+    deviceId: device.deviceId,
+    deviceName: device.name,
+    sessionCount: count(orchestrationSession.orchestrationSessionId).as("session_count")
+  }).from(orchestrationSession).innerJoin(device, eq(orchestrationSession.deviceId, device.deviceId)).groupBy(device.deviceId, device.name);
+});
+var orchestrationSessionDuration = sqliteView2("orchestration_session_duration").as((qb) => {
+  return qb.select({
+    orchestrationSessionId: orchestrationSession.orchestrationSessionId,
+    orchestrationNature: orchestrationNature.nature,
+    orchStartedAt: orchestrationSession.orchStartedAt,
+    orchFinishedAt: orchestrationSession.orchFinishedAt,
+    durationSeconds: sql2`(JULIANDAY(${orchestrationSession.orchFinishedAt}) - JULIANDAY(${orchestrationSession.orchStartedAt})) * 24 * 60 * 60`.as("duration_seconds")
+  }).from(orchestrationSession).innerJoin(orchestrationNature, eq(orchestrationSession.orchestrationNatureId, orchestrationNature.orchestrationNatureId)).where(sql2`${orchestrationSession.orchFinishedAt} IS NOT NULL`);
+});
+var orchestrationSuccessRate = sqliteView2("orchestration_success_rate").as((qb) => {
+  return qb.select({
+    orchestrationNature: orchestrationNature.nature,
+    totalSessions: count().as("total_sessions"),
+    successfulSessions: sum(sql2`CASE WHEN ${orchestrationSessionState.toState} = 'surveilr_orch_completed' THEN 1 ELSE 0 END`).as("successful_sessions"),
+    successRate: sql2`(CAST(SUM(CASE WHEN ${orchestrationSessionState.toState} = 'surveilr_orch_completed' THEN 1 ELSE 0 END) AS FLOAT) / COUNT(*)) * 100`.as("success_rate")
+  }).from(orchestrationSession).innerJoin(orchestrationNature, eq(orchestrationSession.orchestrationNatureId, orchestrationNature.orchestrationNatureId)).innerJoin(orchestrationSessionState, eq(orchestrationSession.orchestrationSessionId, orchestrationSessionState.sessionId)).where(sql2`${orchestrationSessionState.toState} IN ('surveilr_orch_completed', 'surveilr_orch_failed')`).groupBy(orchestrationNature.nature);
+});
+var orchestrationSessionScript = sqliteView2("orchestration_session_script").as((qb) => {
+  return qb.select({
+    orchestrationSessionId: orchestrationSession.orchestrationSessionId,
+    orchestrationNature: orchestrationNature.nature,
+    scriptCount: count(orchestrationSessionEntry.orchestrationSessionEntryId).as("script_count")
+  }).from(orchestrationSession).innerJoin(orchestrationNature, eq(orchestrationSession.orchestrationNatureId, orchestrationNature.orchestrationNatureId)).innerJoin(orchestrationSessionEntry, eq(orchestrationSession.orchestrationSessionId, orchestrationSessionEntry.sessionId)).groupBy(orchestrationSession.orchestrationSessionId, orchestrationNature.nature);
+});
+var orchestrationExecutionsByType = sqliteView2("orchestration_executions_by_type").as((qb) => {
+  return qb.select({
+    execNature: orchestrationSessionExec.execNature,
+    executionCount: count(orchestrationSessionExec.orchestrationSessionExecId).as("execution_count")
+  }).from(orchestrationSessionExec).groupBy(orchestrationSessionExec.execNature);
+});
+var orchestrationExecutionSuccessRateByType = sqliteView2("orchestration_execution_success_rate_by_type").as((qb) => {
+  return qb.select({
+    execNature: orchestrationSessionExec.execNature,
+    totalExecutions: count().as("total_executions"),
+    successfulExecutions: sum(sql2`CASE WHEN ${orchestrationSessionExec.execStatus} = 0 THEN 1 ELSE 0 END`).as("successful_executions"),
+    successRate: sql2`(CAST(SUM(CASE WHEN ${orchestrationSessionExec.execStatus} = 0 THEN 1 ELSE 0 END) AS FLOAT) / COUNT(*)) * 100`.as("success_rate")
+  }).from(orchestrationSessionExec).groupBy(orchestrationSessionExec.execNature);
+});
+var orchestrationSessionSummary = sqliteView2("orchestration_session_summary").as((qb) => {
+  return qb.select({
+    issueType: orchestrationSessionIssue.issueType,
+    issueCount: count(orchestrationSessionIssue.orchestrationSessionIssueId).as("issue_count")
+  }).from(orchestrationSessionIssue).groupBy(orchestrationSessionIssue.issueType);
+});
+var orchestrationIssueRemediation = sqliteView2("orchestration_issue_remediation").as((qb) => {
+  return qb.select({
+    orchestrationSessionIssueId: orchestrationSessionIssue.orchestrationSessionIssueId,
+    issueType: orchestrationSessionIssue.issueType,
+    issueMessage: orchestrationSessionIssue.issueMessage,
+    remediation: orchestrationSessionIssue.remediation
+  }).from(orchestrationSessionIssue).where(sql2`${orchestrationSessionIssue.remediation} IS NOT NULL`);
+});
+var orchestrationLogsBySession = sqliteView2("orchestration_logs_by_session").as((qb) => {
+  return qb.select({
+    orchestrationSessionId: orchestrationSession.orchestrationSessionId,
+    orchestrationNature: orchestrationNature.nature,
+    category: orchestrationSessionLog.category,
+    logCount: count(orchestrationSessionLog.orchestrationSessionLogId).as("log_count")
+  }).from(orchestrationSession).innerJoin(orchestrationNature, eq(orchestrationSession.orchestrationNatureId, orchestrationNature.orchestrationNatureId)).innerJoin(orchestrationSessionExec, eq(orchestrationSession.orchestrationSessionId, orchestrationSessionExec.sessionId)).innerJoin(orchestrationSessionLog, eq(orchestrationSessionExec.orchestrationSessionExecId, orchestrationSessionLog.parentExecId)).groupBy(orchestrationSession.orchestrationSessionId, orchestrationNature.nature, orchestrationSessionLog.category);
+});
+var emailMessagesWithTimezone = sqliteView2("email_messages_with_timezone", {}).as(sql2`
+SELECT
+    m.*,
+    -- Smart timezone conversion based on original timezone
+    CASE
+        -- If already IST (+0530), just extract the time
+        WHEN date LIKE '%+0530%' THEN substr(date, 18, 8)
+        -- If UTC (+0000), convert to IST
+        WHEN date LIKE '%+0000%' THEN time(substr(date, 18, 8), '+5 hours', '+30 minutes')
+        -- If EST (-0500), convert to IST
+        WHEN date LIKE '%-0500%' THEN time(substr(date, 18, 8), '+10 hours', '+30 minutes')
+        -- If PST (-0800), convert to IST
+        WHEN date LIKE '%-0800%' THEN time(substr(date, 18, 8), '+13 hours', '+30 minutes')
+        -- Default: assume UTC and convert
+        ELSE time(substr(date, 18, 8), '+5 hours', '+30 minutes')
+    END as ist_time,
+
+    -- Always show UTC time (convert from any timezone to UTC first)
+    CASE
+        WHEN date LIKE '%+0530%' THEN time(substr(date, 18, 8), '-5 hours', '-30 minutes')
+        WHEN date LIKE '%+0000%' THEN substr(date, 18, 8)
+        WHEN date LIKE '%-0500%' THEN time(substr(date, 18, 8), '+5 hours')
+        WHEN date LIKE '%-0800%' THEN time(substr(date, 18, 8), '+8 hours')
+        ELSE substr(date, 18, 8)
+    END as utc_time,
+
+    -- Detect original timezone more accurately
+    CASE
+        WHEN date LIKE '%+0530%' THEN 'IST'
+        WHEN date LIKE '%+0000%' THEN 'UTC'
+        WHEN date LIKE '%-0500%' THEN 'EST'
+        WHEN date LIKE '%-0800%' THEN 'PST'
+        ELSE 'Unknown'
+    END as detected_timezone
+FROM ur_ingest_session_imap_acct_folder_message m`);
+var deviceGraphOverview = sqliteView2("device_graph_overview", {}).as(sql2`
+SELECT
+    'snmp_device' as device_type,
+    sd.device_key as device_id,
+    sd.snmp_host as primary_identifier,
+    sd.device_type as device_category,
+    sd.device_description as description,
+    sd.status,
+    sd.created_at,
+    sd.updated_at,
+    json_object(
+        'snmp_port', sd.snmp_port,
+        'snmp_community', sd.snmp_community,
+        'snmp_version', sd.snmp_version,
+        'snmp_timeout', sd.snmp_timeout,
+        'snmp_retries', sd.snmp_retries
+    ) as device_metadata
+FROM surveilr_snmp_device sd
+WHERE sd.status = 'active'
+
+UNION ALL
+
+SELECT
+    'osquery_node' as device_type,
+    osq.node_key as device_id,
+    osq.host_identifier as primary_identifier,
+    'endpoint' as device_category,
+    osq.os_version as description,
+    osq.status,
+    osq.created_at,
+    osq.updated_at,
+    json_object(
+        'last_seen', osq.last_seen,
+        'platform', osq.platform,
+        'osquery_version', osq.osquery_version,
+        'device_id', osq.device_id
+    ) as device_metadata
+FROM surveilr_osquery_ms_node osq
+WHERE osq.status = 'active'`);
+var deviceGraphCorrelations = sqliteView2("device_graph_correlations", {}).as(sql2`
+SELECT DISTINCT
+    ure1.node_id as snmp_device_key,
+    ure1.uniform_resource_id as osquery_node_key,
+    CASE
+        WHEN ure1.nature LIKE '%ip_address_match%' THEN 'IP Address Match'
+        WHEN ure1.nature LIKE '%hostname_match%' THEN 'Hostname Match'
+        WHEN ure1.nature LIKE '%mac_address_match%' THEN 'MAC Address Match'
+        WHEN ure1.nature LIKE '%network_topology%' THEN 'Network Topology'
+        WHEN ure1.nature LIKE '%manual%' THEN 'Manual'
+        ELSE 'Unknown'
+    END as correlation_type,
+    CASE
+        WHEN ure1.nature LIKE '%ip_address_match%' THEN 0.95
+        WHEN ure1.nature LIKE '%hostname_match%' THEN 0.85
+        WHEN ure1.nature LIKE '%mac_address_match%' THEN 0.90
+        WHEN ure1.nature LIKE '%network_topology%' THEN 0.70
+        WHEN ure1.nature LIKE '%manual%' THEN 1.0
+        ELSE 0.5
+    END as confidence_score,
+    json_extract(ure1.elaboration, '$.snmp_host') as snmp_host,
+    json_extract(ure1.elaboration, '$.correlation_method') as correlation_method,
+    ure1.elaboration as evidence
+FROM uniform_resource_edge ure1
+WHERE ure1.graph_name = 'device_graph'
+AND ure1.nature LIKE 'snmp_to_osquery_%'
+ORDER BY ure1.node_id, ure1.uniform_resource_id`);
+var snmpDeviceInventory = sqliteView2("snmp_device_inventory", {}).as(sql2`
+SELECT
+    sd.device_key,
+    sd.snmp_host,
+    sd.snmp_port,
+    sd.device_type,
+    sd.device_description,
+    sd.status,
+    sd.created_at,
+    COUNT(sc.surveilr_snmp_collection_id) as total_collections,
+    MAX(sc.collected_at) as last_collection_time,
+    COUNT(DISTINCT sc.oid) as unique_oids_collected,
+    AVG(
+        CASE
+            WHEN sc.collected_at > datetime('now', '-1 hour') THEN 1
+            ELSE 0
+        END
+    ) as recent_activity_score
+FROM surveilr_snmp_device sd
+LEFT JOIN surveilr_snmp_collection sc ON sd.device_key = sc.device_key
+GROUP BY sd.device_key, sd.snmp_host, sd.snmp_port, sd.device_type,
+         sd.device_description, sd.status, sd.created_at
+ORDER BY sd.status, sd.snmp_host`);
+var snmpCollectionSummary = sqliteView2("snmp_collection_summary", {}).as(sql2`
+SELECT
+    sc.device_key,
+    sd.snmp_host,
+    sc.oid_type,
+    COUNT(*) as collection_count,
+    COUNT(DISTINCT sc.oid) as unique_oids,
+    MIN(sc.collected_at) as first_collection,
+    MAX(sc.collected_at) as latest_collection,
+    COUNT(DISTINCT DATE(sc.collected_at)) as collection_days
+FROM surveilr_snmp_collection sc
+JOIN surveilr_snmp_device sd ON sc.device_key = sd.device_key
+GROUP BY sc.device_key, sd.snmp_host, sc.oid_type
+ORDER BY sd.snmp_host, sc.oid_type`);
+var networkDeviceTopology = sqliteView2("network_device_topology", {}).as(sql2`
+SELECT
+    sd.device_key,
+    sd.snmp_host,
+    sd.device_type,
+    -- Extract network information from SNMP collections
+    COALESCE(
+        (SELECT sc.oid_value
+         FROM surveilr_snmp_collection sc
+         WHERE sc.device_key = sd.device_key
+         AND sc.oid LIKE '%.1.3.6.1.2.1.1.1.%'
+         LIMIT 1),
+        'Unknown'
+    ) as system_description,
+    COALESCE(
+        (SELECT sc.oid_value
+         FROM surveilr_snmp_collection sc
+         WHERE sc.device_key = sd.device_key
+         AND sc.oid LIKE '%.1.3.6.1.2.1.1.5.%'
+         LIMIT 1),
+        'Unknown'
+    ) as system_name,
+    -- Count correlated devices
+    (SELECT COUNT(*)
+     FROM device_graph_correlations dgc
+     WHERE dgc.snmp_device_key = sd.device_key
+    ) as correlated_devices_count,
+    sd.status,
+    sd.created_at
+FROM surveilr_snmp_device sd
+WHERE sd.status = 'active'
+ORDER BY sd.snmp_host`);
+var deviceGraphAnalytics = sqliteView2("device_graph_analytics", {}).as(sql2`
+SELECT
+    'summary' as metric_type,
+    'total_snmp_devices' as metric_name,
+    COUNT(*) as metric_value,
+    NULL as additional_info
+FROM surveilr_snmp_device
+WHERE status = 'active'
+
+UNION ALL
+
+SELECT
+    'summary' as metric_type,
+    'total_osquery_nodes' as metric_name,
+    COUNT(*) as metric_value,
+    NULL as additional_info
+FROM surveilr_osquery_ms_node
+WHERE status = 'active'
+
+UNION ALL
+
+SELECT
+    'summary' as metric_type,
+    'total_correlations' as metric_name,
+    COUNT(*) as metric_value,
+    NULL as additional_info
+FROM device_graph_correlations
+
+UNION ALL
+
+SELECT
+    'summary' as metric_type,
+    'correlation_types' as metric_name,
+    COUNT(DISTINCT correlation_type) as metric_value,
+    GROUP_CONCAT(DISTINCT correlation_type) as additional_info
+FROM device_graph_correlations
+
+UNION ALL
+
+SELECT
+    'correlation_by_type' as metric_type,
+    correlation_type as metric_name,
+    COUNT(*) as metric_value,
+    printf('avg_confidence: %.2f', AVG(confidence_score)) as additional_info
+FROM device_graph_correlations
+GROUP BY correlation_type
+
+UNION ALL
+
+SELECT
+    'collection_stats' as metric_type,
+    'total_snmp_collections' as metric_name,
+    COUNT(*) as metric_value,
+    printf('unique_devices: %d', COUNT(DISTINCT device_key)) as additional_info
+FROM surveilr_snmp_collection
+
+UNION ALL
+
+SELECT
+    'collection_stats' as metric_type,
+    'collection_activity_last_24h' as metric_name,
+    COUNT(*) as metric_value,
+    printf('devices_active: %d', COUNT(DISTINCT device_key)) as additional_info
+FROM surveilr_snmp_collection
+WHERE collected_at > datetime('now', '-24 hours')`);
+var snmpOidPerformance = sqliteView2("snmp_oid_performance", {}).as(sql2`
+SELECT
+    sc.oid,
+    sc.oid_type,
+    COUNT(*) as total_collections,
+    COUNT(DISTINCT sc.device_key) as devices_collecting,
+    COUNT(DISTINCT DATE(sc.collected_at)) as collection_days,
+    MIN(sc.collected_at) as first_seen,
+    MAX(sc.collected_at) as last_seen,
+    -- Calculate collection frequency (avoid nested aggregates)
+    CAST(
+        COUNT(*) * 1.0 /
+        NULLIF(MAX(julianday(sc.collected_at)) - MIN(julianday(sc.collected_at)), 0)
+    AS REAL) as avg_collections_per_day,
+    -- Sample values for diversity analysis
+    COUNT(DISTINCT sc.oid_value) as unique_values_count,
+    GROUP_CONCAT(DISTINCT sc.oid_value) as sample_values
+FROM surveilr_snmp_collection sc
+GROUP BY sc.oid, sc.oid_type
+HAVING COUNT(*) > 0
+ORDER BY total_collections DESC, devices_collecting DESC`);
 
-// relations.ts
+// ../../drizzle/relations.ts
 import { relations } from "drizzle-orm/relations";
 var codeNotebookCellRelations = relations(codeNotebookCell, ({ one, many }) => ({
   codeNotebookKernel: one(codeNotebookKernel, {