@saptools/service-flow 0.1.70 → 0.1.72

package/src/db/event-fact-semantics.ts

@@ -0,0 +1,347 @@
+import type { Db } from './connection.js';
+import { ANALYZER_VERSION } from '../version.js';
+import {
+  EVENT_ENVIRONMENT_KEY_ALLOWLIST,
+  parseEnvironmentDeclarationsFact,
+} from '../parsers/environment-declarations.js';
+import type {
+  EventEnvironmentReference,
+} from '../parsers/event-environment-reference.js';
+import { parseEventSkeletonFact } from '../utils/event-skeleton.js';
+import { parsePackageImportReference } from
+  '../parsers/package-fact-contract.js';
+import {
+  expectedPackageEventConstantResolution,
+  type PackageEventConstantResolution,
+} from '../linker/package-event-constant-resolver.js';
+
+export interface EventFactSemanticCategoryCount {
+  category: string;
+  count: number;
+}
+
+interface EventFactRow extends Record<string, unknown> {
+  workspaceId?: number;
+  eventName?: string;
+  skeletonSignature?: string | null;
+  skeletonJson?: string | null;
+  unresolvedReason?: string | null;
+  evidenceJson?: string;
+}
+
+const receiverReasons = new Set([
+  'event_receiver_unproven_binding',
+  'event_receiver_unproven_propagation',
+  'event_receiver_not_cap_client',
+]);
+const constantReasons = new Set([
+  'event_name_constant_container_ambiguous',
+  'event_name_constant_member_not_string',
+  'event_name_constant_container_mutable',
+  'event_name_constant_container_not_exported',
+  'event_name_constant_resolution_pending',
+]);
+const environmentKeys = new Set<string>(EVENT_ENVIRONMENT_KEY_ALLOWLIST);
+
+function category(
+  name: string,
+  count: number,
+): EventFactSemanticCategoryCount[] {
+  return count > 0 ? [{ category: name, count }] : [];
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown> : undefined;
+}
+
+function jsonRecord(value: unknown): Record<string, unknown> | undefined {
+  if (typeof value !== 'string') return undefined;
+  try {
+    return record(JSON.parse(value) as unknown);
+  } catch {
+    return undefined;
+  }
+}
+
+function currentEventRows(
+  db: Db,
+  workspaceId?: number,
+): EventFactRow[] {
+  return db.prepare(`SELECT fact.event_name_expr eventName,
+    r.workspace_id workspaceId,
+    fact.event_skeleton_signature skeletonSignature,
+    fact.event_skeleton_json skeletonJson,
+    fact.unresolved_reason unresolvedReason,
+    fact.evidence_json evidenceJson
+    FROM outbound_calls fact JOIN repositories r ON r.id=fact.repo_id
+    WHERE r.fact_analyzer_version=?
+      AND (? IS NULL OR r.workspace_id=?)
+      AND fact.call_type IN ('async_emit','async_subscribe')`).all(
+    ANALYZER_VERSION, workspaceId, workspaceId,
+  ) as EventFactRow[];
+}
+
+function integerField(
+  value: Record<string, unknown>,
+  key: string,
+): number | undefined {
+  const item = value[key];
+  return Number.isInteger(item) && Number(item) >= 0
+    ? Number(item) : undefined;
+}
+
+function packagePendingValid(
+  row: EventFactRow,
+  evidence: Record<string, unknown>,
+): boolean {
+  const source = evidence.eventNameConstantSourceExpression;
+  return evidence.eventNameUnresolvedReason
+      === 'event_name_constant_resolution_pending'
+    && evidence.eventNamePackageConstantResolution === undefined
+    && typeof source === 'string' && source.length > 0
+    && row.eventName === source;
+}
+
+function resolutionFieldsValid(
+  value: Record<string, unknown>,
+  expected: PackageEventConstantResolution,
+): boolean {
+  return value.status === expected.status
+    && value.reason === expected.reason
+    && integerField(value, 'candidateCount') === expected.candidateCount
+    && integerField(value, 'eligibleCandidateCount')
+      === expected.eligibleCandidateCount
+    && integerField(value, 'selectedCandidateCount')
+      === (expected.status === 'resolved' ? 1 : 0)
+    && value.candidateSetComplete === expected.complete
+    && value.resolvedModulePath === expected.modulePath
+    && value.targetRepositoryId === expected.targetRepoId;
+}
+
+function packageTerminalValid(
+  db: Db,
+  row: EventFactRow,
+  evidence: Record<string, unknown>,
+): boolean {
+  const binding = parsePackageImportReference(
+    evidence.eventNameConstantImportBinding,
+  );
+  const workspaceId = row.workspaceId;
+  const resolution = record(evidence.eventNamePackageConstantResolution);
+  if (!binding || typeof workspaceId !== 'number' || !resolution)
+    return false;
+  const expected = expectedPackageEventConstantResolution(
+    db, workspaceId, binding,
+  );
+  const source = evidence.eventNameConstantSourceExpression;
+  const expectedName = expected.value ?? source;
+  const expectedReason = expected.status === 'resolved'
+    ? undefined : expected.reason;
+  if (row.eventName !== expectedName
+    || evidence.eventNameUnresolvedReason !== expectedReason
+    || !resolutionFieldsValid(resolution, expected)) return false;
+  if (expected.status !== 'resolved') return true;
+  const constant = record(evidence.eventNameConstant);
+  return constant?.sourceKind === 'package_static_string'
+    && constant.sourceFile === expected.sourceFile
+    && constant.sourceLine === expected.sourceLine;
+}
+
+function packageConstantValid(
+  db: Db,
+  row: EventFactRow,
+  evidence: Record<string, unknown>,
+  phase: 'pre_package' | 'terminal',
+): boolean {
+  if (evidence.eventNameConstantImportBinding === undefined) return true;
+  const binding = parsePackageImportReference(
+    evidence.eventNameConstantImportBinding,
+  );
+  const source = evidence.eventNameConstantSourceExpression;
+  if (!binding || typeof source !== 'string' || source.length === 0)
+    return false;
+  if (packagePendingValid(row, evidence))
+    return phase === 'pre_package';
+  return packageTerminalValid(db, row, evidence);
+}
+
+function receiverEvidenceValid(
+  row: EventFactRow,
+  evidence: Record<string, unknown>,
+): boolean {
+  const classification = evidence.receiverClassification;
+  const proof = evidence.receiverProof;
+  if (!['cap_evidence', 'name_fallback', 'unproven'].includes(
+    String(classification),
+  ) || typeof proof !== 'string' || proof.length === 0
+    || !Array.isArray(evidence.consideredBindingSites)
+    || evidence.consideredBindingSites.length > 8) return false;
+  if (classification === 'name_fallback')
+    return proof === 'compatibility_name_fallback';
+  if (classification !== 'unproven') return true;
+  return typeof row.unresolvedReason === 'string'
+    && receiverReasons.has(row.unresolvedReason);
+}
+
+function environmentBindingValid(
+  binding: EventEnvironmentReference,
+  sourceKeys: readonly string[],
+): boolean {
+  if (!['resolved', 'refused'].includes(binding.status)
+    || !sourceKeys.includes(binding.sourceKey)
+    || !Array.isArray(binding.transforms)
+    || !binding.transforms.every((item) =>
+      item === 'toUpperCase' || item === 'toLowerCase')) return false;
+  if (binding.status === 'refused')
+    return typeof binding.reason === 'string' && binding.reason.length > 0;
+  return typeof binding.environmentKey === 'string'
+    && environmentKeys.has(binding.environmentKey)
+    && typeof binding.sourceFile === 'string' && binding.sourceFile.length > 0
+    && Number.isInteger(binding.startOffset)
+    && Number(binding.startOffset) >= 0
+    && Number.isInteger(binding.endOffset)
+    && Number(binding.endOffset) > Number(binding.startOffset);
+}
+
+function skeletonValid(
+  row: EventFactRow,
+  evidence: Record<string, unknown>,
+): boolean {
+  const reason = evidence.eventNameUnresolvedReason;
+  if (reason !== 'dynamic_event_name_identifier')
+    return row.skeletonSignature == null && row.skeletonJson == null;
+  const skeleton = parseEventSkeletonFact(row.skeletonJson);
+  if (!skeleton || skeleton.status !== 'complete'
+    || row.skeletonSignature !== skeleton.signature
+    || !skeleton.environmentBindings.every((binding) =>
+      environmentBindingValid(binding, skeleton.sourceKeys))) return false;
+  const keys = evidence.eventNamePlaceholderKeys;
+  return Array.isArray(keys)
+    && JSON.stringify(keys) === JSON.stringify(skeleton.sourceKeys);
+}
+
+function eventReasonValid(
+  row: EventFactRow,
+  evidence: Record<string, unknown>,
+): boolean {
+  const eventReason = evidence.eventNameUnresolvedReason;
+  if (receiverReasons.has(String(row.unresolvedReason)))
+    return eventReason === undefined
+      || eventReason === 'dynamic_event_name_identifier'
+      || eventReason === 'dynamic_event_name_unsupported_expression'
+      || constantReasons.has(String(eventReason));
+  if (eventReason === undefined) return row.unresolvedReason == null;
+  if (eventReason === 'dynamic_event_name_identifier'
+    || eventReason === 'dynamic_event_name_unsupported_expression'
+    || constantReasons.has(String(eventReason)))
+    return row.unresolvedReason === eventReason;
+  return false;
+}
+
+function invalidEventRows(
+  db: Db,
+  workspaceId?: number,
+  phase: 'pre_package' | 'terminal' = 'pre_package',
+): number {
+  return currentEventRows(db, workspaceId).filter((row) => {
+    if (typeof row.eventName !== 'string' || row.eventName.length === 0)
+      return false;
+    const evidence = jsonRecord(row.evidenceJson);
+    return !evidence
+      || !receiverEvidenceValid(row, evidence)
+      || !eventReasonValid(row, evidence)
+      || !packageConstantValid(db, row, evidence, phase)
+      || !skeletonValid(row, evidence);
+  }).length;
+}
+
+function invalidEnvironmentRepositories(
+  db: Db,
+  workspaceId?: number,
+): number {
+  const rows = db.prepare(`SELECT environment_declarations_json value
+    FROM repositories WHERE fact_analyzer_version=?
+      AND (? IS NULL OR workspace_id=?)`).all(
+    ANALYZER_VERSION, workspaceId, workspaceId,
+  );
+  return rows.filter((row) =>
+    !parseEnvironmentDeclarationsFact(row.value)).length;
+}
+
+function generatedConstantInvalid(row: Record<string, unknown>): boolean {
+  const kind = String(row.constantKind);
+  const container = row.containerName;
+  const member = row.memberName;
+  const name = row.name;
+  const memberShape = kind === 'const_identifier'
+    ? container == null && member == null
+    : typeof container === 'string' && container.length > 0
+      && typeof member === 'string' && member.length > 0
+      && name === `${container}.${member}`;
+  const resolved = row.resolutionStatus === 'resolved';
+  const refused = row.resolutionStatus === 'refused';
+  return !['const_identifier', 'enum_member', 'const_object_property']
+    .includes(kind)
+    || typeof name !== 'string' || name.length === 0
+    || (!resolved && !refused)
+    || (resolved && (typeof row.value !== 'string'
+      || row.value.length === 0 || row.unresolvedReason != null))
+    || (refused && (row.value != null
+      || !constantReasons.has(String(row.unresolvedReason))))
+    || typeof row.sourceFile !== 'string' || row.sourceFile.length === 0
+    || !Number.isInteger(row.sourceLine) || Number(row.sourceLine) < 1
+    || ![0, 1].includes(Number(row.exported))
+    || ![0, 1].includes(Number(row.stable))
+    || !validConstantOffsets(row) || !memberShape;
+}
+
+function validConstantOffsets(row: Record<string, unknown>): boolean {
+  const start = row.declarationStartOffset;
+  const end = row.declarationEndOffset;
+  const valueStart = row.valueStartOffset;
+  const valueEnd = row.valueEndOffset;
+  return Number.isInteger(start) && Number(start) >= 0
+    && Number.isInteger(end) && Number(end) > Number(start)
+    && Number.isInteger(valueStart) && Number(valueStart) >= Number(start)
+    && Number.isInteger(valueEnd) && Number(valueEnd) > Number(valueStart)
+    && Number(valueEnd) <= Number(end);
+}
+
+function invalidGeneratedConstants(
+  db: Db,
+  workspaceId?: number,
+): number {
+  const rows = db.prepare(`SELECT fact.source_file sourceFile,
+    fact.source_line sourceLine,fact.name,fact.container_name containerName,
+    fact.member_name memberName,fact.value,
+    fact.constant_kind constantKind,fact.exported,fact.stable,
+    fact.resolution_status resolutionStatus,
+    fact.unresolved_reason unresolvedReason,
+    fact.declaration_start_offset declarationStartOffset,
+    fact.declaration_end_offset declarationEndOffset,
+    fact.value_start_offset valueStartOffset,
+    fact.value_end_offset valueEndOffset
+    FROM generated_constants fact
+    JOIN repositories r ON r.id=fact.repo_id
+    WHERE r.fact_analyzer_version=?
+      AND (? IS NULL OR r.workspace_id=?)`).all(
+    ANALYZER_VERSION, workspaceId, workspaceId,
+  );
+  return rows.filter(generatedConstantInvalid).length;
+}
+
+export function invalidEventFactCategories(
+  db: Db,
+  workspaceId?: number,
+  phase: 'pre_package' | 'terminal' = 'pre_package',
+): EventFactSemanticCategoryCount[] {
+  return [
+    ...category('event_fact_semantics_invalid',
+      invalidEventRows(db, workspaceId, phase)),
+    ...category('repository_environment_declarations_invalid',
+      invalidEnvironmentRepositories(db, workspaceId)),
+    ...category('generated_constant_fact_invalid',
+      invalidGeneratedConstants(db, workspaceId)),
+  ];
+}

