@nebulacomponents/citable 1.18.2 → 1.20.0

package/src/evidence/determination.js

@@ -0,0 +1,157 @@
+/**
+ * Coverage requirements for determinations.
+ *
+ * A requirement describes the population a conclusion is allowed to speak
+ * about. It is deliberately separate from the crawler's execution status:
+ * observing one page can support a page-local positive finding even when a
+ * corpus-wide absence claim is not supportable.
+ */
+export const REQUIREMENTS = Object.freeze({
+  PAGE_RESOURCE: 'page_resource',
+  EVALUATED_SUBSET: 'evaluated_subset',
+  DECLARED_SAMPLE: 'declared_sample',
+  EXHAUSTIVE_SCOPE: 'exhaustive_requested_scope',
+  RENDERED_RESOURCE: 'rendered_resource',
+  PROVIDER_BOUNDED: 'provider_bounded',
+});
+
+const VALID_REQUIREMENTS = new Set(Object.values(REQUIREMENTS));
+
+export function isCoverageRequirement(value) {
+  return VALID_REQUIREMENTS.has(value);
+}
+
+function population(coverage) {
+  return coverage?.populations && typeof coverage.populations === 'object'
+    ? coverage.populations
+    : {};
+}
+
+function normalizedUrl(value) {
+  if (typeof value !== 'string' || !value) return null;
+  try {
+    const url = new URL(value);
+    url.hash = '';
+    return url.href;
+  } catch {
+    return value.split('#', 1)[0];
+  }
+}
+
+function resourcesFor(coverage) {
+  return Array.isArray(coverage?.resources) ? coverage.resources : [];
+}
+
+function resourceForSubject(coverage, subject) {
+  const candidates = [subject?.url, subject?.identifier].map(normalizedUrl).filter(Boolean);
+  return resourcesFor(coverage).find((resource) => {
+    const resourceUrl = normalizedUrl(resource?.url || resource?.normalized_url);
+    return resourceUrl && candidates.includes(resourceUrl);
+  }) || null;
+}
+
+function completeCoverage(coverage) {
+  const p = population(coverage);
+  return coverage?.coverage_status === 'complete'
+    && p.unvisited === 0
+    && p.failed === 0
+    && p.indeterminate === 0
+    && p.valid_but_unevaluated === 0
+    && p.evaluated > 0;
+}
+
+function result(status, extra = {}) {
+  return { status, ...extra };
+}
+
+function evaluatePageResource(coverage, subject, rendered = false) {
+  const resource = resourceForSubject(coverage, subject);
+  if (!resource) return result('indeterminate', { reason: 'resource_not_observed' });
+  const state = resource.state || (resource.evaluation ? 'evaluated' : resource.classification?.state);
+  if (state !== 'evaluated') {
+    return result('indeterminate', { reason: 'resource_not_evaluated', resource_id: resource.resource_id });
+  }
+  if (rendered && resource.rendered !== true && resource.rendering_status !== 'complete') {
+    return result('indeterminate', { reason: 'rendered_observation_unavailable', resource_id: resource.resource_id });
+  }
+  return result('supported', {
+    resource_id: resource.resource_id,
+    population: 'evaluated_resource',
+  });
+}
+
+/**
+ * Evaluate whether a coverage envelope satisfies one determination contract.
+ * The returned status is intentionally limited to supported, qualified,
+ * indeterminate, and not_applicable, matching the finding/run contracts.
+ */
+export function evaluateRequirement(requirement, coverage, subject = null) {
+  if (!VALID_REQUIREMENTS.has(requirement)) throw new TypeError(`unknown coverage requirement: ${requirement}`);
+
+  if (requirement === REQUIREMENTS.PAGE_RESOURCE) return evaluatePageResource(coverage, subject);
+  if (requirement === REQUIREMENTS.RENDERED_RESOURCE) return evaluatePageResource(coverage, subject, true);
+
+  if (requirement === REQUIREMENTS.DECLARED_SAMPLE) {
+    const sample = coverage?.sample;
+    const numerator = sample?.numerator;
+    const denominator = sample?.denominator;
+    if (!Number.isInteger(numerator) || !Number.isInteger(denominator) || denominator < 1 || numerator < 0 || numerator > denominator) {
+      return result('indeterminate', { reason: 'sample_denominator_unavailable' });
+    }
+    return { status: 'qualified', population: 'evaluated_subset', numerator, denominator };
+  }
+
+  if (requirement === REQUIREMENTS.PROVIDER_BOUNDED) {
+    const p = population(coverage);
+    if (!Number.isInteger(p.evaluated) || p.evaluated < 1) return result('indeterminate', { reason: 'no_evaluated_resources' });
+    return result('qualified', { population: 'provider_bounded', denominator: p.evaluated });
+  }
+
+  if (requirement === REQUIREMENTS.EVALUATED_SUBSET) {
+    // A subject-bearing determination cannot borrow aggregate subset counts:
+    // the named page/URL must itself be an evaluator-completed resource.
+    if (subject?.type === 'page' || subject?.type === 'url') {
+      return evaluatePageResource(coverage, subject);
+    }
+    const p = population(coverage);
+    if (!Number.isInteger(p.evaluated) || p.evaluated < 1) return result('indeterminate', { reason: 'no_evaluated_resources' });
+    return result(coverage?.coverage_status === 'complete' ? 'supported' : 'qualified', {
+      population: 'evaluated_subset', denominator: p.evaluated,
+    });
+  }
+
+  // Exhaustive scope is the only requirement that may support a corpus-wide
+  // absence claim. A completed execution with zero resources is not evidence
+  // of absence, so require at least one evaluated resource.
+  if (completeCoverage(coverage)) {
+    return result('supported', { population: 'requested_scope', denominator: population(coverage).evaluated });
+  }
+  return result('indeterminate', { reason: 'coverage_incomplete' });
+}
+
+/**
+ * Apply coverage semantics to a determination produced by a detector or
+ * downstream consumer. Positive page-local observations are preserved; a
+ * negative exhaustive conclusion is downgraded when its corpus is incomplete.
+ */
+export function propagateDetermination(determination, coverage) {
+  if (!determination || typeof determination !== 'object') throw new TypeError('determination must be an object');
+  const current = determination.status;
+  if (!['supported', 'qualified', 'indeterminate', 'not_applicable'].includes(current)) {
+    throw new TypeError(`invalid determination status: ${current}`);
+  }
+  if (current !== 'supported') return { ...determination };
+  if (determination.polarity !== 'negative' || !determination.requirement) return { ...determination };
+  const evaluated = evaluateRequirement(determination.requirement, coverage, determination.subject);
+  if (evaluated.status === 'supported') return { ...determination };
+  return { ...determination, status: evaluated.status, reason: evaluated.reason || 'coverage_requirement_unsatisfied' };
+}
+
+export function requirementForDetector(detector, hit = null) {
+  if (!detector || !isCoverageRequirement(detector.coverage_requirement)) {
+    throw new TypeError(`detector ${detector?.id ?? '?'} must declare a valid coverage_requirement`);
+  }
+  // The detector declaration is authoritative. Subject shape must never
+  // silently weaken an exhaustive or rendered-resource contract.
+  return detector.coverage_requirement;
+}

