@happyvertical/smrt-ingestion 0.55.5 → 0.55.7

package/dist/chunks/execution-internal-DWteDHM2.js

@@ -0,0 +1,7 @@
+//#region src/execution-internal.ts
+var discoveryTransaction = /* @__PURE__ */ Symbol("ingestion.discoveryTransaction");
+var generationSnapshotRead = /* @__PURE__ */ Symbol("ingestion.generationSnapshotRead");
+//#endregion
+export { generationSnapshotRead as n, discoveryTransaction as t };
+
+//# sourceMappingURL=execution-internal-DWteDHM2.js.map

package/dist/chunks/execution-internal-DWteDHM2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-internal-DWteDHM2.js","names":[],"sources":["../../src/execution-internal.ts"],"sourcesContent":["import type { DatabaseInterface } from '@happyvertical/sql';\nimport type { HandlerContext } from './execution-contracts.js';\n\n// Package-internal transaction bridge. Neither symbol is a public package export.\nexport const discoveryTransaction = Symbol('ingestion.discoveryTransaction');\nexport const generationSnapshotRead = Symbol(\n  'ingestion.generationSnapshotRead',\n);\nexport type TransactionRunner<T> = (\n  work: (db: DatabaseInterface) => Promise<T>,\n) => Promise<T>;\nexport type DiscoveryGate = <T>(\n  handlerId: string,\n  handlerVersion: string,\n  work: (\n    context: HandlerContext,\n    currentTarget: (model: string, id: string) => Promise<{ revision: string }>,\n  ) => Promise<T>,\n) => Promise<T>;\n"],"mappings":";AAIO,IAAM,uBAAuB,uBAAO,gCAAgC;AACpE,IAAM,yBAAyB,uBACpC,kCACF"}

package/dist/chunks/feedback-B_NILilH.js

