feat: add source-owned combat mechanic programs

src/lib/server/audit.ts

@@ -30,7 +30,6 @@ export async function auditRecord(table: string, id: string): Promise<Record<str
 	if (![
 		'stat_attributes',
 		'talents',
-		'talent_triggers',
 		'brand_sets',
 		'gear',
 		'weapons',

src/lib/server/conditional-effects.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+import { conditionalRuleDraftFromRows } from './conditional-effects.js';
+
+const rule = {
+	id: 'rule-1',
+	simulation_readiness: 'simulation_ready',
+	scenario_inputs_json: '[]'
+};
+
+const clause = {
+	id: 'clause-1',
+	rule_id: 'rule-1',
+	clause_key: 'hit',
+	label: 'Hit',
+	event_kind: 'weapon_hit',
+	conditions_json: '{"kind":"true"}',
+	reducer_json: '{"kind":"none"}',
+	mutations_json: '[]',
+	sort_order: 1,
+	active: 1
+};
+
+const outcome = {
+	rule_id: 'rule-1',
+	clause_id: 'clause-1',
+	effect_key: 'damage',
+	outcome_key: 'Damage',
+	application_kind: 'active_modifier',
+	effect_scope: 'self',
+	stat_attribute_id: 'weapon-damage',
+	value_basis: 'flat',
+	value_scaling: 'flat',
+	damage_basis: null,
+	application_phase: 'while_active',
+	combat_timing: 'current',
+	resource_kind: null,
+	state_pool_id: null,
+	min_state_value: null,
+	max_state_value: null,
+	description_slot: 1,
+	value: 3,
+	value_expression_json: null
+};
+
+describe('conditional mechanic persistence adapter', () => {
+	it('rejects divergent metadata across value variants', () => {
+		expect(() => conditionalRuleDraftFromRows(
+			rule,
+			[],
+			[clause],
+			[
+				{ ...outcome, variant_key: 'I' },
+				{ ...outcome, variant_key: 'II', application_phase: 'after_event', value: 5 }
+			],
+			['I', 'II']
+		)).toThrow(/inconsistent application_phase metadata/);
+	});
+
+	it('loads consistent value variants into one outcome', () => {
+		const draft = conditionalRuleDraftFromRows(
+			rule,
+			[],
+			[clause],
+			[
+				{ ...outcome, variant_key: 'I' },
+				{ ...outcome, variant_key: 'II', value: 5 }
+			],
+			['I', 'II']
+		);
+
+		expect(draft?.clauses[0].outcomes[0].variants).toEqual({
+			I: { value: 3 },
+			II: { value: 5 }
+		});
+	});
+});

src/lib/server/conditional-effects.ts

@@ -0,0 +1,392 @@
+import {
+	parseConditionalMechanicDraft,
+	type ConditionalMechanicClauseDraft,
+	type ConditionalMechanicDraftV1,
+	type ConditionalMechanicOutcomeDraft,
+	type ConditionalMechanicPoolDraft
+} from '$lib/calculations/mechanic-editor';
+import type { MechanicOutcome, MechanicResource, NumericExpression } from '$lib/calculations/mechanic';
+import type { Database } from '@tursodatabase/database';
+import { randomUUID } from 'node:crypto';
+
+const sourceTypes = [
+	'talent',
+	'os_protocol_talent',
+	'skill_chip_talent',
+	'specialization_tree_rank'
+] as const;
+
+export type ConditionalSourceType = (typeof sourceTypes)[number];
+export type ConditionalValueColumn = { key: string; variantKey: string };
+
+type RuleRow = Record<string, unknown>;
+type PoolRow = Record<string, unknown>;
+type ClauseRow = Record<string, unknown>;
+type OutcomeRow = Record<string, unknown>;
+
+const parseJson = <T>(value: unknown, fallback: T): T => {
+	try {
+		const parsed = JSON.parse(String(value ?? ''));
+		return parsed === null || parsed === undefined ? fallback : parsed as T;
+	} catch {
+		return fallback;
+	}
+};
+
+const applicationKind = (outcome: ConditionalMechanicOutcomeDraft) => {
+	if (outcome.kind === 'attribute_modifier') return 'active_modifier';
+	if (outcome.kind === 'direct_damage') return 'direct_damage';
+	if (outcome.kind === 'resource_cost') return 'resource_cost';
+	if (outcome.kind === 'marker') return 'marker';
+	if (outcome.resource === 'armor') return 'restore_armor';
+	if (outcome.resource === 'ammo') return 'restore_ammo';
+	return 'restore_health';
+};
+
+const outcomeKind = (row: OutcomeRow): MechanicOutcome['kind'] => {
+	if (row.application_kind === 'active_modifier') return 'attribute_modifier';
+	if (row.application_kind === 'direct_damage') return 'direct_damage';
+	if (row.application_kind === 'resource_cost') return 'resource_cost';
+	if (row.application_kind === 'marker') return 'marker';
+	return 'restoration';
+};
+
+const outcomeResource = (row: OutcomeRow): MechanicResource | undefined => {
+	if (row.resource_kind === 'health' || row.resource_kind === 'armor' || row.resource_kind === 'ammo') {
+		return row.resource_kind;
+	}
+	if (row.application_kind === 'restore_health') return 'health';
+	if (row.application_kind === 'restore_armor') return 'armor';
+	if (row.application_kind === 'restore_ammo') return 'ammo';
+	return undefined;
+};
+
+const outcomeMetadataColumns = [
+	'outcome_key',
+	'application_kind',
+	'effect_scope',
+	'stat_attribute_id',
+	'value_basis',
+	'value_scaling',
+	'damage_basis',
+	'application_phase',
+	'combat_timing',
+	'resource_kind',
+	'state_pool_id',
+	'min_state_value',
+	'max_state_value',
+	'description_slot'
+] as const;
+
+const comparableMetadataValue = (value: unknown) => value === undefined ? null : value;
+
+function assertVariantMetadataConsistent(effectKey: string, variants: OutcomeRow[]) {
+	const first = variants[0];
+	for (const variant of variants.slice(1)) {
+		const mismatch = outcomeMetadataColumns.find((column) =>
+			comparableMetadataValue(variant[column]) !== comparableMetadataValue(first[column])
+		);
+		if (mismatch) {
+			throw new Error(
+				`Conditional outcome "${effectKey}" has inconsistent ${mismatch} metadata across value variants.`
+			);
+		}
+	}
+}
+
+export function parseConditionalRulePayload(
+	raw: FormDataEntryValue | string | null,
+	valueColumns: ConditionalValueColumn[],
+	options: {
+		allowedAttributeIds?: ReadonlySet<string>;
+		allowedRecipeKeys?: ReadonlySet<string>;
+		programId?: string;
+		programName?: string;
+	} = {}
+) {
+	const result = parseConditionalMechanicDraft(raw, {
+		variantKeys: valueColumns.map((column) => column.variantKey),
+		allowedAttributeIds: options.allowedAttributeIds,
+		allowedRecipeKeys: options.allowedRecipeKeys,
+		programId: options.programId,
+		programName: options.programName
+	});
+	if (!result.ok) throw new Error(result.errors.join(' '));
+	return result.value.draft;
+}
+
+export function conditionalRuleDraftFromRows(
+	rule: RuleRow | null | undefined,
+	poolRows: PoolRow[],
+	clauseRows: ClauseRow[],
+	outcomeRows: OutcomeRow[],
+	variantKeys: readonly string[]
+): ConditionalMechanicDraftV1 | null {
+	if (!rule) return null;
+	const pools = poolRows
+		.filter((row) => row.rule_id === rule.id)
+		.sort((left, right) => Number(left.sort_order) - Number(right.sort_order))
+		.map((row): ConditionalMechanicPoolDraft => ({
+			key: String(row.state_key),
+			label: String(row.label),
+			stateKind: String(row.state_kind) as ConditionalMechanicPoolDraft['stateKind'],
+			scope: String(row.state_scope) as ConditionalMechanicPoolDraft['scope'],
+			initial: Number(row.initial_value),
+			...(row.minimum_value === null || row.minimum_value === undefined ? {} : { min: Number(row.minimum_value) }),
+			...(row.maximum_value === null || row.maximum_value === undefined ? {} : { max: Number(row.maximum_value) }),
+			...(row.best_case_value === null || row.best_case_value === undefined ? {} : { bestCaseValue: Number(row.best_case_value) }),
+			...(row.duration_seconds === null || row.duration_seconds === undefined ? {} : { expiresAfterSeconds: Number(row.duration_seconds) })
+		}));
+	const poolKeyById = new Map(poolRows.map((row) => [String(row.id), String(row.state_key)]));
+	const rowsByClause = new Map<string, OutcomeRow[]>();
+	for (const row of outcomeRows.filter((item) => item.rule_id === rule.id)) {
+		const key = String(row.clause_id ?? '');
+		rowsByClause.set(key, [...(rowsByClause.get(key) ?? []), row]);
+	}
+	const clauses = clauseRows
+		.filter((row) => row.rule_id === rule.id && Number(row.active ?? 1) === 1)
+		.sort((left, right) => Number(left.sort_order) - Number(right.sort_order))
+		.map((row): ConditionalMechanicClauseDraft => {
+			const grouped = new Map<string, OutcomeRow[]>();
+			for (const outcome of rowsByClause.get(String(row.id)) ?? []) {
+				const key = String(outcome.effect_key);
+				grouped.set(key, [...(grouped.get(key) ?? []), outcome]);
+			}
+			const outcomes = [...grouped.entries()].map(([key, variants]): ConditionalMechanicOutcomeDraft => {
+				assertVariantMetadataConsistent(key, variants);
+				const first = variants[0];
+				const resource = outcomeResource(first);
+				return {
+					key,
+					label: String(first.outcome_key || key),
+					phase: String(first.application_phase) as ConditionalMechanicOutcomeDraft['phase'],
+					kind: outcomeKind(first),
+					scope: String(first.effect_scope) as ConditionalMechanicOutcomeDraft['scope'],
+					basis: String(first.value_basis) as ConditionalMechanicOutcomeDraft['basis'],
+					...(resource ? { resource } : {}),
+					...(first.combat_timing ? { combatTiming: String(first.combat_timing) as 'pre_event' | 'current' } : {}),
+					...(first.stat_attribute_id ? { attributeId: String(first.stat_attribute_id) } : {}),
+					...(first.state_pool_id && poolKeyById.has(String(first.state_pool_id))
+						? { statePool: poolKeyById.get(String(first.state_pool_id)) }
+						: {}),
+					perStack: first.value_scaling === 'per_state_unit',
+					...(first.min_state_value === null || first.min_state_value === undefined ? {} : { minStacks: Number(first.min_state_value) }),
+					...(first.max_state_value === null || first.max_state_value === undefined ? {} : { maxStacks: Number(first.max_state_value) }),
+					...(first.description_slot === null || first.description_slot === undefined ? {} : { descriptionSlot: Number(first.description_slot) }),
+					variants: Object.fromEntries(variantKeys.map((variant) => {
+						const variantRow = variants.find((candidate) => candidate.variant_key === variant);
+						return [variant, {
+							value: Number(variantRow?.value ?? 0),
+							...(variantRow?.value_expression_json
+								? { expression: parseJson<NumericExpression>(variantRow.value_expression_json, Number(variantRow.value ?? 0)) }
+								: {})
+						}];
+					}))
+				};
+			});
+			return {
+				key: String(row.clause_key),
+				label: String(row.label),
+				event: String(row.event_kind) as ConditionalMechanicClauseDraft['event'],
+				...(row.recipe_key ? { recipeKey: String(row.recipe_key) } : {}),
+				if: parseJson(row.conditions_json, { kind: 'true' }),
+				reducer: parseJson(row.reducer_json, { kind: 'none' }),
+				...(row.weight_expression_json
+					? { weight: parseJson<NumericExpression>(row.weight_expression_json, 1) }
+					: {}),
+				...(row.cooldown_seconds === null || row.cooldown_seconds === undefined
+					? {}
+					: { cooldownSeconds: Number(row.cooldown_seconds) }),
+				mutations: parseJson(row.mutations_json, []),
+				outcomes
+			};
+		});
+	return {
+		version: 1,
+		simulationReadiness: String(rule.simulation_readiness ?? 'captured_only') as ConditionalMechanicDraftV1['simulationReadiness'],
+		scenarioInputs: parseJson(rule.scenario_inputs_json, []),
+		pools,
+		clauses
+	};
+}
+
+export async function loadConditionalRuleDraft(
+	database: Database,
+	sourceType: ConditionalSourceType,
+	sourceId: string,
+	variantKeys: readonly string[]
+) {
+	const rule = await (await database.prepare(
+		'SELECT * FROM conditional_effect_rules WHERE source_type=? AND source_id=?'
+	)).get(sourceType, sourceId);
+	if (!rule) return null;
+	const [pools, clauses, outcomes] = await Promise.all([
+		(await database.prepare('SELECT * FROM conditional_effect_state_pools WHERE rule_id=? ORDER BY sort_order')).all(rule.id),
+		(await database.prepare('SELECT * FROM conditional_effect_clauses WHERE rule_id=? ORDER BY sort_order')).all(rule.id),
+		(await database.prepare('SELECT * FROM conditional_effect_outcomes WHERE rule_id=? ORDER BY sort_order,variant_key')).all(rule.id)
+	]);
+	return conditionalRuleDraftFromRows(rule, pools, clauses, outcomes, variantKeys);
+}
+
+/**
+ * Replaces one source-owned mechanic program inside the caller's active transaction.
+ * Every ISAC source mutation must include this write in the same transaction as its
+ * source record and append-only audit event.
+ */
+export async function saveConditionalRuleInTransaction(
+	database: Database,
+	sourceType: ConditionalSourceType,
+	sourceId: string,
+	draft: ConditionalMechanicDraftV1
+) {
+	if (!sourceTypes.includes(sourceType)) throw new Error('Unsupported conditional source.');
+	const existing = await (await database.prepare(
+		'SELECT id,created_at FROM conditional_effect_rules WHERE source_type=? AND source_id=?'
+	)).get(sourceType, sourceId);
+	const now = new Date().toISOString();
+	const ruleId = String(existing?.id ?? randomUUID());
+	await (await database.prepare(`INSERT INTO conditional_effect_rules
+		(id,source_type,source_id,configured,script_version,simulation_readiness,
+		 scenario_inputs_json,created_at,updated_at)
+		VALUES(?,?,?,1,1,?,?,?,?)
+		ON CONFLICT(source_type,source_id) DO UPDATE SET
+			configured=1,
+			script_version=1,
+			simulation_readiness=excluded.simulation_readiness,
+			scenario_inputs_json=excluded.scenario_inputs_json,
+			updated_at=excluded.updated_at`)).run(
+		ruleId,
+		sourceType,
+		sourceId,
+		draft.simulationReadiness,
+		JSON.stringify(draft.scenarioInputs),
+		String(existing?.created_at ?? now),
+		now
+	);
+	await (await database.prepare('DELETE FROM conditional_effect_outcomes WHERE rule_id=?')).run(ruleId);
+	await (await database.prepare('DELETE FROM conditional_effect_clauses WHERE rule_id=?')).run(ruleId);
+	await (await database.prepare('DELETE FROM conditional_effect_state_pools WHERE rule_id=?')).run(ruleId);
+
+	const poolIds = new Map<string, string>();
+	for (const [index, pool] of draft.pools.entries()) {
+		const poolId = randomUUID();
+		poolIds.set(pool.key, poolId);
+		await (await database.prepare(`INSERT INTO conditional_effect_state_pools
+			(id,rule_id,state_key,label,state_kind,state_scope,initial_value,minimum_value,
+			 maximum_value,best_case_value,duration_seconds,expiry_policy,refresh_policy,
+			 parameters_json,sort_order,created_at,updated_at)
+			VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)).run(
+			poolId,
+			ruleId,
+			pool.key,
+			pool.label,
+			pool.stateKind,
+			pool.scope,
+			pool.initial,
+			pool.min ?? null,
+			pool.max ?? Math.max(1, pool.bestCaseValue ?? pool.initial ?? 1),
+			pool.bestCaseValue ?? null,
+			pool.expiresAfterSeconds ?? null,
+			'clear_all',
+			'refresh',
+			'{}',
+			index + 1,
+			now,
+			now
+		);
+	}
+
+	let outcomeSortOrder = 0;
+	for (const [clauseIndex, clause] of draft.clauses.entries()) {
+		const clauseId = randomUUID();
+		await (await database.prepare(`INSERT INTO conditional_effect_clauses
+			(id,rule_id,clause_key,label,event_kind,recipe_key,recipe_parameters_json,
+			 conditions_json,reducer_json,weight_expression_json,emission_kind,state_pool_id,
+			 mutations_json,cooldown_seconds,output_branch,sort_order,active,created_at,updated_at)
+			VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)).run(
+			clauseId,
+			ruleId,
+			clause.key,
+			clause.label || clause.key,
+			clause.event,
+			clause.recipeKey ?? null,
+			'{}',
+			JSON.stringify(clause.if ?? { kind: 'true' }),
+			JSON.stringify(clause.reducer),
+			clause.weight === undefined ? null : JSON.stringify(clause.weight),
+			'each_match',
+			null,
+			JSON.stringify(clause.mutations),
+			clause.cooldownSeconds ?? null,
+			'active',
+			clauseIndex + 1,
+			1,
+			now,
+			now
+		);
+		for (const [outcomeIndex, outcome] of clause.outcomes.entries()) {
+			for (const [variantKey, variant] of Object.entries(outcome.variants)) {
+				outcomeSortOrder += 1;
+				await (await database.prepare(`INSERT INTO conditional_effect_outcomes
+					(id,rule_id,clause_id,state_pool_id,effect_key,variant_key,outcome_key,
+					 application_kind,effect_scope,stat_attribute_id,value,value_expression_json,
+					 value_basis,value_scaling,unit,damage_basis,application_phase,combat_timing,
+					 resource_kind,min_state_value,max_state_value,description_slot,sort_order,
+					 created_at,updated_at)
+					VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)).run(
+					randomUUID(),
+					ruleId,
+					clauseId,
+					outcome.statePool ? poolIds.get(outcome.statePool) ?? null : null,
+					outcome.key,
+					variantKey,
+					outcome.label,
+					applicationKind(outcome),
+					outcome.scope,
+					outcome.attributeId ?? null,
+					variant.value,
+					variant.expression === undefined ? null : JSON.stringify(variant.expression),
+					outcome.basis,
+					outcome.perStack === false ? 'flat' : 'per_state_unit',
+					null,
+					outcome.kind === 'direct_damage'
+						? outcome.basis === 'weapon_base_percent' ? 'weapon_base_percent' : 'flat'
+						: null,
+					outcome.phase,
+					outcome.combatTiming ?? 'current',
+					outcome.resource ?? null,
+					outcome.minStacks ?? null,
+					outcome.maxStacks ?? null,
+					outcome.descriptionSlot ?? null,
+					outcomeSortOrder,
+					now,
+					now
+				);
+			}
+		}
+	}
+	return ruleId;
+}
+
+export async function conditionalRuleSnapshot(
+	database: Database,
+	sourceType: ConditionalSourceType,
+	sourceId: string
+) {
+	const rule = await (await database.prepare(
+		'SELECT * FROM conditional_effect_rules WHERE source_type=? AND source_id=?'
+	)).get(sourceType, sourceId);
+	if (!rule) return null;
+	return {
+		rule,
+		statePools: await (await database.prepare(
+			'SELECT * FROM conditional_effect_state_pools WHERE rule_id=? ORDER BY sort_order'
+		)).all(rule.id),
+		clauses: await (await database.prepare(
+			'SELECT * FROM conditional_effect_clauses WHERE rule_id=? ORDER BY sort_order'
+		)).all(rule.id),
+		outcomes: await (await database.prepare(
+			'SELECT * FROM conditional_effect_outcomes WHERE rule_id=? ORDER BY variant_key,outcome_key,sort_order'
+		)).all(rule.id)
+	};
+}

src/lib/server/data-moderation.ts

@@ -6,7 +6,7 @@ import { recordIsacAudit } from '$lib/server/audit';
 import { getContributorMode } from '$lib/server/contributor-mode';
 import { notifyOversightReview } from '$lib/server/oversight-notifications';
 
-export const DATA_MODULES = ['configuration', 'calculations', 'attributes', 'talents', 'brands', 'gear', 'weapons', 'weaponmods', 'gearmods', 'protocols', 'skillchips', 'specializations'] as const;
+export const DATA_MODULES = ['configuration', 'calculations', 'specializations', 'attributes', 'talents', 'brands', 'gear', 'weapons', 'weaponmods', 'gearmods', 'protocols', 'skillchips'] as const;
 export type DataModule = typeof DATA_MODULES[number];
 
 const proposalResultKeys: Partial<Record<DataModule, Record<string, { saved: string; mode?: string }>>> = {
@@ -24,10 +24,7 @@ const proposalResultKeys: Partial<Record<DataModule, Record<string, { saved: str
 	weapons: { save: { saved: 'weaponSaved', mode: 'weaponMode' } },
 	weaponmods: { save: { saved: 'weaponModSaved', mode: 'weaponModMode' } },
 	gearmods: { save: { saved: 'gearModSaved', mode: 'gearModMode' } },
-	talents: {
-		saveTrigger: { saved: 'triggerSaved', mode: 'triggerMode' },
-		saveTalent: { saved: 'talentSaved', mode: 'talentMode' }
-	},
+	talents: { saveTalent: { saved: 'talentSaved', mode: 'talentMode' } },
 	protocols: {
 		save: { saved: 'protocolSaved', mode: 'protocolMode' },
 		saveProfile: { saved: 'profileSaved' }

src/lib/server/shared-build-combat.ts

@@ -13,6 +13,10 @@ export async function loadSharedBuildCombatCatalog(database: Database) {
 		talentTiers,
 		talentEffects,
 		talentTemplates,
+		conditionalRules,
+		conditionalPools,
+		conditionalClauses,
+		conditionalOutcomes,
 		chipSets,
 		chipTwoPiece,
 		chipTalents,
@@ -26,6 +30,7 @@ export async function loadSharedBuildCombatCatalog(database: Database) {
 		specializations,
 		specializationFocuses,
 		specializationAbilities,
+		specializationAbilityAttacks,
 		focusAbilities,
 		specializationNodes,
 		specializationRanks,
@@ -35,7 +40,8 @@ export async function loadSharedBuildCombatCatalog(database: Database) {
 		specializationCombatModifiers,
 		activeCalculationRevision,
 		calculationStages,
-		calculationProfiles
+		calculationProfiles,
+		skillCalculationProfiles
 	] = await Promise.all([
 		(await database.prepare('SELECT * FROM stat_attributes WHERE active=1 ORDER BY name COLLATE NOCASE')).all(),
 		(await database.prepare('SELECT * FROM gear WHERE active=1 ORDER BY slot,name COLLATE NOCASE')).all(),
@@ -48,6 +54,10 @@ export async function loadSharedBuildCombatCatalog(database: Database) {
 		(await database.prepare('SELECT * FROM talent_tiers ORDER BY tier')).all(),
 		(await database.prepare('SELECT * FROM talent_tier_effects')).all(),
 		(await database.prepare('SELECT * FROM talent_description_templates')).all(),
+		(await database.prepare('SELECT * FROM conditional_effect_rules WHERE configured=1')).all(),
+		(await database.prepare('SELECT * FROM conditional_effect_state_pools ORDER BY rule_id,sort_order')).all(),
+		(await database.prepare('SELECT * FROM conditional_effect_clauses WHERE active=1 ORDER BY rule_id,sort_order')).all(),
+		(await database.prepare('SELECT * FROM conditional_effect_outcomes ORDER BY rule_id,variant_key,outcome_key,sort_order')).all(),
 		(await database.prepare('SELECT * FROM skill_chip_sets WHERE active=1 ORDER BY name COLLATE NOCASE')).all(),
 		(await database.prepare('SELECT * FROM skill_chip_two_piece_bonuses')).all(),
 		(await database.prepare('SELECT * FROM skill_chip_talents')).all(),
@@ -61,6 +71,7 @@ export async function loadSharedBuildCombatCatalog(database: Database) {
 		(await database.prepare('SELECT * FROM specializations WHERE active=1 ORDER BY name COLLATE NOCASE')).all(),
 		(await database.prepare('SELECT * FROM specialization_focuses WHERE active=1 ORDER BY specialization_id,display_order,name COLLATE NOCASE')).all(),
 		(await database.prepare('SELECT * FROM specialization_abilities WHERE active=1 ORDER BY specialization_id,name COLLATE NOCASE')).all(),
+		(await database.prepare('SELECT * FROM specialization_ability_attacks')).all(),
 		(await database.prepare('SELECT * FROM specialization_focus_abilities ORDER BY focus_id,ability_slot')).all(),
 		(await database.prepare('SELECT * FROM specialization_tree_nodes WHERE active=1 ORDER BY focus_id,row_number,column_number')).all(),
 		(await database.prepare('SELECT * FROM specialization_tree_node_ranks ORDER BY node_id,rank')).all(),
@@ -73,10 +84,23 @@ export async function loadSharedBuildCombatCatalog(database: Database) {
 			JOIN calculation_revisions revision ON revision.id=stage.revision_id
 			WHERE revision.status='active' ORDER BY stage.display_order`)).all(),
 		(await database.prepare(`SELECT profile.* FROM attribute_calculation_profiles profile
+			JOIN calculation_revisions revision ON revision.id=profile.revision_id
+			WHERE revision.status='active' ORDER BY profile.stage_key,profile.stat_attribute_id`)).all(),
+		(await database.prepare(`SELECT profile.* FROM skill_attribute_calculation_profiles profile
 			JOIN calculation_revisions revision ON revision.id=profile.revision_id
 			WHERE revision.status='active' ORDER BY profile.stage_key,profile.stat_attribute_id`)).all()
 	]);
 
+	const hydrateRule = (sourceType: string, sourceId: unknown) => {
+		const rule = conditionalRules.find((item) => item.source_type === sourceType && item.source_id === sourceId);
+		return rule ? {
+			rule,
+			statePools: conditionalPools.filter((pool) => pool.rule_id === rule.id),
+			clauses: conditionalClauses.filter((clause) => clause.rule_id === rule.id),
+			outcomes: conditionalOutcomes.filter((outcome) => outcome.rule_id === rule.id),
+			triggers: []
+		} : null;
+	};
 	const configuredTalents = talents.map((talent) => ({
 		...talent,
 		template: talentTemplates.find((item) => item.talent_id === talent.id)?.template ?? '',
@@ -85,7 +109,8 @@ export async function loadSharedBuildCombatCatalog(database: Database) {
 			.map((tier) => ({
 				...tier,
 				effects: talentEffects.filter((effect) => effect.talent_tier_id === tier.id)
-			}))
+			})),
+		rule: hydrateRule('talent', talent.id)
 	}));
 
 	return {
@@ -109,7 +134,8 @@ export async function loadSharedBuildCombatCatalog(database: Database) {
 				talent: talent
 					? {
 						...talent,
-						effects: chipTalentEffects.filter((effect) => effect.talent_id === talent.id)
+						effects: chipTalentEffects.filter((effect) => effect.talent_id === talent.id),
+						rule: hydrateRule('skill_chip_talent', talent.id)
 					}
 					: null
 			};
@@ -130,7 +156,8 @@ export async function loadSharedBuildCombatCatalog(database: Database) {
 				talent: talent
 					? {
 						...talent,
-						effects: protocolTalentEffects.filter((effect) => effect.talent_id === talent.id)
+						effects: protocolTalentEffects.filter((effect) => effect.talent_id === talent.id),
+						rule: hydrateRule('os_protocol_talent', talent.id)
 					}
 					: null
 			};
@@ -143,7 +170,13 @@ export async function loadSharedBuildCombatCatalog(database: Database) {
 					const abilities = focusAbilities
 						.filter((link) => link.focus_id === focus.id)
 						.sort((left, right) => Number(left.ability_slot) - Number(right.ability_slot))
-						.map((link) => specializationAbilities.find((ability) => ability.id === link.ability_id))
+						.map((link) => {
+							const ability = specializationAbilities.find((entry) => entry.id === link.ability_id);
+							return ability ? {
+								...ability,
+								attack: specializationAbilityAttacks.find((attack) => attack.ability_id === ability.id) ?? null
+							} : null;
+						})
 						.filter(Boolean);
 					const nodes = specializationNodes
 						.filter((node) => node.focus_id === focus.id)
@@ -171,7 +204,8 @@ export async function loadSharedBuildCombatCatalog(database: Database) {
 											),
 											modifiers: specializationCombatModifiers.filter(
 												(modifier) => modifier.rank_combat_effect_id === effect.id
-											)
+											),
+											rule: hydrateRule('specialization_tree_rank', effect.id)
 										}))
 								}))
 						}));
@@ -181,7 +215,8 @@ export async function loadSharedBuildCombatCatalog(database: Database) {
 		calculation: {
 			revision: activeCalculationRevision ?? null,
 			stages: calculationStages,
-			profiles: calculationProfiles
+			profiles: calculationProfiles,
+			skillProfiles: skillCalculationProfiles
 		}
 	};
 }