package/src/db/event-surface-invalidation.ts

@@ -0,0 +1,38 @@
+import type { Db } from './connection.js';
+import type { OutboundCallFact } from '../types.js';
+
+function priorEventFactCount(db: Db, repoId: number): number {
+  const row = db.prepare(`SELECT COUNT(*) count FROM outbound_calls
+    WHERE repo_id=? AND call_type IN ('async_emit','async_subscribe')`).get(
+    repoId,
+  );
+  return Number(row?.count ?? 0);
+}
+
+function repositoryEnvironment(
+  db: Db,
+  repoId: number,
+): string | null {
+  const row = db.prepare(`SELECT environment_declarations_json value
+    FROM repositories WHERE id=?`).get(repoId);
+  return typeof row?.value === 'string' ? row.value : null;
+}
+
+export function invalidateEventSurfaceFacts(
+  db: Db,
+  repoId: number,
+  calls: readonly OutboundCallFact[],
+  nextEnvironmentJson: string,
+): void {
+  const hasNewEvents = calls.some((call) =>
+    call.callType === 'async_emit' || call.callType === 'async_subscribe');
+  const environmentChanged = repositoryEnvironment(db, repoId)
+    !== nextEnvironmentJson;
+  if (!hasNewEvents && priorEventFactCount(db, repoId) === 0
+    && !environmentChanged) return;
+  db.prepare(`UPDATE repositories SET
+    graph_stale_reason='event_surface_facts_changed',
+    graph_stale_at=datetime('now')
+    WHERE workspace_id=(SELECT workspace_id FROM repositories WHERE id=?)`)
+    .run(repoId);
+}