@@ -0,0 +1,577 @@
+import { a as feedbackActionTransaction, c as __exportAll, o as feedbackDiscoveryContext, r as intakeBindingDigest, t as IntakeExecutionService } from "./execution-CYjtj9_l.js";
+import { randomUUID } from "node:crypto";
+//#region src/feedback.ts
+var feedback_exports = /* @__PURE__ */ __exportAll({
+	IntakeFeedbackService: () => IntakeFeedbackService,
+	feedbackSimilarity: () => feedbackSimilarity,
+	feedbackTerms: () => feedbackTerms
+});
+function object(value) {
+	const result = typeof value === "string" ? JSON.parse(value) : value;
+	if (!result || typeof result !== "object" || Array.isArray(result)) throw new Error("Feedback unavailable");
+	return result;
+}
+function text(value, max = 512) {
+	if (typeof value !== "string" || !value.trim() || value.length > max) throw new Error("Invalid feedback");
+}
+function resultData(data) {
+	return {
+		status: data.status,
+		provider: data.provider,
+		model: data.model,
+		version: data.version,
+		output: data.output,
+		usage: data.usage,
+		...Object.hasOwn(data, "error") ? { error: data.error } : {},
+		...Object.hasOwn(data, "confidence") ? { confidence: data.confidence } : {}
+	};
+}
+function feedbackTerms(value) {
+	return [...new Set(value.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [])].sort();
+}
+function feedbackSimilarity(left, right) {
+	const a = new Set(feedbackTerms(left)), b = new Set(feedbackTerms(right));
+	const union = /* @__PURE__ */ new Set([...a, ...b]);
+	return union.size ? [...a].filter((value) => b.has(value)).length / union.size : 0;
+}
+var IntakeFeedbackService = class {
+	constructor(options, execution) {
+		this.options = options;
+		if (!options.execution || !options.feedback) throw new Error("Feedback not configured");
+		this.config = { ...options.feedback };
+		this.execution = execution ?? new IntakeExecutionService(options, options.execution);
+		text(this.config.version);
+		for (const [value, max] of [
+			[this.config.maxExamples, 20],
+			[this.config.maxScan, 1e3],
+			[this.config.maxBytes, 1e6]
+		]) if (!Number.isSafeInteger(value) || value < 1 || value > max) throw new Error("Invalid feedback limits");
+		if (!Number.isFinite(this.config.minimumSimilarity) || this.config.minimumSimilarity < .2 || this.config.minimumSimilarity > 1) throw new Error("Invalid feedback similarity");
+	}
+	options;
+	execution;
+	config;
+	lineage = /* @__PURE__ */ new Set();
+	exampleChecks = 0;
+	configurationDigest() {
+		const { version, maxExamples, maxScan, maxBytes, minimumSimilarity } = this.config;
+		return intakeBindingDigest({
+			version,
+			maxExamples,
+			maxScan,
+			maxBytes,
+			minimumSimilarity
+		});
+	}
+	scope() {
+		return this.options.scope;
+	}
+	async rows(db, where, params = []) {
+		const scope = this.scope();
+		return (await db.query(`SELECT * FROM intake_feedback WHERE tenant_id=? AND confidential_scope_id=? AND ${where}`, scope.tenantId, scope.confidentialScopeId, ...params)).rows;
+	}
+	async authorize(ctx, operation) {
+		if (!await this.config.authorize({
+			db: ctx.db,
+			scope: this.scope(),
+			itemId: ctx.itemId,
+			operation
+		})) throw new Error("Feedback unavailable");
+	}
+	checkBinding(input, ctx) {
+		if (input.itemId !== ctx.itemId || input.actionId !== ctx.review.actionId || input.expectedRevision !== ctx.review.revision || input.expectedReviewVersion !== ctx.review.reviewVersion || input.bindingHash !== ctx.review.bindingHash) throw new Error("Stale feedback binding");
+	}
+	async insert(ctx, key, kind, data, supersedesId = null) {
+		const serialized = JSON.stringify(data);
+		if (Buffer.byteLength(serialized) > Math.min(this.config.maxBytes, ctx.context.policy.maxBytes)) throw new Error("Feedback limit");
+		const scope = this.scope(), now = (this.options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+		const row = {
+			id: randomUUID(),
+			slug: randomUUID(),
+			context: "",
+			created_at: now,
+			updated_at: now,
+			tenant_id: scope.tenantId,
+			confidential_scope_id: scope.confidentialScopeId,
+			item_id: ctx.itemId,
+			request_key: key,
+			supersedes_id: supersedesId,
+			kind,
+			data: serialized
+		};
+		return (await ctx.db.query(`INSERT INTO intake_feedback (${Object.keys(row).join(",")}) VALUES (${Object.keys(row).map(() => "?").join(",")}) RETURNING *`, ...Object.values(row))).rows[0];
+	}
+	receipt(row) {
+		return {
+			id: String(row.id),
+			digest: String(object(row.data).digest),
+			kind: row.kind
+		};
+	}
+	async provenance(ctx) {
+		const generation = object(object(ctx.result.output).proposals), pin = object(generation.source), provenance = object(generation.provenance);
+		if (provenance.feedback) {
+			const inherited = object(provenance.feedback);
+			const key = ctx.attemptId;
+			if (this.lineage.has(key) || this.lineage.size >= 8) throw new Error("Feedback lineage unavailable");
+			this.lineage.add(key);
+			try {
+				await this.assertSelection({
+					itemId: ctx.itemId,
+					query: String(inherited.query),
+					offered: generation.offered,
+					promptVersion: String(provenance.promptVersion),
+					configurationVersion: String(provenance.configurationVersion),
+					model: provenance.generative,
+					providers: [String(object(provenance.generative).provider), ...object(provenance.decision).configured ? [String(object(provenance.decision).provider)] : []]
+				}, inherited.selection, ctx.db);
+			} finally {
+				this.lineage.delete(key);
+			}
+		}
+		const scope = this.scope();
+		const [source] = (await ctx.db.query("SELECT data,output_digest FROM intake_analysis_attempts WHERE tenant_id=? AND confidential_scope_id=? AND item_id=? AND id=?", scope.tenantId, scope.confidentialScopeId, ctx.itemId, pin.attemptId)).rows;
+		if (!source || source.output_digest !== pin.outputDigest) throw new Error("Feedback source unavailable");
+		const sourceResult = resultData(object(source.data));
+		if (intakeBindingDigest(sourceResult) !== pin.outputDigest) throw new Error("Feedback source integrity");
+		const results = object(sourceResult.output).results;
+		if (!Array.isArray(results)) throw new Error("Feedback extraction unavailable");
+		const query = results.flatMap((entry) => {
+			const segments = object(entry).segments;
+			return Array.isArray(segments) ? segments.map((segment) => String(object(segment).text ?? "")) : [];
+		}).join("\n").slice(0, 4096);
+		const model = object(provenance.generative);
+		for (const field of [
+			"provider",
+			"model",
+			"version"
+		]) text(model[field]);
+		text(provenance.promptVersion);
+		text(provenance.configurationVersion);
+		return {
+			query,
+			model: {
+				provider: String(model.provider),
+				model: String(model.model),
+				version: String(model.version)
+			},
+			promptVersion: String(provenance.promptVersion),
+			configurationVersion: String(provenance.configurationVersion),
+			attemptId: ctx.attemptId,
+			evidence: object(ctx.analysis).inputs,
+			source: pin
+		};
+	}
+	/** Internal saved-action gate; the execution owner supplies its transaction. */
+	async assertActionLineage(actionId, db, proposalId) {
+		await this.execution[feedbackActionTransaction](actionId, false, async (ctx) => {
+			await this.provenance(ctx);
+		}, db, void 0, proposalId);
+	}
+	async record(input) {
+		intakeBindingDigest(input);
+		text(input.requestId);
+		if (!["correct", "incorrect"].includes(input.judgment) || input.comment !== void 0 && (typeof input.comment !== "string" || input.comment.length > 4e3)) throw new Error("Invalid feedback");
+		const frozen = structuredClone(input);
+		return this.execution[feedbackActionTransaction](input.actionId, true, async (ctx) => {
+			await this.authorize(ctx, "capture");
+			this.checkBinding(frozen, ctx);
+			const requestHash = intakeBindingDigest(frozen), key = `judgment:${frozen.requestId}`;
+			const [replay] = await this.rows(ctx.db, "item_id=? AND request_key=?", [ctx.itemId, key]);
+			if (replay) {
+				const data = object(replay.data);
+				if (data.requestHash !== requestHash || data.reviewer !== this.scope().actorId) throw new Error("Feedback request conflict");
+				return this.receipt(replay);
+			}
+			if (frozen.supersedesId) {
+				const [old] = await this.rows(ctx.db, "item_id=? AND id=? AND kind=?", [
+					ctx.itemId,
+					frozen.supersedesId,
+					"interpretation"
+				]);
+				if (!old || object(old.data).actionId !== frozen.actionId || (await this.rows(ctx.db, "supersedes_id=?", [old.id])).length) throw new Error("Feedback supersession conflict");
+			}
+			const provenance = await this.provenance(ctx);
+			const body = {
+				version: 1,
+				requestHash,
+				reviewer: this.scope().actorId,
+				actionId: ctx.review.actionId,
+				revision: ctx.review.revision,
+				reviewVersion: ctx.review.reviewVersion,
+				bindingHash: ctx.review.bindingHash,
+				handlerId: ctx.handlerId,
+				handlerVersion: ctx.handlerVersion,
+				args: ctx.args,
+				judgment: frozen.judgment,
+				comment: frozen.comment ?? "",
+				...provenance
+			};
+			const row = await this.insert(ctx, key, "interpretation", {
+				...body,
+				digest: intakeBindingDigest(body)
+			}, frozen.supersedesId ?? null);
+			await this.authorize(ctx, "capture");
+			return this.receipt(row);
+		});
+	}
+	/** Consume a durable owner event idempotently. Never derive correctness from these signals. */
+	async observe(input) {
+		intakeBindingDigest(input);
+		text(input.eventId);
+		if (!["action_decision", "downstream_outcome"].includes(input.kind)) throw new Error("Invalid feedback kind");
+		return this.execution[feedbackActionTransaction](input.actionId, true, async (ctx) => {
+			await this.authorize(ctx, "capture");
+			this.checkBinding(input, ctx);
+			const scope = this.scope();
+			const table = input.kind === "action_decision" ? "intake_review_decisions" : "intake_executions";
+			const [event] = (await ctx.db.query(`SELECT * FROM ${table} WHERE tenant_id=? AND confidential_scope_id=? AND item_id=? AND action_id=? AND id=?`, scope.tenantId, scope.confidentialScopeId, ctx.itemId, input.actionId, input.eventId)).rows;
+			if (!event || event.binding_hash !== ctx.review.bindingHash) throw new Error("Feedback event unavailable");
+			const state = input.kind === "action_decision" ? event.decision : event.state;
+			if (input.kind === "downstream_outcome" && ![
+				"succeeded",
+				"failed",
+				"outcome_unknown"
+			].includes(String(state))) throw new Error("Outcome is not terminal");
+			const body = {
+				version: 1,
+				eventId: input.eventId,
+				actionId: input.actionId,
+				revision: ctx.review.revision,
+				reviewer: input.kind === "action_decision" ? object(event.data).reviewer : null,
+				observedBy: this.scope().actorId,
+				principalId: object(event.data).principalId ?? null,
+				signal: state,
+				provenance: await this.provenance(ctx)
+			};
+			const key = `event:${input.kind}:${input.eventId}:${String(state)}`;
+			const [existing] = await this.rows(ctx.db, "item_id=? AND request_key=?", [ctx.itemId, key]);
+			if (existing) return this.receipt(existing);
+			const row = await this.insert(ctx, key, input.kind, {
+				...body,
+				digest: intakeBindingDigest(body)
+			});
+			await this.authorize(ctx, "capture");
+			return this.receipt(row);
+		});
+	}
+	async example(row, input, executor) {
+		if (++this.exampleChecks > this.config.maxScan) return void 0;
+		try {
+			const candidate = object(row.data);
+			if (typeof candidate.actionId !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(candidate.actionId)) return void 0;
+			return await this.execution[feedbackActionTransaction](candidate.actionId, false, async (ctx) => {
+				await this.authorize(ctx, "retrieve");
+				await this.provenance(ctx);
+				const [current] = await this.rows(ctx.db, "id=? AND kind=? AND NOT EXISTS (SELECT 1 FROM intake_feedback successor WHERE successor.tenant_id=intake_feedback.tenant_id AND successor.confidential_scope_id=intake_feedback.confidential_scope_id AND successor.supersedes_id=intake_feedback.id)", [row.id, "interpretation"]);
+				if (!current) return void 0;
+				const data = object(current.data);
+				const { digest: stored, ...body } = data;
+				if (intakeBindingDigest(body) !== stored) throw new Error("Feedback integrity");
+				if (data.revision !== ctx.review.revision || data.bindingHash !== ctx.review.bindingHash || data.attemptId !== ctx.attemptId || data.promptVersion !== input.promptVersion || data.configurationVersion !== input.configurationVersion || intakeBindingDigest(data.model) !== intakeBindingDigest(input.model)) return void 0;
+				const offered = input.offered.find((entry) => entry.handler.id === data.handlerId && entry.handler.version === data.handlerVersion);
+				if (!offered) return void 0;
+				const args = object(data.args);
+				for (const [field, reference] of Object.entries(offered.handler.references)) if (reference.kind === "candidate" && Object.hasOwn(args, field) && !offered.candidates.some((candidate2) => candidate2.id === args[field] && candidate2.model === reference.model)) return void 0;
+				return {
+					feedbackId: String(current.id),
+					digest: String(stored),
+					itemId: ctx.itemId,
+					actionId: ctx.review.actionId,
+					revision: ctx.review.revision,
+					handlerId: ctx.handlerId,
+					handlerVersion: ctx.handlerVersion,
+					judgment: data.judgment,
+					query: String(data.query),
+					args,
+					model: data.model,
+					promptVersion: String(data.promptVersion),
+					configurationVersion: String(data.configurationVersion)
+				};
+			}, executor, input.providers ?? [input.model.provider]);
+		} catch {
+			return;
+		}
+	}
+	receivingContext(input, executor, work) {
+		let limit = this.config.maxBytes;
+		let bytes;
+		const validate = async (context) => {
+			if ((input.providers ?? [input.model.provider]).some((provider) => !context.policy.providers.includes(provider))) throw new Error("Feedback recipient unavailable");
+			limit = Math.min(limit, context.policy.maxBytes);
+			if (bytes !== void 0 && bytes > limit) throw new Error("Feedback limit");
+		};
+		const visit = (index, db) => {
+			const entry = input.offered[index];
+			return this.execution[feedbackDiscoveryContext](db, input.itemId, entry.handler.id, entry.handler.version, async (context) => {
+				await validate(context);
+				const selection = index + 1 < input.offered.length ? await visit(index + 1, context.db) : await work(context);
+				bytes = Buffer.byteLength(JSON.stringify(selection));
+				if (bytes > limit) throw new Error("Feedback limit");
+				return selection;
+			}, validate);
+		};
+		return visit(0, executor);
+	}
+	async retrieve(input, executor) {
+		text(input.query, 4096);
+		if (!input.offered[0]) return {
+			version: this.config.version,
+			configurationDigest: this.configurationDigest(),
+			examples: []
+		};
+		const work = async (context) => {
+			const authorize = async () => {
+				if (!await this.config.authorize({
+					db: context.db,
+					scope: this.scope(),
+					itemId: input.itemId,
+					operation: "retrieve"
+				})) throw new Error("Feedback unavailable");
+			};
+			await authorize();
+			const scope = this.scope();
+			const rows = (await context.db.query("SELECT * FROM intake_feedback WHERE tenant_id=? AND confidential_scope_id=? AND kind='interpretation' ORDER BY id LIMIT ?", scope.tenantId, scope.confidentialScopeId, this.config.maxScan)).rows;
+			const ranked = [];
+			for (const row of rows) {
+				const example = await this.example(row, input, context.db);
+				if (!example) continue;
+				const score = feedbackSimilarity(input.query, example.query);
+				if (score >= this.config.minimumSimilarity) ranked.push({
+					example,
+					score
+				});
+			}
+			ranked.sort((a, b) => b.score - a.score || a.example.feedbackId.localeCompare(b.example.feedbackId));
+			const selection = {
+				version: this.config.version,
+				configurationDigest: this.configurationDigest(),
+				examples: ranked.slice(0, this.config.maxExamples).map((entry) => entry.example)
+			};
+			await authorize();
+			return selection;
+		};
+		return this.receivingContext(input, executor, work);
+	}
+	async assertSelection(input, selection, executor) {
+		if (selection.version !== this.config.version || selection.configurationDigest !== this.configurationDigest() || !Array.isArray(selection.examples) || selection.examples.length > this.config.maxExamples || new Set(selection.examples.map((example) => example.feedbackId)).size !== selection.examples.length || Buffer.byteLength(JSON.stringify(selection)) > this.config.maxBytes) throw new Error("Feedback eligibility changed");
+		if (!input.offered[0]) {
+			if (selection.examples.length) throw new Error("Feedback eligibility changed");
+			return;
+		}
+		const work = async (context) => {
+			if (!await this.config.authorize({
+				db: context.db,
+				scope: this.scope(),
+				itemId: input.itemId,
+				operation: "retrieve"
+			})) throw new Error("Feedback unavailable");
+			const examples = [];
+			for (const expected of selection.examples) {
+				const [row] = await this.rows(context.db, "id=? AND kind=?", [expected.feedbackId, "interpretation"]);
+				const current = row ? await this.example(row, input, context.db) : void 0;
+				if (!current || current.digest !== expected.digest || feedbackSimilarity(input.query, current.query) < this.config.minimumSimilarity) throw new Error("Feedback eligibility changed");
+				examples.push(current);
+			}
+			if (!await this.config.authorize({
+				db: context.db,
+				scope: this.scope(),
+				itemId: input.itemId,
+				operation: "retrieve"
+			})) throw new Error("Feedback unavailable");
+			return {
+				...selection,
+				examples
+			};
+		};
+		await this.receivingContext(input, executor, work);
+	}
+	async support(ctx, ids) {
+		if (!Array.isArray(ids) || ids.length < 2 || ids.length > this.config.maxExamples || new Set(ids).size !== ids.length) throw new Error("Insufficient rule evidence");
+		const provenance = await this.provenance(ctx), origins = /* @__PURE__ */ new Set(), result = [];
+		for (const id of [...ids].sort()) {
+			text(id);
+			const [row] = await this.rows(ctx.db, "id=? AND kind=?", [id, "interpretation"]);
+			if (!row) throw new Error("Rule evidence unavailable");
+			const data = object(row.data);
+			await this.execution[feedbackActionTransaction](String(data.actionId), false, async (source) => {
+				await this.authorize(source, "retrieve");
+				await this.provenance(source);
+				if (origins.has(source.itemId)) throw new Error("Independent rule evidence required");
+				origins.add(source.itemId);
+				const { digest: stored, ...body } = data;
+				if (intakeBindingDigest(body) !== stored || data.judgment !== "correct" || data.revision !== source.review.revision || data.bindingHash !== source.review.bindingHash || data.handlerId !== ctx.handlerId || data.handlerVersion !== ctx.handlerVersion || intakeBindingDigest(data.args) !== intakeBindingDigest(ctx.args) || data.promptVersion !== provenance.promptVersion || data.configurationVersion !== provenance.configurationVersion || intakeBindingDigest(data.model) !== intakeBindingDigest(provenance.model) || (await this.rows(ctx.db, "supersedes_id=?", [id])).length) throw new Error("Rule evidence unavailable");
+				result.push({
+					id,
+					digest: String(stored),
+					query: String(data.query)
+				});
+			}, ctx.db);
+		}
+		return result;
+	}
+	async suggest(input) {
+		intakeBindingDigest(input);
+		text(input.requestId);
+		if (!this.config.policy) throw new Error("Rule policy owner unavailable");
+		return this.execution[feedbackActionTransaction](input.actionId, true, async (ctx) => {
+			this.checkBinding(input, ctx);
+			await this.authorize(ctx, "suggest");
+			const support = await this.support(ctx, input.supportingFeedbackIds);
+			const terms = feedbackTerms(support[0].query).filter((term) => support.every((example) => feedbackTerms(example.query).includes(term)));
+			if (!terms.length) throw new Error("No shared routing evidence");
+			const rule = {
+				handlerId: ctx.handlerId,
+				handlerVersion: ctx.handlerVersion,
+				matchTerms: terms,
+				args: ctx.args
+			};
+			const preview = await this.config.policy.preview({
+				db: ctx.db,
+				scope: this.scope(),
+				rule: structuredClone(rule)
+			});
+			text(preview.version);
+			text(preview.preview, 4e3);
+			const body = {
+				version: 1,
+				actionId: input.actionId,
+				revision: ctx.review.revision,
+				bindingHash: ctx.review.bindingHash,
+				rule,
+				supportingFeedback: support.map(({ id, digest: digest2 }) => ({
+					id,
+					digest: digest2
+				})),
+				expectedPolicyVersion: preview.version,
+				preview: preview.preview,
+				reviewer: this.scope().actorId,
+				requestHash: intakeBindingDigest(input)
+			};
+			const key = `rule:${input.requestId}`;
+			let [row] = await this.rows(ctx.db, "item_id=? AND request_key=?", [ctx.itemId, key]);
+			if (row) {
+				if (object(row.data).requestHash !== body.requestHash) throw new Error("Rule request conflict");
+			} else row = await this.insert(ctx, key, "rule_suggestion", {
+				...body,
+				digest: intakeBindingDigest(body)
+			});
+			await this.authorize(ctx, "suggest");
+			return this.ruleDTO(row);
+		});
+	}
+	ruleDTO(row) {
+		const data = object(row.data);
+		return {
+			id: String(row.id),
+			digest: String(data.digest),
+			itemId: String(row.item_id),
+			rule: data.rule,
+			supportingFeedback: data.supportingFeedback,
+			expectedPolicyVersion: String(data.expectedPolicyVersion),
+			preview: String(data.preview),
+			automaticActionEligible: false
+		};
+	}
+	async rule(ctx, id) {
+		const [row] = await this.rows(ctx.db, "item_id=? AND id=? AND kind=?", [
+			ctx.itemId,
+			id,
+			"rule_suggestion"
+		]);
+		if (!row) throw new Error("Rule unavailable");
+		const data = object(row.data), { digest: stored, ...body } = data;
+		if (intakeBindingDigest(body) !== stored || data.actionId !== ctx.review.actionId || data.revision !== ctx.review.revision || data.bindingHash !== ctx.review.bindingHash) throw new Error("Stale rule");
+		const support = data.supportingFeedback;
+		if (intakeBindingDigest((await this.support(ctx, support.map((entry) => entry.id))).map(({ id: id2, digest: digest2 }) => ({
+			id: id2,
+			digest: digest2
+		}))) !== intakeBindingDigest(support)) throw new Error("Rule evidence changed");
+		return row;
+	}
+	async readRule(input) {
+		return this.execution[feedbackActionTransaction](input.actionId, true, async (ctx) => {
+			this.checkBinding(input, ctx);
+			await this.authorize(ctx, "suggest");
+			const suggestion = this.ruleDTO(await this.rule(ctx, input.suggestionId));
+			if (!this.config.policy) throw new Error("Rule policy owner unavailable");
+			const current = await this.config.policy.preview({
+				db: ctx.db,
+				scope: this.scope(),
+				rule: structuredClone(suggestion.rule)
+			});
+			if (current.version !== suggestion.expectedPolicyVersion || current.preview !== suggestion.preview) throw new Error("Rule policy changed");
+			await this.authorize(ctx, "suggest");
+			return suggestion;
+		});
+	}
+	async adopt(input) {
+		intakeBindingDigest(input);
+		text(input.requestId);
+		if (!this.config.policy) throw new Error("Rule policy owner unavailable");
+		return this.execution[feedbackActionTransaction](input.actionId, true, async (ctx) => {
+			this.checkBinding(input, ctx);
+			await this.authorize(ctx, "adopt");
+			const row = await this.rule(ctx, input.suggestionId), suggestion = this.ruleDTO(row);
+			if (input.expectedDigest !== suggestion.digest || input.expectedPolicyVersion !== suggestion.expectedPolicyVersion) throw new Error("Stale rule");
+			const requestHash = intakeBindingDigest(input), key = `adopt:${input.requestId}`;
+			const [replay] = await this.rows(ctx.db, "item_id=? AND request_key=?", [ctx.itemId, key]);
+			if (replay) {
+				const data = object(replay.data);
+				if (data.requestHash !== requestHash || data.reviewer !== this.scope().actorId) throw new Error("Rule request conflict");
+				return {
+					id: String(replay.id),
+					policyVersion: String(data.policyVersion),
+					auditId: String(data.auditId),
+					automaticActionEligible: false
+				};
+			}
+			if ((await this.config.policy.preview({
+				db: ctx.db,
+				scope: this.scope(),
+				rule: structuredClone(suggestion.rule)
+			})).version !== input.expectedPolicyVersion) throw new Error("Policy version changed");
+			const applied = await this.config.policy.adopt({
+				db: ctx.db,
+				scope: this.scope(),
+				rule: structuredClone(suggestion.rule),
+				expectedVersion: input.expectedPolicyVersion,
+				requestId: input.requestId
+			});
+			text(applied.version);
+			text(applied.auditId);
+			if (applied.version === input.expectedPolicyVersion) throw new Error("Policy version did not advance");
+			if ((await this.config.policy.preview({
+				db: ctx.db,
+				scope: this.scope(),
+				rule: structuredClone(suggestion.rule)
+			})).version !== applied.version) throw new Error("Policy adoption mismatch");
+			const body = {
+				version: 1,
+				requestHash,
+				suggestionId: suggestion.id,
+				suggestionDigest: suggestion.digest,
+				previousPolicyVersion: input.expectedPolicyVersion,
+				policyVersion: applied.version,
+				auditId: applied.auditId,
+				reviewer: this.scope().actorId,
+				automaticActionEligible: false
+			};
+			const saved = await this.insert(ctx, key, "rule_adoption", {
+				...body,
+				digest: intakeBindingDigest(body)
+			});
+			await this.authorize(ctx, "adopt");
+			return {
+				id: String(saved.id),
+				policyVersion: applied.version,
+				auditId: applied.auditId,
+				automaticActionEligible: false
+			};
+		});
+	}
+};
+//#endregion
+export { feedback_exports as n, IntakeFeedbackService as t };
+
+//# sourceMappingURL=feedback-B_NILilH.js.map