package/src/evidence/downstream.js

@@ -0,0 +1,110 @@
+/**
+ * Shared semantics for consumers that summarize or act on an evidence package.
+ * A consumer may describe the evaluated subset, but may not widen it to the
+ * requested scope when collection was incomplete or empty.
+ */
+const DETERMINATION_STATUSES = new Set(['supported', 'qualified', 'indeterminate', 'not_applicable']);
+import { validateAgainst } from '../shared/schemaValidator.js';
+
+function populations(coverage) {
+  return coverage?.populations && typeof coverage.populations === 'object'
+    ? coverage.populations : {};
+}
+
+function contractStatus(coverage) {
+  if (!coverage || typeof coverage !== 'object') return { valid: false, errors: ['coverage artifact unavailable'] };
+  const result = validateAgainst('audit-coverage.schema.json', coverage);
+  return { valid: result.valid, errors: result.errors || [] };
+}
+
+export function coverageDenominator(coverage) {
+  const value = populations(coverage).evaluated;
+  return Number.isInteger(value) && value > 0 ? value : 0;
+}
+
+export function completeLocalCoverage(pages, baseUrl = 'https://example.test') {
+  const origin = new URL(baseUrl).origin;
+  const resources = pages.map((page, index) => ({
+    resource_id: `LOCAL-${index + 1}`,
+    normalized_url: page.url || `${origin}/page-${index + 1}`,
+    original_urls: [page.url || `${origin}/page-${index + 1}`],
+    state: 'evaluated',
+    evaluation: {},
+  }));
+  const n = resources.length;
+  return {
+    schema_version: 1,
+    normalization_version: 'url-identity-v1',
+    requested_scope: { start_url: `${origin}/`, origin, max_pages: 500, time_budget_seconds: 1800 },
+    discovery: { status: 'complete', methods: ['built_output'], limitations: [] },
+    populations: { discovered: n, eligible: n, excluded: 0, attempted: n, retrieved: n, valid_resource: n, evaluated: n, valid_but_unevaluated: 0, failed: 0, indeterminate: 0, unvisited: 0 },
+    resources,
+    stop_reason: 'frontier_exhausted',
+    coverage_status: 'complete',
+    reconciliation: { valid: true, errors: [] },
+    limitations: [],
+  };
+}
+
+export function downstreamStatus(coverage) {
+  if (!coverage) return 'indeterminate';
+  const contract = contractStatus(coverage);
+  const denominator = coverageDenominator(coverage);
+  const p = populations(coverage);
+  const completePopulation = p.failed === 0 && p.indeterminate === 0 && p.unvisited === 0 && p.valid_but_unevaluated === 0;
+  if (coverage.coverage_status === 'complete' && denominator > 0 && completePopulation && contract.valid && coverage.reconciliation?.valid === true) return 'supported';
+  if (coverage.coverage_status === 'truncated' && denominator > 0
+    && contract.valid && coverage.reconciliation?.valid === true) return 'qualified';
+  return 'indeterminate';
+}
+
+export function coverageLimitations(coverage) {
+  if (!coverage) return ['coverage artifact unavailable; scope is not established'];
+  const p = populations(coverage);
+  const limitations = Array.isArray(coverage.limitations) ? [...coverage.limitations] : [];
+  const contract = contractStatus(coverage);
+  if (!contract.valid) limitations.push('coverage artifact does not satisfy the coverage contract');
+  if (coverage.coverage_status !== 'complete') {
+    limitations.push(`coverage is ${coverage.coverage_status || 'unknown'}; conclusions are limited to evaluated resources`);
+  }
+  for (const key of ['failed', 'indeterminate', 'unvisited', 'valid_but_unevaluated']) {
+    if (Number.isInteger(p[key]) && p[key] > 0) limitations.push(`${p[key]} ${key} resource(s) omitted from determinations`);
+  }
+  return [...new Set(limitations)];
+}
+
+export function downstreamEnvelope(coverage, extra = {}) {
+  const p = populations(coverage);
+  const denominator = coverageDenominator(coverage);
+  const status = downstreamStatus(coverage);
+  if (!DETERMINATION_STATUSES.has(status)) throw new Error(`invalid downstream determination status: ${status}`);
+  return {
+    coverage_status: coverage?.coverage_status || 'indeterminate',
+    determination_status: status,
+    evidence_scope: {
+      requirement: 'evaluated_subset',
+      satisfaction: status,
+      coverage_ref: coverage ? 'coverage.json' : null,
+      resource_ids: Array.isArray(coverage?.resources)
+        ? coverage.resources.map((resource) => resource.resource_id).filter(Boolean)
+        : [],
+      population: denominator > 0 ? 'evaluated_subset' : 'none_observed',
+      evaluated: denominator,
+      eligible: Number.isInteger(p.eligible) ? p.eligible : null,
+      excluded: Number.isInteger(p.excluded) ? p.excluded : null,
+      failed: Number.isInteger(p.failed) ? p.failed : null,
+      indeterminate: Number.isInteger(p.indeterminate) ? p.indeterminate : null,
+      unvisited: Number.isInteger(p.unvisited) ? p.unvisited : null,
+      denominator,
+    },
+    limitations: coverageLimitations(coverage),
+    ...extra,
+  };
+}
+
+/** Return null for empty evidence; never divide by a convenient zero. */
+export function scoreFromCoverage(numerator, coverage, { scale = 100 } = {}) {
+  const denominator = coverageDenominator(coverage);
+  if (!Number.isFinite(numerator) || denominator === 0) return null;
+  return Math.round((numerator / denominator) * scale);
+}

