@absolutejs/vulnerabilities-postgres 0.3.0 → 0.5.0

package/README.md

@@ -14,8 +14,8 @@ const osvSnapshots = persistence.snapshots();
 ```
 
 The package stores complete provider snapshots and records, appendable sync
-history, tenant-scoped managed findings, correlation observations, risk
-assessments, and expiring distributed refresh leases. Snapshot replacement is
+history, tenant-scoped managed findings, correlation observations, VEX decisions
+and applications, remediation plans and evidence, risk assessments, and expiring distributed refresh leases. Snapshot replacement is
 one Postgres statement, so readers never see a half-replaced record set. Schema
 creation is lazy and idempotent, or can be disabled when application migrations
 own the tables.

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { type FeedSnapshotStore, type FeedSyncRunStore, type ManagedFindingStore, type VulnerabilityObservationStore, type VulnerabilityRiskAssessmentStore } from "@absolutejs/vulnerabilities";
+import { type FeedSnapshotStore, type FeedSyncRunStore, type ManagedFindingStore, type RemediationExecutionStore, type RemediationPlanStore, type RemediationVerificationStore, type VulnerabilityObservationStore, type VulnerabilityRiskAssessmentStore, type VexDecisionStore, type VexFindingApplicationStore } from "@absolutejs/vulnerabilities";
 export type PostgresTag = {
     (strings: TemplateStringsArray, ...values: never[]): PromiseLike<unknown[]>;
     unsafe: (sql: string, ...args: never[]) => PromiseLike<unknown[]>;
@@ -18,9 +18,14 @@ export type PostgresVulnerabilityStore = {
     findings: ManagedFindingStore;
     leases: FeedLeaseStore;
     observations: VulnerabilityObservationStore;
+    remediationExecutions: RemediationExecutionStore;
+    remediationPlans: RemediationPlanStore;
+    remediationVerifications: RemediationVerificationStore;
     riskAssessments: VulnerabilityRiskAssessmentStore;
     snapshots: <T>() => FeedSnapshotStore<T>;
     syncRuns: FeedSyncRunStore;
+    vexApplications: VexFindingApplicationStore;
+    vexDecisions: VexDecisionStore;
 };
 export type CreatePostgresVulnerabilityStoreOptions = {
     ensureSchema?: boolean;

package/dist/index.js

@@ -2,8 +2,13 @@
 // src/index.ts
 import {
   ManagedVulnerabilityFindingSchema,
+  RemediationExecutionSchema,
+  RemediationPlanSchema,
+  RemediationVerificationSchema,
   VulnerabilityObservationSchema,
-  VulnerabilityRiskAssessmentSchema
+  VulnerabilityRiskAssessmentSchema,
+  VexDecisionSchema,
+  VexFindingApplicationSchema
 } from "@absolutejs/vulnerabilities";
 import { Value } from "@sinclair/typebox/value";
 var IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
@@ -59,10 +64,15 @@ var prefixTables = (prefix) => ({
   findings: `${prefix}_findings`,
   leases: `${prefix}_feed_leases`,
   observations: `${prefix}_observations`,
+  remediationExecutions: `${prefix}_remediation_executions`,
+  remediationPlans: `${prefix}_remediation_plans`,
+  remediationVerifications: `${prefix}_remediation_verifications`,
   riskAssessments: `${prefix}_risk_assessments`,
   records: `${prefix}_feed_records`,
   runs: `${prefix}_feed_sync_runs`,
-  snapshots: `${prefix}_feed_snapshots`
+  snapshots: `${prefix}_feed_snapshots`,
+  vexApplications: `${prefix}_vex_applications`,
+  vexDecisions: `${prefix}_vex_decisions`
 });
 var vulnerabilityPostgresSchemaSql = (tablePrefix = "vulnerability") => {
   if (!IDENTIFIER.test(tablePrefix))
@@ -149,6 +159,71 @@ var vulnerabilityPostgresSchemaSql = (tablePrefix = "vulnerability") => {
     CREATE INDEX IF NOT EXISTS ${table.riskAssessments}_tenant_due_idx
       ON ${table.riskAssessments} (tenant_id, remediate_by)
       WHERE remediate_by IS NOT NULL;
+    CREATE TABLE IF NOT EXISTS ${table.remediationPlans} (
+      tenant_id text NOT NULL,
+      plan_id text NOT NULL,
+      status text NOT NULL,
+      created_at timestamptz NOT NULL,
+      value jsonb NOT NULL,
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      PRIMARY KEY (tenant_id, plan_id)
+    );
+    CREATE INDEX IF NOT EXISTS ${table.remediationPlans}_tenant_status_idx
+      ON ${table.remediationPlans} (tenant_id, status, created_at DESC);
+    CREATE TABLE IF NOT EXISTS ${table.remediationExecutions} (
+      tenant_id text NOT NULL,
+      execution_id text NOT NULL,
+      plan_id text NOT NULL,
+      status text NOT NULL,
+      started_at timestamptz NOT NULL,
+      completed_at timestamptz,
+      value jsonb NOT NULL,
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      PRIMARY KEY (tenant_id, execution_id)
+    );
+    CREATE INDEX IF NOT EXISTS ${table.remediationExecutions}_tenant_plan_idx
+      ON ${table.remediationExecutions} (tenant_id, plan_id, started_at DESC);
+    CREATE TABLE IF NOT EXISTS ${table.remediationVerifications} (
+      tenant_id text NOT NULL,
+      verification_id text NOT NULL,
+      execution_id text NOT NULL,
+      plan_id text NOT NULL,
+      status text NOT NULL,
+      observed_at timestamptz NOT NULL,
+      value jsonb NOT NULL,
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      PRIMARY KEY (tenant_id, verification_id)
+    );
+    CREATE INDEX IF NOT EXISTS ${table.remediationVerifications}_tenant_execution_idx
+      ON ${table.remediationVerifications} (tenant_id, execution_id, observed_at DESC);
+    CREATE TABLE IF NOT EXISTS ${table.vexDecisions} (
+      tenant_id text NOT NULL,
+      decision_id text NOT NULL,
+      product_id text NOT NULL,
+      vulnerability_id text NOT NULL,
+      status text NOT NULL,
+      created_at timestamptz NOT NULL,
+      expires_at timestamptz,
+      value jsonb NOT NULL,
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      PRIMARY KEY (tenant_id, decision_id)
+    );
+    CREATE INDEX IF NOT EXISTS ${table.vexDecisions}_tenant_product_idx
+      ON ${table.vexDecisions} (tenant_id, product_id, created_at DESC);
+    CREATE INDEX IF NOT EXISTS ${table.vexDecisions}_tenant_vulnerability_idx
+      ON ${table.vexDecisions} (tenant_id, vulnerability_id, created_at DESC);
+    CREATE TABLE IF NOT EXISTS ${table.vexApplications} (
+      tenant_id text NOT NULL,
+      finding_id text NOT NULL,
+      decision_id text NOT NULL,
+      applied_at timestamptz NOT NULL,
+      ended_at timestamptz,
+      value jsonb NOT NULL,
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      PRIMARY KEY (tenant_id, finding_id)
+    );
+    CREATE INDEX IF NOT EXISTS ${table.vexApplications}_tenant_decision_idx
+      ON ${table.vexApplications} (tenant_id, decision_id, applied_at DESC);
     CREATE TABLE IF NOT EXISTS ${table.leases} (
       feed_id text PRIMARY KEY,
       owner_id text NOT NULL,
@@ -552,6 +627,293 @@ var createPostgresVulnerabilityStore = (options) => {
     save: async (tenantId, assessment) => saveRiskAssessments(tenantId, [assessment]),
     saveMany: saveRiskAssessments
   };
+  const parseRemediationPlan = (value) => {
+    const plan = json(value, "Remediation plan");
+    if (!Value.Check(RemediationPlanSchema, plan))
+      throw new Error("Stored remediation plan is invalid");
+    return plan;
+  };
+  const remediationPlans = {
+    get: async (tenantId, planId) => {
+      await ensureSchema();
+      const rows = await sql`
+        SELECT value FROM ${sql.unsafe(table.remediationPlans)}
+        WHERE tenant_id = ${requiredText(tenantId, "Tenant id")}
+          AND plan_id = ${requiredText(planId, "Remediation plan id")}
+      `;
+      return rows[0] ? parseRemediationPlan(rows[0].value) : null;
+    },
+    list: async (filter) => {
+      await ensureSchema();
+      const tenantId = requiredText(filter.tenantId, "Tenant id");
+      const status = filter.status ?? null;
+      const rows = await sql`
+        SELECT value FROM ${sql.unsafe(table.remediationPlans)}
+        WHERE tenant_id = ${tenantId}
+          AND (${status}::text IS NULL OR status = ${status})
+        ORDER BY created_at DESC, plan_id
+        LIMIT ${limit(filter.limit)}
+      `;
+      return rows.map(({ value }) => parseRemediationPlan(value));
+    },
+    save: async (tenantId, plan) => {
+      await ensureSchema();
+      const planId = plan.id;
+      if (!Value.Check(RemediationPlanSchema, plan))
+        throw new Error(`Remediation plan ${planId} is invalid`);
+      await sql`
+        INSERT INTO ${sql.unsafe(table.remediationPlans)} (
+          tenant_id, plan_id, status, created_at, value, updated_at
+        ) VALUES (
+          ${requiredText(tenantId, "Tenant id")}, ${plan.id}, ${plan.status},
+          ${plan.createdAt}::timestamptz, ${JSON.stringify(plan)}::jsonb, now()
+        )
+        ON CONFLICT (tenant_id, plan_id) DO UPDATE SET
+          status = EXCLUDED.status,
+          created_at = EXCLUDED.created_at,
+          value = EXCLUDED.value,
+          updated_at = now()
+      `;
+    }
+  };
+  const parseRemediationExecution = (value) => {
+    const execution = json(value, "Remediation execution");
+    if (!Value.Check(RemediationExecutionSchema, execution))
+      throw new Error("Stored remediation execution is invalid");
+    return execution;
+  };
+  const remediationExecutions = {
+    get: async (tenantId, executionId) => {
+      await ensureSchema();
+      const rows = await sql`
+        SELECT value FROM ${sql.unsafe(table.remediationExecutions)}
+        WHERE tenant_id = ${requiredText(tenantId, "Tenant id")}
+          AND execution_id = ${requiredText(executionId, "Remediation execution id")}
+      `;
+      return rows[0] ? parseRemediationExecution(rows[0].value) : null;
+    },
+    list: async (tenantId, planId) => {
+      await ensureSchema();
+      const rows = await sql`
+        SELECT value FROM ${sql.unsafe(table.remediationExecutions)}
+        WHERE tenant_id = ${requiredText(tenantId, "Tenant id")}
+          AND plan_id = ${requiredText(planId, "Remediation plan id")}
+        ORDER BY started_at DESC, execution_id
+        LIMIT 1000
+      `;
+      return rows.map(({ value }) => parseRemediationExecution(value));
+    },
+    save: async (tenantId, execution) => {
+      await ensureSchema();
+      const executionId = execution.id;
+      if (!Value.Check(RemediationExecutionSchema, execution))
+        throw new Error(`Remediation execution ${executionId} is invalid`);
+      await sql`
+        INSERT INTO ${sql.unsafe(table.remediationExecutions)} (
+          tenant_id, execution_id, plan_id, status, started_at, completed_at,
+          value, updated_at
+        ) VALUES (
+          ${requiredText(tenantId, "Tenant id")}, ${execution.id},
+          ${execution.planId}, ${execution.status},
+          ${execution.startedAt}::timestamptz,
+          ${execution.completedAt}::timestamptz,
+          ${JSON.stringify(execution)}::jsonb, now()
+        )
+        ON CONFLICT (tenant_id, execution_id) DO UPDATE SET
+          plan_id = EXCLUDED.plan_id,
+          status = EXCLUDED.status,
+          started_at = EXCLUDED.started_at,
+          completed_at = EXCLUDED.completed_at,
+          value = EXCLUDED.value,
+          updated_at = now()
+      `;
+    }
+  };
+  const parseRemediationVerification = (value) => {
+    const verification = json(value, "Remediation verification");
+    if (!Value.Check(RemediationVerificationSchema, verification))
+      throw new Error("Stored remediation verification is invalid");
+    return verification;
+  };
+  const remediationVerifications = {
+    get: async (tenantId, verificationId) => {
+      await ensureSchema();
+      const rows = await sql`
+        SELECT value FROM ${sql.unsafe(table.remediationVerifications)}
+        WHERE tenant_id = ${requiredText(tenantId, "Tenant id")}
+          AND verification_id = ${requiredText(verificationId, "Remediation verification id")}
+      `;
+      return rows[0] ? parseRemediationVerification(rows[0].value) : null;
+    },
+    list: async (tenantId, executionId) => {
+      await ensureSchema();
+      const rows = await sql`
+        SELECT value FROM ${sql.unsafe(table.remediationVerifications)}
+        WHERE tenant_id = ${requiredText(tenantId, "Tenant id")}
+          AND execution_id = ${requiredText(executionId, "Remediation execution id")}
+        ORDER BY observed_at DESC, verification_id
+        LIMIT 1000
+      `;
+      return rows.map(({ value }) => parseRemediationVerification(value));
+    },
+    save: async (tenantId, verification) => {
+      await ensureSchema();
+      const verificationId = verification.id;
+      if (!Value.Check(RemediationVerificationSchema, verification))
+        throw new Error(`Remediation verification ${verificationId} is invalid`);
+      await sql`
+        INSERT INTO ${sql.unsafe(table.remediationVerifications)} (
+          tenant_id, verification_id, execution_id, plan_id, status,
+          observed_at, value, updated_at
+        ) VALUES (
+          ${requiredText(tenantId, "Tenant id")}, ${verification.id},
+          ${verification.executionId}, ${verification.planId},
+          ${verification.status}, ${verification.observedAt}::timestamptz,
+          ${JSON.stringify(verification)}::jsonb, now()
+        )
+        ON CONFLICT (tenant_id, verification_id) DO UPDATE SET
+          execution_id = EXCLUDED.execution_id,
+          plan_id = EXCLUDED.plan_id,
+          status = EXCLUDED.status,
+          observed_at = EXCLUDED.observed_at,
+          value = EXCLUDED.value,
+          updated_at = now()
+      `;
+    }
+  };
+  const parseVexDecision = (value) => {
+    const decision = json(value, "VEX decision");
+    if (!Value.Check(VexDecisionSchema, decision))
+      throw new Error("Stored VEX decision is invalid");
+    return decision;
+  };
+  const saveVexDecisions = async (tenantId, decisions) => {
+    await ensureSchema();
+    const normalizedTenantId = requiredText(tenantId, "Tenant id");
+    if (decisions.length === 0)
+      return;
+    for (const decision of decisions) {
+      const decisionId = decision.id;
+      if (!Value.Check(VexDecisionSchema, decision))
+        throw new Error(`VEX decision ${decisionId} is invalid`);
+    }
+    const payload = JSON.stringify(decisions.map((decision) => ({
+      created_at: decision.createdAt,
+      decision_id: decision.id,
+      expires_at: decision.expiresAt,
+      product_id: decision.productId,
+      status: decision.status,
+      value: decision,
+      vulnerability_id: decision.vulnerabilityId
+    })));
+    await sql`
+      INSERT INTO ${sql.unsafe(table.vexDecisions)} (
+        tenant_id, decision_id, product_id, vulnerability_id, status,
+        created_at, expires_at, value, updated_at
+      )
+      SELECT
+        ${normalizedTenantId}, item.decision_id, item.product_id,
+        item.vulnerability_id, item.status, item.created_at::timestamptz,
+        item.expires_at::timestamptz, item.value, now()
+      FROM jsonb_to_recordset(${payload}::jsonb) AS item(
+        decision_id text, product_id text, vulnerability_id text, status text,
+        created_at text, expires_at text, value jsonb
+      )
+      ON CONFLICT (tenant_id, decision_id) DO UPDATE SET
+        product_id = EXCLUDED.product_id,
+        vulnerability_id = EXCLUDED.vulnerability_id,
+        status = EXCLUDED.status,
+        created_at = EXCLUDED.created_at,
+        expires_at = EXCLUDED.expires_at,
+        value = EXCLUDED.value,
+        updated_at = now()
+    `;
+  };
+  const vexDecisions = {
+    get: async (tenantId, decisionId) => {
+      await ensureSchema();
+      const rows = await sql`
+        SELECT value FROM ${sql.unsafe(table.vexDecisions)}
+        WHERE tenant_id = ${requiredText(tenantId, "Tenant id")}
+          AND decision_id = ${requiredText(decisionId, "Decision id")}
+      `;
+      return rows[0] ? parseVexDecision(rows[0].value) : null;
+    },
+    list: async (filter) => {
+      await ensureSchema();
+      const tenantId = requiredText(filter.tenantId, "Tenant id");
+      const productId = filter.productId?.trim() || null;
+      const vulnerabilityId = filter.vulnerabilityId?.trim() || null;
+      const rows = await sql`
+        SELECT value FROM ${sql.unsafe(table.vexDecisions)}
+        WHERE tenant_id = ${tenantId}
+          AND (${productId}::text IS NULL OR product_id = ${productId})
+          AND (${vulnerabilityId}::text IS NULL OR vulnerability_id = ${vulnerabilityId})
+        ORDER BY created_at DESC, decision_id
+        LIMIT ${limit(filter.limit)}
+      `;
+      return rows.map(({ value }) => parseVexDecision(value));
+    },
+    save: async (tenantId, decision) => saveVexDecisions(tenantId, [decision]),
+    saveMany: saveVexDecisions
+  };
+  const parseVexApplication = (value) => {
+    const application = json(value, "VEX application");
+    if (!Value.Check(VexFindingApplicationSchema, application))
+      throw new Error("Stored VEX application is invalid");
+    return application;
+  };
+  const saveVexApplications = async (applications) => {
+    await ensureSchema();
+    if (applications.length === 0)
+      return;
+    for (const application of applications) {
+      const findingId = application.findingId;
+      if (!Value.Check(VexFindingApplicationSchema, application))
+        throw new Error(`VEX application ${findingId} is invalid`);
+    }
+    const payload = JSON.stringify(applications.map((application) => ({
+      applied_at: application.appliedAt,
+      decision_id: application.decisionId,
+      ended_at: application.endedAt,
+      finding_id: application.findingId,
+      tenant_id: application.tenantId,
+      value: application
+    })));
+    await sql`
+      INSERT INTO ${sql.unsafe(table.vexApplications)} (
+        tenant_id, finding_id, decision_id, applied_at, ended_at, value,
+        updated_at
+      )
+      SELECT
+        item.tenant_id, item.finding_id, item.decision_id,
+        item.applied_at::timestamptz, item.ended_at::timestamptz,
+        item.value, now()
+      FROM jsonb_to_recordset(${payload}::jsonb) AS item(
+        tenant_id text, finding_id text, decision_id text, applied_at text,
+        ended_at text, value jsonb
+      )
+      ON CONFLICT (tenant_id, finding_id) DO UPDATE SET
+        decision_id = EXCLUDED.decision_id,
+        applied_at = EXCLUDED.applied_at,
+        ended_at = EXCLUDED.ended_at,
+        value = EXCLUDED.value,
+        updated_at = now()
+    `;
+  };
+  const vexApplications = {
+    get: async (tenantId, findingId) => {
+      await ensureSchema();
+      const rows = await sql`
+        SELECT value FROM ${sql.unsafe(table.vexApplications)}
+        WHERE tenant_id = ${requiredText(tenantId, "Tenant id")}
+          AND finding_id = ${requiredText(findingId, "Finding id")}
+      `;
+      return rows[0] ? parseVexApplication(rows[0].value) : null;
+    },
+    save: async (application) => saveVexApplications([application]),
+    saveMany: saveVexApplications
+  };
   const leases = {
     acquire: async (request) => {
       await ensureSchema();
@@ -594,9 +956,14 @@ var createPostgresVulnerabilityStore = (options) => {
     findings,
     leases,
     observations,
+    remediationExecutions,
+    remediationPlans,
+    remediationVerifications,
     riskAssessments,
     snapshots,
-    syncRuns
+    syncRuns,
+    vexApplications,
+    vexDecisions
   };
 };
 export {

package/dist/manifest.js

@@ -9,7 +9,7 @@ var manifest = defineManifest()({
     intents: [
       "persist vulnerability intelligence",
       "retain vulnerability sync history",
-      "store managed vulnerability findings, observations, and risk assessments"
+      "store managed vulnerability findings, VEX decisions, remediation evidence, and risk assessments"
     ],
     keywords: ["vulnerabilities", "Postgres", "CVE", "feed-history"],
     protocols: ["PostgreSQL", "AbsoluteJS vulnerability contracts"]
@@ -17,7 +17,7 @@ var manifest = defineManifest()({
   identity: {
     accent: "#336791",
     category: "operations",
-    description: "Durable Postgres snapshots, sync history, findings, observations, risk assessments, and distributed refresh leases.",
+    description: "Durable Postgres snapshots, findings, VEX decisions, remediation evidence, risk assessments, and distributed refresh leases.",
     docsUrl: "https://github.com/absolutejs/vulnerabilities-postgres",
     name: "@absolutejs/vulnerabilities-postgres",
     tagline: "Keep vulnerability intelligence durable and auditable."
@@ -30,7 +30,7 @@ var manifest = defineManifest()({
       requires: {
         env: [
           {
-            description: "Postgres connection string for vulnerability intelligence, findings, observations, and risk assessments",
+            description: "Postgres connection string for vulnerability intelligence, findings, VEX decisions, remediation evidence, and risk assessments",
             example: "postgres://user:pass@host/db",
             key: "DATABASE_URL",
             secret: true
@@ -45,7 +45,7 @@ var manifest = defineManifest()({
         ],
         services: [
           {
-            description: "Stores vulnerability intelligence, findings, observations, risk assessments, and leases",
+            description: "Stores vulnerability intelligence, findings, VEX decisions, remediation evidence, risk assessments, and leases",
             id: "postgres"
           }
         ]

package/dist/manifest.json

@@ -8,7 +8,7 @@
 		"intents": [
 			"persist vulnerability intelligence",
 			"retain vulnerability sync history",
-			"store managed vulnerability findings, observations, and risk assessments"
+			"store managed vulnerability findings, VEX decisions, remediation evidence, and risk assessments"
 		],
 		"keywords": [
 			"vulnerabilities",
@@ -24,7 +24,7 @@
 	"identity": {
 		"accent": "#336791",
 		"category": "operations",
-		"description": "Durable Postgres snapshots, sync history, findings, observations, risk assessments, and distributed refresh leases.",
+		"description": "Durable Postgres snapshots, findings, VEX decisions, remediation evidence, risk assessments, and distributed refresh leases.",
 		"docsUrl": "https://github.com/absolutejs/vulnerabilities-postgres",
 		"name": "@absolutejs/vulnerabilities-postgres",
 		"tagline": "Keep vulnerability intelligence durable and auditable."
@@ -37,7 +37,7 @@
 			"requires": {
 				"env": [
 					{
-						"description": "Postgres connection string for vulnerability intelligence, findings, observations, and risk assessments",
+						"description": "Postgres connection string for vulnerability intelligence, findings, VEX decisions, remediation evidence, and risk assessments",
 						"example": "postgres://user:pass@host/db",
 						"key": "DATABASE_URL",
 						"secret": true
@@ -52,7 +52,7 @@
 				],
 				"services": [
 					{
-						"description": "Stores vulnerability intelligence, findings, observations, risk assessments, and leases",
+						"description": "Stores vulnerability intelligence, findings, VEX decisions, remediation evidence, risk assessments, and leases",
 						"id": "postgres"
 					}
 				]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@absolutejs/vulnerabilities-postgres",
-  "version": "0.3.0",
-  "description": "Durable Postgres feeds, findings, observations, risk assessments, and refresh leases for AbsoluteJS vulnerability management.",
+  "version": "0.5.0",
+  "description": "Durable Postgres feeds, findings, VEX decisions, remediation evidence, risk assessments, and refresh leases for AbsoluteJS vulnerability management.",
   "type": "module",
   "license": "BSL-1.1",
   "author": "Alex Kahn",
@@ -53,7 +53,7 @@
   ],
   "dependencies": {
     "@absolutejs/manifest": "0.3.0",
-    "@absolutejs/vulnerabilities": "0.7.0",
+    "@absolutejs/vulnerabilities": "0.8.0",
     "@sinclair/typebox": "0.34.52"
   },
   "peerDependencies": {