package/src/db/fact-json-inventory.ts

@@ -36,6 +36,14 @@ export const LINK_FACT_JSON_INVENTORY: readonly FactJsonInventoryItem[] = [
     consumers: ['package-import-symbol-resolver'],
     repositoryJoin: '',
   },
+  {
+    table: 'repositories',
+    column: 'environment_declarations_json',
+    nullable: false,
+    shape: 'object',
+    consumers: ['event-environment-resolver'],
+    repositoryJoin: '',
+  },
   {
     table: 'handler_methods',
     column: 'decorator_resolution_json',
@@ -77,6 +85,14 @@ export const LINK_FACT_JSON_INVENTORY: readonly FactJsonInventoryItem[] = [
     consumers: ['cross-repository-linker', 'trace-engine'],
     repositoryJoin: directRepositoryJoin,
   },
+  {
+    table: 'outbound_calls',
+    column: 'event_skeleton_json',
+    nullable: true,
+    shape: 'object',
+    consumers: ['event-shape-linker', 'event-runtime-resolver'],
+    repositoryJoin: directRepositoryJoin,
+  },
   {
     table: 'service_bindings',
     column: 'placeholders_json',

package/src/db/migrations.ts

@@ -1,6 +1,6 @@
 import type { Db } from './connection.js';
 import { schemaIndexesSql, schemaTablesSql } from './schema.js';
-export const CURRENT_SCHEMA_VERSION = 13;
+export const CURRENT_SCHEMA_VERSION = 14;
 const columns: Record<string, Array<{ name: string; ddl: string }>> = {
   handler_methods: [
     { name: 'decorator_resolution_json', ddl: "ALTER TABLE handler_methods ADD COLUMN decorator_resolution_json TEXT NOT NULL DEFAULT '{}'" },
@@ -20,6 +20,7 @@ const columns: Record<string, Array<{ name: string; ddl: string }>> = {
     { name: 'graph_stale_at', ddl: 'ALTER TABLE repositories ADD COLUMN graph_stale_at TEXT' },
     { name: 'fact_analyzer_version', ddl: "ALTER TABLE repositories ADD COLUMN fact_analyzer_version TEXT DEFAULT 'legacy'" },
     { name: 'package_public_surface_json', ddl: 'ALTER TABLE repositories ADD COLUMN package_public_surface_json TEXT' },
+    { name: 'environment_declarations_json', ddl: 'ALTER TABLE repositories ADD COLUMN environment_declarations_json TEXT' },
   ],
   graph_edges: [
     { name: 'status', ddl: "ALTER TABLE graph_edges ADD COLUMN status TEXT NOT NULL DEFAULT 'unresolved'" },
@@ -60,6 +61,8 @@ const columns: Record<string, Array<{ name: string; ddl: string }>> = {
     { name: 'external_target_dynamic', ddl: 'ALTER TABLE outbound_calls ADD COLUMN external_target_dynamic INTEGER NOT NULL DEFAULT 0' },
     { name: 'call_site_start_offset', ddl: 'ALTER TABLE outbound_calls ADD COLUMN call_site_start_offset INTEGER' },
     { name: 'call_site_end_offset', ddl: 'ALTER TABLE outbound_calls ADD COLUMN call_site_end_offset INTEGER' },
+    { name: 'event_skeleton_signature', ddl: 'ALTER TABLE outbound_calls ADD COLUMN event_skeleton_signature TEXT' },
+    { name: 'event_skeleton_json', ddl: 'ALTER TABLE outbound_calls ADD COLUMN event_skeleton_json TEXT' },
   ],
   symbol_calls: [
     { name: 'call_site_start_offset', ddl: 'ALTER TABLE symbol_calls ADD COLUMN call_site_start_offset INTEGER' },
@@ -104,6 +107,13 @@ function markFactProvenanceMigrationStale(db: Db, priorVersion: number): void {
       graph_stale_at=COALESCE(graph_stale_at,datetime('now'))
     WHERE index_status='indexed' OR last_indexed_at IS NOT NULL`).run();
 }
+function markEventSurfaceMigrationStale(db: Db, priorVersion: number): void {
+  if (priorVersion >= 14) return;
+  db.prepare(`UPDATE repositories
+    SET graph_stale_reason='schema_v14_event_surface_requires_reindex',
+      graph_stale_at=COALESCE(graph_stale_at,datetime('now'))
+    WHERE index_status='indexed' OR last_indexed_at IS NOT NULL`).run();
+}
 export function migrate(db: Db): void {
   db.transaction(() => {
     const version = userVersion(db);
@@ -114,6 +124,7 @@ export function migrate(db: Db): void {
     normalizeLegacyStatus(db, version);
     markCallSiteMigrationStale(db, version);
     markFactProvenanceMigrationStale(db, version);
+    markEventSurfaceMigrationStale(db, version);
     const violations = db.pragma('foreign_key_check');
     if (violations.length > 0) throw new Error('SQLite foreign_key_check failed during migration');
     db.pragma(`user_version = ${CURRENT_SCHEMA_VERSION}`);

package/src/db/package-target-invalidation.ts

@@ -10,6 +10,13 @@ interface PackageCallRow {
   evidence: Record<string, unknown>;
 }
 
+interface PackageEventCallRow {
+  id: number;
+  repoId: number;
+  unresolvedReason?: string | null;
+  evidence: Record<string, unknown>;
+}
+
 export interface PackageInvalidationBatch {
   publishingRepoIds: ReadonlySet<number>;
   affectedCallerRepoIds: Set<number>;
@@ -44,6 +51,14 @@ function packageName(evidence: Record<string, unknown>): string | undefined {
     ?.requestedPackageName ?? undefined;
 }
 
+function eventPackageName(
+  evidence: Record<string, unknown>,
+): string | undefined {
+  return parsePackageImportReference(
+    evidence.eventNameConstantImportBinding,
+  )?.requestedPackageName ?? undefined;
+}
+
 function packageCallEvidenceValid(
   evidence: Record<string, unknown>,
 ): boolean {
@@ -94,6 +109,67 @@ function pendingEvidence(evidence: Record<string, unknown>): string {
   });
 }
 
+function currentEventCalls(
+  db: Db,
+  workspaceId: number,
+  targetRepoId: number,
+): PackageEventCallRow[] {
+  const rows = db.prepare(`SELECT c.id,c.repo_id repoId,
+    c.unresolved_reason unresolvedReason,c.evidence_json evidenceJson
+    FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id
+    WHERE r.workspace_id=? AND r.id<>? AND r.fact_analyzer_version=?
+      AND json_extract(c.evidence_json,
+        '$.eventNameConstantImportBinding.moduleKind')='package'
+    ORDER BY c.id`).all(workspaceId, targetRepoId, ANALYZER_VERSION);
+  return rows.flatMap((row) => {
+    const evidence = parsedEvidence(row.evidenceJson);
+    return evidence && eventPackageName(evidence)
+      && typeof row.id === 'number' && typeof row.repoId === 'number'
+      ? [{
+          id: row.id, repoId: row.repoId, evidence,
+          unresolvedReason: typeof row.unresolvedReason === 'string'
+            ? row.unresolvedReason : null,
+        }] : [];
+  });
+}
+
+function pendingEventEvidence(
+  evidence: Record<string, unknown>,
+): string {
+  const parser = { ...evidence };
+  delete parser.eventNameConstant;
+  delete parser.eventNamePackageConstantResolution;
+  parser.eventNameUnresolvedReason = 'event_name_constant_resolution_pending';
+  parser.eventNameStatus = 'dynamic';
+  parser.eventNameSourceKind = 'dynamic_expression';
+  parser.eventNamePlaceholderKeys = [];
+  return JSON.stringify(parser);
+}
+
+function resetPackageEventCalls(
+  db: Db,
+  workspaceId: number,
+  targetRepoId: number,
+  names: ReadonlySet<string>,
+  batch: PackageInvalidationBatch,
+): boolean {
+  const update = db.prepare(`UPDATE outbound_calls SET event_name_expr=?,
+    unresolved_reason=?,evidence_json=? WHERE id=?`);
+  let matched = false;
+  for (const call of currentEventCalls(db, workspaceId, targetRepoId)) {
+    if (!names.has(eventPackageName(call.evidence) ?? '')) continue;
+    const source = call.evidence.eventNameConstantSourceExpression;
+    if (typeof source !== 'string' || source.length === 0)
+      throw new Error('invalid_current_package_event_constant_evidence');
+    const reason = call.evidence.receiverClassification === 'unproven'
+      ? call.unresolvedReason : 'event_name_constant_resolution_pending';
+    update.run(source, reason, pendingEventEvidence(call.evidence), call.id);
+    batch.affectedCallerRepoIds.add(call.repoId);
+    matched = true;
+  }
+  return matched;
+}
+
 function targetWorkspace(
   db: Db,
   repoId: number,
@@ -142,6 +218,9 @@ export function invalidatePackageTargetFacts(
     batch.affectedCallerRepoIds.add(call.repoId);
     matched = true;
   }
+  matched = resetPackageEventCalls(
+    db, target.workspaceId, targetRepoId, names, batch,
+  ) || matched;
   if (matched || packageIdentityChanged(
     target.packageName, newPackageName,
   )) batch.affectedWorkspaceIds.add(target.workspaceId);

package/src/db/repositories.ts

@@ -7,6 +7,7 @@ import type {
   HandlerRegistrationFact,
   ServiceBindingFact,
   ExecutableSymbolFact,
+  GeneratedConstantFact,
 } from '../types.js';
 import {
   selectCallOwner,
@@ -16,6 +17,9 @@ import {
   PreparedRepositorySnapshotError,
   type PreparedSnapshotFailureCode,
 } from './index-publication-failure.js';
+import {
+  emptyEnvironmentDeclarations,
+} from '../parsers/environment-declarations.js';
 export interface RepoRow {
   id: number;
   name: string;
@@ -92,8 +96,8 @@ export function upsertRepository(
   db.prepare(
     `INSERT INTO repositories(workspace_id,name,absolute_path,relative_path,
       package_name,package_version,dependencies_json,
-      package_public_surface_json,kind,is_git_repo)
-    VALUES(?,?,?,?,?,?,?,?,?,?)
+      package_public_surface_json,environment_declarations_json,kind,is_git_repo)
+    VALUES(?,?,?,?,?,?,?,?,?,?,?)
     ON CONFLICT(workspace_id,absolute_path) DO UPDATE SET
       name=excluded.name,relative_path=excluded.relative_path,
       package_name=excluded.package_name,
@@ -108,6 +112,7 @@ export function upsertRepository(
     r.packageVersion,
     JSON.stringify(r.dependencies ?? {}),
     initialPackagePublicSurface(r.packageName),
+    JSON.stringify(emptyEnvironmentDeclarations()),
     r.kind ?? 'unknown',
     r.isGitRepo ? 1 : 0,
   );
@@ -152,6 +157,7 @@ export function clearRepoFacts(db: Db, repoId: number): void {
     'symbol_calls',
     'handler_registrations',
     'service_bindings',
+    'generated_constants',
     'symbols',
     'diagnostics',
     'files',
@@ -159,6 +165,26 @@ export function clearRepoFacts(db: Db, repoId: number): void {
     db.prepare(`DELETE FROM ${t} WHERE repo_id=?`).run(repoId);
   db.prepare('DELETE FROM search_index WHERE repo=?').run(String(repoId));
 }
+export function insertGeneratedConstants(
+  db: Db,
+  repoId: number,
+  rows: GeneratedConstantFact[],
+): void {
+  const stmt = db.prepare(`INSERT INTO generated_constants(
+    repo_id,source_file,source_line,name,container_name,member_name,value,
+    constant_kind,exported,stable,resolution_status,unresolved_reason,
+    declaration_start_offset,declaration_end_offset,
+    value_start_offset,value_end_offset
+  ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`);
+  for (const row of rows) stmt.run(
+    repoId, row.sourceFile, row.sourceLine, row.name,
+    row.containerName ?? null, row.memberName ?? null, row.value ?? null,
+    row.constantKind, row.exported ? 1 : 0, row.stable ? 1 : 0,
+    row.resolutionStatus, row.unresolvedReason ?? null,
+    row.declarationStartOffset, row.declarationEndOffset,
+    row.valueStartOffset, row.valueEndOffset,
+  );
+}
 export function insertRequires(
   db: Db,
   repoId: number,