package/src/evidence/hashes.js

@@ -0,0 +1,109 @@
+import { sha256 } from '../shared/io.js';
+
+export const EVIDENCE_HASH_SCHEMA_VERSION = 'evidence-hashes-v1';
+
+/**
+ * Canonical JSON used for evidence representations. Object key order is not
+ * evidence; array order is preserved because it can be meaningful (for
+ * example, JSON-LD graph order and an evaluator's finding order).
+ */
+export function canonicalEvidenceJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalEvidenceJson).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalEvidenceJson(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function bytes(value) {
+  if (Buffer.isBuffer(value)) return value;
+  if (value instanceof Uint8Array) return Buffer.from(value);
+  return Buffer.from(String(value ?? ''), 'utf8');
+}
+
+function hashBytes(value) {
+  return sha256(bytes(value));
+}
+
+function hashCanonical(value) {
+  return sha256(canonicalEvidenceJson(value));
+}
+
+/** Normalize only extraction whitespace; do not remove content or metadata. */
+export function normalizeExtractedText(value) {
+  return String(value ?? '').replace(/\s+/g, ' ').trim();
+}
+
+/**
+ * Build named hashes for representations that are actually available.
+ * Null means that representation was not observed; it is never synthesized
+ * from another layer.
+ */
+export function createEvidenceHashes({
+  responseBody,
+  extractedText,
+  structuredData,
+  renderedDom,
+  evidence,
+  artifact,
+} = {}) {
+  return {
+    hash_schema_version: EVIDENCE_HASH_SCHEMA_VERSION,
+    response_body_hash: responseBody == null ? null : hashBytes(responseBody),
+    rendered_dom_hash: renderedDom == null ? null : hashBytes(renderedDom),
+    extracted_text_hash: extractedText == null ? null : hashBytes(normalizeExtractedText(extractedText)),
+    structured_data_hash: structuredData == null ? null : hashCanonical(structuredData),
+    evidence_hash: evidence == null ? null : hashCanonical(evidence),
+    artifact_hash: artifact == null ? null : hashCanonical(artifact),
+  };
+}
+
+/** Explicit legacy meaning for snapshots and connector payloads during migration. */
+export const LEGACY_CONTENT_HASH_SEMANTICS = 'extracted_text_v1';
+
+/**
+ * Canonical shape of the persisted pages/index.json record. The artifact hash
+ * is intentionally excluded so the hash does not contain itself; verification
+ * recomputes this exact record shape and compares it with the stored claim.
+ */
+export function pageArtifactRecord(page) {
+  return {
+    url: page.url,
+    status: page.status,
+    title: page.title,
+    canonicals: page.canonicals,
+    noindex: page.noindex,
+    wordCount: page.wordCount,
+    sourceFile: page.sourceFile,
+    requested_url: page.requestedUrl ?? null,
+    effective_url: page.url,
+    declared_canonical_url: page.canonicals?.[0] ?? null,
+    resource_id: page.urlIdentity?.resource_id ?? null,
+    url_identity: page.urlIdentity ?? null,
+    hash_schema_version: page.hash_schema_version ?? null,
+    response_body_hash: page.response_body_hash ?? null,
+    rendered_dom_hash: page.rendered_dom_hash ?? null,
+    extracted_text_hash: page.extracted_text_hash ?? null,
+    structured_data_hash: page.structured_data_hash ?? null,
+    evidence_hash: page.evidence_hash ?? null,
+    contentHash: page.extracted_text_hash ?? null,
+    hash_semantics: LEGACY_CONTENT_HASH_SEMANTICS,
+  };
+}
+
+export function hashPageArtifact(page) {
+  return hashCanonical(pageArtifactRecord(page));
+}
+
+/** Bind a determination/finding to the representation its hash actually covers. */
+export function evidenceIdentity(hashes, representation) {
+  const field = `${representation}_hash`;
+  const hash = hashes?.[field];
+  if (!['response_body', 'rendered_dom', 'extracted_text', 'structured_data', 'evidence', 'artifact'].includes(representation)) {
+    throw new TypeError(`unknown evidence representation: ${representation}`);
+  }
+  if (typeof hash !== 'string' || !/^[a-f0-9]{64}$/.test(hash)) {
+    throw new Error(`evidence representation is unavailable: ${representation}`);
+  }
+  return { hash_schema_version: hashes.hash_schema_version ?? EVIDENCE_HASH_SCHEMA_VERSION, representation, hash };
+}

package/src/evidence/run.js

@@ -23,6 +23,26 @@ function gitInfo(root) {
   }
 }
 
+function assertSafeArtifactPath(runDir, relativePath) {
+  if (typeof relativePath !== 'string' || !relativePath || path.isAbsolute(relativePath) || relativePath.includes('\\')) {
+    throw new Error(`unsafe artifact path: ${relativePath}`);
+  }
+  const parts = relativePath.split('/');
+  if (parts.some((part) => !part || part === '.' || part === '..')) throw new Error(`unsafe artifact path: ${relativePath}`);
+  let current = runDir;
+  for (const part of parts) {
+    current = path.join(current, part);
+    if (!fs.existsSync(current)) continue;
+    const stat = fs.lstatSync(current);
+    if (stat.isSymbolicLink()) throw new Error(`artifact path contains symbolic link: ${relativePath}`);
+  }
+}
+
+function fsyncPath(file) {
+  const handle = fs.openSync(file, 'r');
+  try { fs.fsyncSync(handle); } finally { fs.closeSync(handle); }
+}
+
 /** Create a run evidence package under <root>/.citable/runs/<run-id>/. */
 export function createRun(root, { command, argv = [], target, locale = process.env.LANG || 'en', jurisdiction = null, configHash = null }) {
   const runId = newRunId(command);
@@ -30,6 +50,7 @@ export function createRun(root, { command, argv = [], target, locale = process.e
   fs.mkdirSync(dir, { recursive: true });
   const git = gitInfo(root);
   const manifest = {
+    schema_version: 2,
     run_id: runId,
     command,
     argv,
@@ -50,6 +71,9 @@ export function createRun(root, { command, argv = [], target, locale = process.e
     errors: [],
     warnings: [],
     status: 'incomplete',
+    execution_status: 'completed',
+    coverage_status: 'not_applicable',
+    determination_status: 'not_applicable',
   };
   return {
     runId,
@@ -59,6 +83,7 @@ export function createRun(root, { command, argv = [], target, locale = process.e
       manifest.input_hashes[name] = sha256(typeof content === 'string' ? content : JSON.stringify(content));
     },
     writeArtifact(relPath, data) {
+      assertSafeArtifactPath(dir, relPath);
       const file = path.join(dir, relPath);
       fs.mkdirSync(path.dirname(file), { recursive: true });
       if (typeof data === 'string' || Buffer.isBuffer(data)) fs.writeFileSync(file, data);
@@ -70,18 +95,53 @@ export function createRun(root, { command, argv = [], target, locale = process.e
       manifest.status = status;
       const { valid, errors } = validateAgainst('run.schema.json', manifest);
       if (!valid) throw new Error(`run manifest invalid: ${errors.join('; ')}`);
-      writeJson(path.join(dir, 'manifest.json'), manifest);
+      const stage = `${dir}.sealing-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+      fs.rmSync(stage, { recursive: true, force: true });
+      fs.cpSync(dir, stage, { recursive: true, dereference: false, errorOnExist: true });
+      writeJson(path.join(stage, 'manifest.json'), manifest);
+      const summaryFile = path.join(stage, 'summary.json');
+      if (fs.existsSync(summaryFile)) {
+        // Keep the persisted ordering contract deterministic even on filesystems
+        // with coarse timestamp resolution or delayed copy metadata updates.
+        const now = new Date(Date.now() + 1000);
+        fs.utimesSync(summaryFile, now, now);
+      }
       // checksums over every artifact in the package
-      const checksums = {};
+      const checksumEntries = [];
       const walk = (d) => {
-        for (const name of fs.readdirSync(d)) {
-          const p = path.join(d, name);
-          if (fs.statSync(p).isDirectory()) walk(p);
-          else if (name !== 'checksums.json') checksums[path.relative(dir, p)] = sha256File(p);
+        for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+          const p = path.join(d, entry.name);
+          if (entry.isSymbolicLink()) throw new Error(`staging package contains symbolic link: ${path.relative(stage, p)}`);
+          if (entry.isDirectory()) walk(p);
+          else if (entry.isFile() && entry.name !== 'checksums.json') checksumEntries.push([path.relative(stage, p).split(path.sep).join('/'), sha256File(p)]);
+          else if (!entry.isFile()) throw new Error(`staging package contains unsupported entry: ${path.relative(stage, p)}`);
+        }
+      };
+      walk(stage);
+      const checksums = Object.fromEntries(checksumEntries.sort(([a], [b]) => a.localeCompare(b)));
+      writeJson(path.join(stage, 'checksums.json'), checksums);
+      const fsyncTree = (directory) => {
+        for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+          const file = path.join(directory, entry.name);
+          if (entry.isSymbolicLink()) throw new Error(`staging package contains symbolic link: ${path.relative(stage, file)}`);
+          if (entry.isDirectory()) fsyncTree(file);
+          else if (entry.isFile()) fsyncPath(file);
         }
+        fsyncPath(directory);
       };
-      walk(dir);
-      writeJson(path.join(dir, 'checksums.json'), checksums);
+      fsyncTree(stage);
+      const parent = path.dirname(dir);
+      const displaced = `${dir}.partial-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+      fs.renameSync(dir, displaced);
+      try {
+        fs.renameSync(stage, dir);
+        fs.rmSync(displaced, { recursive: true, force: true });
+        fsyncPath(parent);
+      } catch (error) {
+        if (!fs.existsSync(dir) && fs.existsSync(displaced)) fs.renameSync(displaced, dir);
+        fs.rmSync(stage, { recursive: true, force: true });
+        throw error;
+      }
       return dir;
     },
   };

package/src/extractor/page.js

@@ -1,10 +1,11 @@
 import { parse } from 'node-html-parser';
+import { createEvidenceHashes, hashPageArtifact } from '../evidence/hashes.js';
 
 /**
  * Extract a PageModel from raw HTML plus transport metadata.
  * Everything downstream (detectors, inspect, schema) consumes this model.
  */
-export function extractPage({ url, html, status = 200, headers = {}, sourceFile = null, redirectChain = [] }) {
+export function extractPage({ url, html, responseBody = null, status = 200, headers = {}, sourceFile = null, redirectChain = [], renderedDom = null }) {
   const root = parse(html, { comment: true });
   const head = root.querySelector('head');
 
@@ -282,7 +283,7 @@ export function extractPage({ url, html, status = 200, headers = {}, sourceFile
   };
   walkDom(root, 1);
 
-  return {
+  const page = {
     url,
     sourceFile,
     status,
@@ -323,4 +324,30 @@ export function extractPage({ url, html, status = 200, headers = {}, sourceFile
     domNodeCount,
     maxDomDepth,
   };
+
+  // Keep representation identity explicit. These hashes deliberately do not
+  // share a generic `contentHash`: raw response bytes, extracted text,
+  // structured data, evaluator evidence, and the persisted page artifact are
+  // different claims and may change independently.
+  const hashes = createEvidenceHashes({
+    responseBody: responseBody ?? html,
+    renderedDom,
+    extractedText: text,
+    structuredData: jsonLd.length
+      ? jsonLd.map(({ parsed, blocks, parseError }) => ({ parsed, blocks, parseError }))
+      : null,
+    evidence: {
+      extracted_text: text,
+      headings,
+      paragraphs,
+      structured_data: jsonLd.map(({ parsed, blocks, parseError }) => ({ parsed, blocks, parseError })),
+    },
+    // This is replaced after URL/resource metadata is attached; keeping the
+    // field null here prevents a pre-persistence model from being presented as
+    // the persisted artifact identity.
+    artifact: null,
+  });
+  const withHashes = { ...page, ...hashes };
+  withHashes.artifact_hash = hashPageArtifact(withHashes);
+  return withHashes;
 }