@classytic/ca-tax 0.0.2 → 0.0.12

package/dist/t2.mjs

@@ -1,4 +1,4 @@
-import { rt as SCHEDULE_1_LINE_BY_NUMBER } from "./forms.mjs";
+import { kt as AT1_SCHEDULE_21_POOLS, rt as SCHEDULE_1_LINE_BY_NUMBER } from "./forms.mjs";
 //#region src/t2/rates/rate-book.ts
 /**
 * Resolve the table in effect for `taxYear` — the entry with the greatest
@@ -254,15 +254,25 @@ function computeAlbertaTax(input, rates = AB_TAX_2024) {
 const AT1_SCHEDULES_WITH_BUILDERS = Object.freeze([
 	"001",
 	"002",
+	"003",
+	"004",
+	"005",
+	"006",
+	"007",
+	"008",
+	"009",
 	"010",
+	"011",
 	"012",
 	"013",
+	"015",
 	"016",
 	"017",
 	"018",
 	"020",
 	"021",
-	"029"
+	"029",
+	"4970"
 ]);
 /**
 * Schedules the engine computes but cannot yet file.
@@ -435,6 +445,15 @@ function schedule18Values(result) {
 * Field ids read off the live, TRA-certified form
 * (`research/sources/tra-forms/pdf/AT1SCH29-*.pdf`, Rev. 2026-06):
 *
+* Page 1 — Eligible Expenditures, filed only when the caller supplies
+* `eligible` (from `computeIegEligibleExpenditures` in
+* `schedule29-eligible-expenditures.ts`):
+*   003  federal amount of qualified/current SR&ED expenditures (T661 line
+*        559 or 557 — see `iegT661SourceLine`)
+*   005/007/009/011/025  the five adjustments; 031 = 005 − 007 + 009 + 011 + 025
+*   040  primary field of science or technology (1–4), when the caller
+*        supplies `primaryFieldCode`
+*
 * Page 1/2 — the grant itself:
 *   110  8% of the capped expenditures
 *   112  12% of the increment above base — the non-associated path. Filed
@@ -477,12 +496,22 @@ function schedule18Values(result) {
 * band. See `schedule29-ieg.ts` for why 128 exists and the one unresolved
 * discrepancy in how 130 is meant to be computed.
 */
-function schedule29Values(result, agreement) {
+function schedule29Values(result, agreement, eligible, primaryFieldCode) {
 	const values = [];
 	const put = (fieldId, value, occurrence = 1) => values.push({
 		lineItemId: at1LineItemId("029", fieldId, occurrence),
 		value
 	});
+	if (eligible) {
+		put("003", eligible.federalAmount);
+		put("005", eligible.albertaPortion);
+		if (eligible.federalProxyAmount > 0) put("007", eligible.federalProxyAmount);
+		if (eligible.albertaProxyAmount > 0) put("009", eligible.albertaProxyAmount);
+		if (eligible.iegReducingFederalExpenditure > 0) put("011", eligible.iegReducingFederalExpenditure);
+		if (eligible.repaymentOrContractPayment > 0) put("025", eligible.repaymentOrContractPayment);
+		put("031", eligible.totalEligibleExpenditures);
+	}
+	if (primaryFieldCode !== void 0) put("040", primaryFieldCode);
 	put("110", result.creditAtBaseRate);
 	put(result.enhancedRateBasis === "associated" ? "125" : "112", result.creditAtEnhancedRate);
 	put("126", result.taxableCapital);
@@ -524,6 +553,70 @@ function schedule29Values(result, agreement) {
 	};
 }
 /**
+* A separate attachment from Schedule 29 itself, one occurrence per Alberta
+* SR&ED project (101/103/105/107/109/111/113), a TOTAL row (repeats the same
+* field ids at a fixed trailing occurrence — see below), and the jurisdiction
+* table (135–170, occurrence 1, no per-jurisdiction row structure since each
+* jurisdiction has its own field id already).
+*
+* ⚠ The schedule id (`'4970'`) and line-item id scheme used here are a
+* PLACEHOLDER — TRA's own published Guide confirms the field NUMBERS
+* (verified twice, independently) but not the NetFile wire-format encoding
+* for this attachment. See `at4970-ieg-projects.ts` and `forms/at4970.ts`
+* for the same caveat. Verify before relying on this for live filing.
+*
+* The TOTAL row is filed at occurrence `projects.length + 1` — one past the
+* last project row — so a real project can never collide with it.
+*/
+function schedule4970Values(result) {
+	const values = [];
+	const put = (fieldId, value, occurrence = 1) => values.push({
+		lineItemId: `4970${fieldId}${String(occurrence).padStart(3, "0")}`,
+		value
+	});
+	result.projects.forEach((p, i) => {
+		const n = i + 1;
+		put("101", p.title, n);
+		if (p.projectCode !== void 0) put("103", p.projectCode, n);
+		put("105", p.albertaPortion, n);
+		put("107", p.otherPortion, n);
+		put("109", p.salariesAndWages, n);
+		if (p.federalProxyAmount > 0) put("111", p.federalProxyAmount, n);
+		if (p.albertaProxyAmount > 0) put("113", p.albertaProxyAmount, n);
+	});
+	const totalRow = result.projects.length + 1;
+	put("105", result.totals.albertaPortion, totalRow);
+	put("107", result.totals.otherPortion, totalRow);
+	put("109", result.totals.salariesAndWages, totalRow);
+	put("111", result.totals.federalProxyAmount, totalRow);
+	put("113", result.totals.albertaProxyAmount, totalRow);
+	const jurisdictionFields = {
+		alberta: "135",
+		britishColumbia: "137",
+		manitoba: "139",
+		newBrunswick: "141",
+		newfoundlandAndLabrador: "143",
+		northwestTerritories: "145",
+		novaScotia: "147",
+		nunavut: "149",
+		ontario: "151",
+		princeEdwardIsland: "153",
+		quebec: "155",
+		saskatchewan: "157",
+		yukon: "159",
+		other: "161"
+	};
+	for (const j of result.jurisdictions) {
+		const fieldId = jurisdictionFields[j.jurisdiction];
+		if (fieldId && j.amountIncurred > 0) put(fieldId, j.amountIncurred);
+	}
+	if (result.jurisdictionTotal > 0) put("170", result.jurisdictionTotal);
+	return {
+		scheduleId: "4970",
+		values
+	};
+}
+/**
 * The Schedule 21 → Schedule 12 carry-forwards, as the form states them beside
 * each line:
 *
@@ -593,38 +686,26 @@ function schedule12Values(input) {
 		values
 	};
 }
-/** Per-pool line numbers, from the live form. */
-const S21_POOL_LINES = {
-	nonCapital: {
-		opening: "031",
-		current: "037",
-		carryBack: "047",
-		closing: "049"
-	},
-	capital: {
-		opening: "051",
-		current: "057",
-		carryBack: "067",
-		closing: "069"
-	},
-	farm: {
-		opening: "071",
-		current: "077",
-		carryBack: "085",
-		closing: "087"
-	},
-	restrictedFarm: {
-		opening: "091",
-		current: "097",
-		carryBack: "105",
-		closing: "107"
-	},
-	listedPersonalProperty: {
-		opening: "111",
-		current: "117",
-		carryBack: "123",
-		closing: "125"
-	}
+/** `Schedule21FilingInput` key → `AT1_SCHEDULE_21_POOLS` key. */
+const POOL_KEY = {
+	nonCapital: "non-capital",
+	capital: "capital",
+	farm: "farm",
+	restrictedFarm: "restricted-farm",
+	listedPersonalProperty: "listed-personal"
+};
+/** `AlbertaLossPool` field → the `LossContinuityResult` field it reports. */
+const POOL_FIELD_TO_RESULT_KEY = {
+	carriedForward: "openingBalance",
+	expired: "expired",
+	opening: "balanceAtBeginningOfYear",
+	windUpTransfer: "windUpTransfer",
+	currentYearLoss: "currentYearLoss",
+	appliedAgainstIncome: "appliedCurrentYear",
+	section80Adjustment: "section80Adjustment",
+	otherAdjustments: "otherAdjustments",
+	carryBack: "carriedBack",
+	closing: "closingBalance"
 };
 function schedule21Values(input) {
 	const values = [];
@@ -633,14 +714,97 @@ function schedule21Values(input) {
 		value
 	});
 	if (input.currentYearNonCapitalLoss !== void 0) put("021", input.currentYearNonCapitalLoss);
-	for (const [pool, lines] of Object.entries(S21_POOL_LINES)) {
-		const c = input[pool];
+	for (const [inputKey, poolKey] of Object.entries(POOL_KEY)) {
+		const c = input[inputKey];
 		if (!c) continue;
-		put(lines.opening, c.openingBalance);
-		put(lines.current, c.currentYearLoss);
-		put(lines.carryBack, c.carriedBack);
-		put(lines.closing, c.closingBalance);
+		const pool = AT1_SCHEDULE_21_POOLS.find((p) => p.key === poolKey);
+		for (const [field, resultKey] of Object.entries(POOL_FIELD_TO_RESULT_KEY)) {
+			const line = pool[field];
+			if (!line) continue;
+			put(line, c[resultKey]);
+		}
 	}
+	input.limitedPartnershipLosses?.rows.forEach((r, i) => {
+		const n = i + 1;
+		if (r.identifier !== void 0) values.push({
+			lineItemId: at1LineItemId("021", "131", n),
+			value: r.identifier
+		});
+		values.push({
+			lineItemId: at1LineItemId("021", "133", n),
+			value: r.precedingYearBalance
+		});
+		values.push({
+			lineItemId: at1LineItemId("021", "135", n),
+			value: r.transferredOnWindUp
+		});
+		values.push({
+			lineItemId: at1LineItemId("021", "137", n),
+			value: r.currentYearLoss
+		});
+		values.push({
+			lineItemId: at1LineItemId("021", "139", n),
+			value: r.applied
+		});
+		values.push({
+			lineItemId: at1LineItemId("021", "141", n),
+			value: r.closingBalance
+		});
+	});
+	input.nonCapitalByYearOfOrigin?.rows.forEach((r, i) => {
+		const n = i + 1;
+		values.push({
+			lineItemId: at1LineItemId("021", "151", n),
+			value: r.yearIndex
+		});
+		if (r.taxYearEnd !== void 0) values.push({
+			lineItemId: at1LineItemId("021", "153", n),
+			value: r.taxYearEnd
+		});
+		values.push({
+			lineItemId: at1LineItemId("021", "155", n),
+			value: r.balanceAtBeginning
+		});
+		values.push({
+			lineItemId: at1LineItemId("021", "157", n),
+			value: r.lossIncurred
+		});
+		values.push({
+			lineItemId: at1LineItemId("021", "159", n),
+			value: r.adjustments
+		});
+		values.push({
+			lineItemId: at1LineItemId("021", "165", n),
+			value: r.carriedBack
+		});
+		values.push({
+			lineItemId: at1LineItemId("021", "167", n),
+			value: r.applied
+		});
+		values.push({
+			lineItemId: at1LineItemId("021", "169", n),
+			value: r.balanceAtEnd
+		});
+	});
+	input.otherLossesByYearOfOrigin?.rows.forEach((r, i) => {
+		const n = i + 1;
+		values.push({
+			lineItemId: at1LineItemId("021", "181", n),
+			value: r.yearIndex
+		});
+		values.push({
+			lineItemId: at1LineItemId("021", "183", n),
+			value: r.farmLosses
+		});
+		values.push({
+			lineItemId: at1LineItemId("021", "185", n),
+			value: r.restrictedFarmLosses
+		});
+		if (r.yearIndex <= 7) values.push({
+			lineItemId: at1LineItemId("021", "187", n),
+			value: r.listedPersonalPropertyLosses
+		});
+	});
 	return {
 		scheduleId: "021",
 		values
@@ -717,129 +881,2488 @@ function schedule10Values(input) {
 		], input.nonCapital.carrybacks)) put(f, c.amount);
 		put("010", input.nonCapital.remainingLoss);
 	}
-	if (input.capital) {
-		const rate = input.inclusionRate ?? .5;
-		put("042", input.capital.currentYearLoss);
-		for (const [f, c] of zip([
-			"044",
-			"046",
-			"048"
-		], input.capital.carrybacks)) put(f, Math.round(rate * c.amount));
+	if (input.capital) {
+		const rate = input.inclusionRate ?? .5;
+		put("042", input.capital.currentYearLoss);
+		for (const [f, c] of zip([
+			"044",
+			"046",
+			"048"
+		], input.capital.carrybacks)) put(f, Math.round(rate * c.amount));
+	}
+	return {
+		scheduleId: "010",
+		values
+	};
+}
+const S20_CHARITABLE = {
+	opening: "002",
+	expired: "004",
+	beginning: "006",
+	transferred: "008",
+	currentYear: "010",
+	subtotal: "012",
+	acquisitionOfControl: "013",
+	available: "014",
+	applied: "016",
+	closing: "018"
+};
+const S20_GIFTS = {
+	opening: "062",
+	expired: "064",
+	beginning: "066",
+	transferred: "068",
+	currentYear: "070",
+	subtotal: "072",
+	acquisitionOfControl: "073",
+	available: "074",
+	applied: "076",
+	closing: "078"
+};
+function donationContinuityValues(result, f) {
+	const put = (fieldId, value) => ({
+		lineItemId: at1LineItemId("020", fieldId),
+		value
+	});
+	return [
+		put(f.opening, result.openingBalance),
+		put(f.expired, result.expired),
+		put(f.beginning, Math.max(0, result.openingBalance - result.expired)),
+		put(f.transferred, result.transferredIn),
+		put(f.currentYear, result.currentYearGifts),
+		put(f.subtotal, result.transferredIn + result.currentYearGifts),
+		put(f.acquisitionOfControl, result.acquisitionOfControlAdjustment),
+		put(f.available, result.availableBeforeClaim),
+		put(f.applied, result.amountApplied),
+		put(f.closing, result.closingBalance)
+	];
+}
+function schedule20Values(input) {
+	const values = [];
+	if (input.charitable) values.push(...donationContinuityValues(input.charitable, S20_CHARITABLE));
+	if (input.gifts) values.push(...donationContinuityValues(input.gifts, S20_GIFTS));
+	if (input.maximum) {
+		const put = (fieldId, value) => values.push({
+			lineItemId: at1LineItemId("020", fieldId),
+			value
+		});
+		put("030", input.maximum.incomeComponent);
+		put("042", input.maximum.lesserOfProceedsAndCost);
+		put("044", input.maximum.allowableRecapture);
+		put("046", input.maximum.gainsComponent);
+		put("048", input.maximum.maximumDeduction);
+	}
+	return {
+		scheduleId: "020",
+		values
+	};
+}
+/**
+* The SR&ED expenditure POOL — a deduction against income, not the investment tax
+* credit and not the innovation grant.
+*
+* Line numbers and the subtotal formula verified against the live form, which
+* states it exactly as transcribed:
+*
+*   016 = 002 − (004 + 006 + 008) + 010 + 012 + 014 + 015
+*
+* and closes the year-over-year chain in as many words: line 022 is *"the carry
+* forward amount for next year, line 012"*.
+*/
+function schedule16Values(result) {
+	const values = [];
+	const put = (fieldId, value) => values.push({
+		lineItemId: at1LineItemId("016", fieldId),
+		value
+	});
+	put("002", result.currentYearExpenditures);
+	put("016", result.subtotal);
+	put("018", result.deductionAvailable);
+	put("020", result.amountClaimed);
+	put("022", result.unclaimedPoolBalance);
+	return {
+		scheduleId: "016",
+		values
+	};
+}
+//#endregion
+//#region src/t2/at1/schedules/at4970-ieg-projects.ts
+const nn$34 = (v) => Math.max(0, Math.round(v ?? 0));
+function computeAt4970(input) {
+	const projects = input.projects.map((p) => ({
+		title: p.title,
+		...p.projectCode !== void 0 ? { projectCode: p.projectCode } : {},
+		albertaPortion: nn$34(p.albertaPortion),
+		otherPortion: nn$34(p.otherPortion),
+		salariesAndWages: nn$34(p.salariesAndWages),
+		federalProxyAmount: nn$34(p.federalProxyAmount),
+		albertaProxyAmount: nn$34(p.albertaProxyAmount)
+	}));
+	const totals = {
+		albertaPortion: projects.reduce((s, p) => s + p.albertaPortion, 0),
+		otherPortion: projects.reduce((s, p) => s + p.otherPortion, 0),
+		salariesAndWages: projects.reduce((s, p) => s + p.salariesAndWages, 0),
+		federalProxyAmount: projects.reduce((s, p) => s + p.federalProxyAmount, 0),
+		albertaProxyAmount: projects.reduce((s, p) => s + p.albertaProxyAmount, 0)
+	};
+	const jurisdictions = (input.jurisdictions ?? []).map((j) => ({
+		jurisdiction: j.jurisdiction,
+		amountIncurred: nn$34(j.amountIncurred)
+	}));
+	return {
+		projects,
+		totals,
+		jurisdictions,
+		jurisdictionTotal: jurisdictions.reduce((s, j) => s + j.amountIncurred, 0)
+	};
+}
+//#endregion
+//#region src/t2/at1/schedules/schedule2.ts
+/** Round to six decimal places — the AT1 allocation-factor precision. */
+function round6(n) {
+	return Math.round(n * 1e6) / 1e6;
+}
+/** Single Alberta PE, none elsewhere → all income is Alberta income. */
+const SINGLE_JURISDICTION_ALBERTA_FACTOR = 1;
+function computeAllocationFactor(input) {
+	const hasRevenue = input.totalGrossRevenue > 0;
+	const hasSalaries = input.totalSalaries > 0;
+	const revenueRatio = hasRevenue ? input.albertaGrossRevenue / input.totalGrossRevenue : 0;
+	const salariesRatio = hasSalaries ? input.albertaSalaries / input.totalSalaries : 0;
+	let factor;
+	if (hasRevenue && hasSalaries) factor = (revenueRatio + salariesRatio) / 2;
+	else if (hasRevenue) factor = revenueRatio;
+	else if (hasSalaries) factor = salariesRatio;
+	else factor = 0;
+	return round6(factor);
+}
+//#endregion
+//#region src/t2/at1/schedules/schedule3-other-deductions-credits.ts
+/**
+* Alberta AT1 Schedule 3 — Alberta Other Tax Deductions and Credits.
+*
+* NOT one calculation. The spec (TRA spec §3.2.3.4, "3B3B3.2.3.4 Schedule 3 -
+* Alberta Other Tax Deductions and Credits", `AT1-Chapter3-2025.2-full.txt`
+* lines 4127-4898) groups THREE independent non-refundable investment tax
+* credit continuities under one shared ceiling:
+*
+*   ITC    Investor Tax Credit                    (lines 100-108, 120-130)
+*   CITC   Capital Investment Tax Credit           (lines 200-208, 220-230)
+*   APITC  Agri-Processing Investment Tax Credit   (lines 300-316, 330-340)
+*   MAD    Maximum Allowable Deduction — the shared ceiling (lines 600-604)
+*
+* No matching form PDF exists under `research/sources/tra-forms/pdf/` (searched
+* for `AT1SCH03*` — nothing found, unlike every other schedule this package
+* models). The specification TEXT is therefore the only source for this
+* schedule's shape; there is no live-form layout to cross-check it against.
+*
+* ── The shared ceiling (lines 600-604) ───────────────────────────────────────
+*
+*   600 = 003104 + 003204 + 003312          (ITC + CITC + APITC applied)
+*   602 = 000068 − (000070+000071+000072+000074)   (AT1 page 2 room)
+*   604 = lesser of 600 and 602             ("Total Deduction")
+*
+* `000068`/`000070`/`000071`/`000072`/`000074` are AT1 page-2 jacket lines this
+* engine does not compute here (out of this module's scope per the task's scope
+* rule) — they are plain numeric inputs (`MaximumAllowableDeductionInput`).
+*
+* ── Three pools, one room, in a STATED precedence ────────────────────────────
+*
+* ITC is applied first, capped only by 602 itself:
+*   104 ≤ 000068 − (000070+000071+000072+000074)
+*
+* CITC is gated behind ITC: "If 003108 > 0 [ITC still has an unused carryforward
+* balance after this year's application], then [204] must equal zero." Only once
+* the ITC pool is fully drawn down may CITC be claimed, capped at what room ITC
+* left behind:
+*   204 ≤ 602 − 104   (when 108 = 0; otherwise 204 = 0)
+*
+* APITC draws on what both leave behind, but against a DIFFERENT room formula —
+* the spec's four "cannot exceed" clauses for 304/306/308/310 all subtract only
+* `(000070+000072)`, NOT `000071`/`000074` the way 104/204/602 do. That asymmetry
+* is transcribed exactly as written, not corrected, because it repeats
+* identically across all five APITC business-rule cells (304, 306, 308, 310, 312)
+* — consistent enough to be deliberate rather than a transcription slip:
+*   312 ≤ 000068 − (000070+000072) − (104+204)
+*
+* ── APITC: per-vintage percentage caps ───────────────────────────────────────
+*
+* The four "cannot exceed" clauses for 304/306/308/310, read together, are
+* algebraically just ONE combined-total constraint stated four times from four
+* different partial-sum vantage points (each says "this line ≤ R − the lines
+* listed", and the lines listed are exactly the OTHER three) — they collapse to
+* `304+306+308+310 ≤ R`, which is exactly what 312's own business rule states
+* directly. So the four clauses add nothing beyond that one shared-room ceiling;
+* what makes each vintage different is its OWN percentage cap from AAPITC
+* (330-340):
+*
+*   occurrence 0 (current year, 334/336 occ 0)   ≤ 20% of that vintage's receipt
+*   occurrence 1 (1st preceding, occ 1)          ≤ 30% of that vintage's receipt
+*   occurrence 2 (2nd preceding, occ 2)          ≤ 50% of that vintage's receipt
+*   occurrences 3-10 (3rd-10th preceding)        no percentage cap, own balance only
+*
+* `computeSchedule3` claims each vintage's OWN cap first, then allocates the
+* shared room OLDEST-VINTAGE-FIRST when the total requested exceeds it — APITC
+* is a 10-year-preceding, use-it-or-lose-it credit and the spec states no
+* application order, so this engine flags that choice in `issues` rather than
+* silently guessing at NetFile's actual tie-break. Supply `amountApplied` on
+* each vintage directly for exact filing parity.
+*
+* ── What is deliberately NOT modelled ────────────────────────────────────────
+*
+* The AITC/ACITC year-of-origin analysis tables (120-130, 220-230) are
+* supplementary detail TRA requires when a corporation carries ITC or CITC.
+* Unlike AAPITC, the spec gives them no percentage cap or application order of
+* their own — every business rule on those lines is a reconciliation back to the
+* aggregate 104/106/204/206 this module already computes (e.g. "126 … Value must
+* be less than or equal to 124+125", "130 … calculate 124+125-126-128"). Adding a
+* per-vintage array for ITC/CITC would only re-derive numbers this module
+* already produces without a spec-given rule to allocate them across years, so
+* it is left out; a caller filing the AITC/ACITC detail pages supplies that
+* per-vintage split itself.
+*
+* Whole dollars, pure.
+*/
+const nn$33 = (v) => Math.max(0, Math.round(v ?? 0));
+const raw = (v) => Math.round(v ?? 0);
+function computeItc(input, roomCap, issues) {
+	const certificatesIssued = nn$33(input.certificatesIssued);
+	const carryforwardFromPriorYear = nn$33(input.carryforwardFromPriorYear);
+	const expired = nn$33(input.expired);
+	const availableBeforeClaim = certificatesIssued + carryforwardFromPriorYear;
+	const cap = Math.min(availableBeforeClaim, roomCap);
+	const wanted = input.amountApplied != null ? nn$33(input.amountApplied) : cap;
+	const amountApplied = Math.max(0, Math.min(wanted, cap));
+	const carryforwardToNextYear = availableBeforeClaim - amountApplied - expired;
+	if (carryforwardToNextYear < 0) issues.push(`Alberta Schedule 3 (ITC): expired (${expired}) plus the amount applied (${amountApplied}) exceed the available pool (${availableBeforeClaim}) by ${-carryforwardToNextYear}. Check the 100/102/104/106 inputs.`);
+	return {
+		certificatesIssued,
+		carryforwardFromPriorYear,
+		availableBeforeClaim,
+		amountApplied,
+		expired,
+		carryforwardToNextYear
+	};
+}
+function computeCitc(input, roomCap, itcApplied, itcCarryforwardRemaining, issues) {
+	const certificatesIssued = nn$33(input.certificatesIssued);
+	const carryforwardFromPriorYear = nn$33(input.carryforwardFromPriorYear);
+	const expired = nn$33(input.expired);
+	const availableBeforeClaim = certificatesIssued + carryforwardFromPriorYear;
+	let amountApplied;
+	if (itcCarryforwardRemaining > 0) {
+		amountApplied = 0;
+		if (input.amountApplied != null && nn$33(input.amountApplied) > 0) issues.push(`Alberta Schedule 3 (CITC): a claim of ${nn$33(input.amountApplied)} was requested, but the Investor Tax Credit still has an unused carryforward balance (${itcCarryforwardRemaining}) after this year's application, so line 204 must be nil until ITC is fully drawn down.`);
+	} else {
+		const cap = Math.min(availableBeforeClaim, Math.max(0, roomCap - itcApplied));
+		const wanted = input.amountApplied != null ? nn$33(input.amountApplied) : cap;
+		amountApplied = Math.max(0, Math.min(wanted, cap));
+	}
+	const carryforwardToNextYear = availableBeforeClaim - amountApplied - expired;
+	if (carryforwardToNextYear < 0) issues.push(`Alberta Schedule 3 (CITC): expired (${expired}) plus the amount applied (${amountApplied}) exceed the available pool (${availableBeforeClaim}) by ${-carryforwardToNextYear}. Check the 200/202/204/206 inputs.`);
+	return {
+		certificatesIssued,
+		carryforwardFromPriorYear,
+		availableBeforeClaim,
+		amountApplied,
+		expired,
+		carryforwardToNextYear
+	};
+}
+function computeApitc(input, roomCap, issues) {
+	const current = input.current ?? {};
+	const first = input.firstPreceding ?? {};
+	const second = input.secondPreceding ?? {};
+	const thirdToTenth = input.thirdToTenthPreceding ?? {};
+	const currentAvailable = nn$33(current.received);
+	const firstAvailable = nn$33(first.availableAtBeginning);
+	const secondAvailable = nn$33(second.availableAtBeginning);
+	const thirdToTenthAvailable = nn$33(thirdToTenth.availableAtBeginning);
+	const currentCap = Math.round(currentAvailable * .2);
+	const firstCap = Math.round(firstAvailable * .3);
+	const secondCap = Math.round(secondAvailable * .5);
+	const thirdToTenthCap = thirdToTenthAvailable;
+	const currentAsk = Math.min(current.amountApplied != null ? nn$33(current.amountApplied) : currentCap, currentCap);
+	const firstAsk = Math.min(first.amountApplied != null ? nn$33(first.amountApplied) : firstCap, firstCap);
+	const secondAsk = Math.min(second.amountApplied != null ? nn$33(second.amountApplied) : secondCap, secondCap);
+	const thirdToTenthAsk = Math.min(thirdToTenth.amountApplied != null ? nn$33(thirdToTenth.amountApplied) : thirdToTenthCap, thirdToTenthCap);
+	const totalRequested = currentAsk + firstAsk + secondAsk + thirdToTenthAsk;
+	let room = Math.max(0, roomCap);
+	const allocate = (ask) => {
+		const got = Math.min(ask, room);
+		room -= got;
+		return got;
+	};
+	const thirdToTenthApplied = allocate(thirdToTenthAsk);
+	const secondApplied = allocate(secondAsk);
+	const firstApplied = allocate(firstAsk);
+	const currentApplied = allocate(currentAsk);
+	const totalApplied = currentApplied + firstApplied + secondApplied + thirdToTenthApplied;
+	if (totalApplied < totalRequested) issues.push(`Alberta Schedule 3 (APITC): the shared Maximum Allowable Deduction room (${roomCap}) was insufficient to cover ${totalRequested} requested across vintages; ${totalRequested - totalApplied} went unapplied. Allocation prioritized the oldest vintage first (closest to the 10-year expiry) — the spec states only the combined ceiling on 312, not an application order across 304/306/308/310. Supply amountApplied on each vintage directly for exact filing parity.`);
+	const totalReceived = currentAvailable;
+	const carryforwardFromPriorYear = firstAvailable + secondAvailable + thirdToTenthAvailable;
+	const expired = nn$33(input.expiredThisYear);
+	const availableForCarryforward = totalReceived + carryforwardFromPriorYear - totalApplied - expired;
+	if (availableForCarryforward < 0) issues.push(`Alberta Schedule 3 (APITC): applied (${totalApplied}) plus expired (${expired}) exceed the available pool (${totalReceived + carryforwardFromPriorYear}) by ${-availableForCarryforward}. Check the 300/302/312/314 inputs.`);
+	return {
+		current: {
+			available: currentAvailable,
+			ownCap: currentCap,
+			amountApplied: currentApplied
+		},
+		firstPreceding: {
+			available: firstAvailable,
+			ownCap: firstCap,
+			amountApplied: firstApplied
+		},
+		secondPreceding: {
+			available: secondAvailable,
+			ownCap: secondCap,
+			amountApplied: secondApplied
+		},
+		thirdToTenthPreceding: {
+			available: thirdToTenthAvailable,
+			amountApplied: thirdToTenthApplied
+		},
+		totalReceived,
+		carryforwardFromPriorYear,
+		totalRequested,
+		totalApplied,
+		expired,
+		availableForCarryforward
+	};
+}
+function computeSchedule3(input) {
+	const issues = [];
+	const mad = input.mad ?? {};
+	const line068 = nn$33(mad.taxPayableBeforeDeduction);
+	const line070 = nn$33(mad.line070);
+	const line071 = nn$33(mad.line071);
+	const line072 = nn$33(mad.line072);
+	const line074 = nn$33(mad.line074);
+	const room602 = raw(line068) - (line070 + line071 + line072 + line074);
+	const itcCitcCap = Math.max(0, room602);
+	const itc = computeItc(input.itc ?? {}, itcCitcCap, issues);
+	const citc = computeCitc(input.citc ?? {}, itcCitcCap, itc.amountApplied, itc.carryforwardToNextYear, issues);
+	const apitcRoom = Math.max(0, line068 - (line070 + line072) - (itc.amountApplied + citc.amountApplied));
+	const apitc = computeApitc(input.apitc ?? {}, apitcRoom, issues);
+	const creditsApplied = itc.amountApplied + citc.amountApplied + apitc.totalApplied;
+	return {
+		mad: {
+			creditsApplied,
+			room: room602
+		},
+		itc,
+		citc,
+		apitc,
+		totalDeduction: Math.max(0, Math.min(creditsApplied, Math.max(0, room602))),
+		issues
+	};
+}
+function schedule3LineItemId(fieldId, occurrence = 1) {
+	return `003${fieldId}${String(occurrence).padStart(3, "0")}`;
+}
+/**
+* Field ids per the spec transcription above: 100-108 (ITC), 200-208 (CITC),
+* 300-316 (APITC), 600-604 (MAD). The by-year-of-origin detail pages
+* (120-130/220-230/330-340) are NOT emitted — this module does not compute a
+* per-vintage split for ITC/CITC (see the module docstring), and the APITC
+* per-vintage figures this DOES compute (304/306/308/310) are filed on the
+* 300-series rollup, not re-emitted as an AAPITC occurrence table.
+*/
+function schedule3Values(result) {
+	const values = [];
+	const put = (fieldId, value) => values.push({
+		lineItemId: schedule3LineItemId(fieldId),
+		value
+	});
+	put("100", result.itc.certificatesIssued);
+	put("102", result.itc.carryforwardFromPriorYear);
+	put("104", result.itc.amountApplied);
+	put("106", result.itc.expired);
+	put("108", result.itc.carryforwardToNextYear);
+	put("200", result.citc.certificatesIssued);
+	put("202", result.citc.carryforwardFromPriorYear);
+	put("204", result.citc.amountApplied);
+	put("206", result.citc.expired);
+	put("208", result.citc.carryforwardToNextYear);
+	put("300", result.apitc.totalReceived);
+	put("302", result.apitc.carryforwardFromPriorYear);
+	put("304", result.apitc.current.amountApplied);
+	put("306", result.apitc.firstPreceding.amountApplied);
+	put("308", result.apitc.secondPreceding.amountApplied);
+	put("310", result.apitc.thirdToTenthPreceding.amountApplied);
+	put("312", result.apitc.totalApplied);
+	put("314", result.apitc.expired);
+	put("316", result.apitc.availableForCarryforward);
+	put("600", result.mad.creditsApplied);
+	put("602", result.mad.room);
+	put("604", result.totalDeduction);
+	return {
+		scheduleId: "003",
+		values
+	};
+}
+//#endregion
+//#region src/t2/at1/schedules/schedule4-foreign-investment-tax-credit.ts
+const nn$32 = (v) => Math.max(0, v ?? 0);
+/** Round to 3 decimal places, half-up — the precision the spec directs for D and G. */
+function round3(v) {
+	return Math.round((v + Number.EPSILON) * 1e3) / 1e3;
+}
+function computeSchedule4(input) {
+	const issues = [];
+	const albertaTaxableIncome = nn$32(input.albertaTaxableIncome);
+	const royaltyTaxDeduction = nn$32(input.royaltyTaxDeduction);
+	const allocationFactor = input.allocationFactor ?? 0;
+	const basicAlbertaTax = nn$32(input.basicAlbertaTax);
+	const denominator = (albertaTaxableIncome - royaltyTaxDeduction) * allocationFactor;
+	const countries = input.countries.map((c) => {
+		if (!c.country) issues.push("Alberta Schedule 4: a country code is required for each occurrence (004002).");
+		const netForeignInvestmentIncome = nn$32(c.netForeignInvestmentIncome);
+		const fedForeignTaxPaid = nn$32(c.fedForeignTaxPaid);
+		const fedIta2012Deduction = nn$32(c.fedIta2012Deduction);
+		const albertaDeduction = Math.max(c.albertaActa82Deduction ?? fedIta2012Deduction, fedIta2012Deduction);
+		const taxPaidNetOfDeduction = Math.max(0, fedForeignTaxPaid - albertaDeduction);
+		const federalNonBusinessForeignTaxCredit = nn$32(c.fedNonBusinessForeignTaxCredit);
+		let incomeProrationAmount;
+		if (denominator === 0) {
+			incomeProrationAmount = 0;
+			if (netForeignInvestmentIncome > 0) issues.push(`Alberta Schedule 4 (${c.country || "unspecified country"}): (albertaTaxableIncome − royaltyTaxDeduction) × allocationFactor is nil, so the D proration (000068 / that product) cannot be computed. Treated as nil rather than dividing by zero.`);
+		} else incomeProrationAmount = round3(netForeignInvestmentIncome * allocationFactor * (basicAlbertaTax / denominator));
+		const taxPaidLessFederalCredit = round3((taxPaidNetOfDeduction - federalNonBusinessForeignTaxCredit) * allocationFactor);
+		const allowableCredit = Math.max(0, Math.round(Math.min(incomeProrationAmount, taxPaidLessFederalCredit)));
+		return {
+			country: c.country,
+			netForeignInvestmentIncome,
+			taxPaidNetOfDeduction,
+			federalNonBusinessForeignTaxCredit,
+			incomeProrationAmount,
+			taxPaidLessFederalCredit,
+			allowableCredit
+		};
+	});
+	const totalAllowableCredit = countries.reduce((sum, c) => sum + c.allowableCredit, 0);
+	if (input.countries.length > 0 && totalAllowableCredit === 0) issues.push("Alberta Schedule 4: total allowable credit is nil across all occurrences — the spec directs that this form not be printed/filed in that case.");
+	return {
+		countries,
+		totalAllowableCredit,
+		issues
+	};
+}
+/**
+* Net File line items for AT1 Schedule 4 — one FIC occurrence per country.
+* Field ids from the spec (§3.2.3.5): 002 country, 004 net foreign investment
+* income, 006 foreign tax paid net of deduction, 008 federal non-business
+* foreign tax credit, 012 allowable credit.
+*
+* Does NOT emit jacket line 000072 (the sum-vs-remaining-tax comparison) —
+* that is a jacket line, not a Schedule 4 line, and belongs to whichever
+* module builds the jacket. Use `result.totalAllowableCredit` for that.
+*/
+function schedule4Values(result) {
+	const values = [];
+	result.countries.forEach((c, i) => {
+		const n = i + 1;
+		const put = (fieldId, value) => values.push({
+			lineItemId: at1LineItemId("004", fieldId, n),
+			value
+		});
+		put("002", c.country);
+		put("004", c.netForeignInvestmentIncome);
+		put("006", c.taxPaidNetOfDeduction);
+		put("008", c.federalNonBusinessForeignTaxCredit);
+		put("012", c.allowableCredit);
+	});
+	return {
+		scheduleId: "004",
+		values
+	};
+}
+//#endregion
+//#region src/t2/at1/schedules/schedule5-royalty-tax-deduction.ts
+const nn$31 = (v) => Math.max(0, Math.round(v ?? 0));
+const num$2 = (v) => Math.round(v ?? 0);
+function processSuccessoredPool(entries, label, issues) {
+	return (entries ?? []).map((e, i) => {
+		const hasBrought = e.poolBroughtForward !== void 0;
+		const hasAcquired = e.acquisitionAmount !== void 0;
+		if (hasBrought && hasAcquired) issues.push(`Alberta Schedule 5: ${label} occurrence ${i + 1} (${e.vendorName}) has both a pool-brought-forward and an acquisition amount; the spec allows only one per occurrence. Using poolBroughtForward and ignoring acquisitionAmount.`);
+		else if (!hasBrought && !hasAcquired) issues.push(`Alberta Schedule 5: ${label} occurrence ${i + 1} (${e.vendorName}) has neither a pool-brought-forward nor an acquisition amount; treating the pool base as zero.`);
+		const base = nn$31(hasBrought ? e.poolBroughtForward : e.acquisitionAmount);
+		const baseKind = hasBrought ? "broughtForward" : hasAcquired ? "acquired" : "unspecified";
+		const propertyIncome = nn$31(e.propertyIncome);
+		const claim = Math.min(base, propertyIncome);
+		return {
+			vendorName: e.vendorName,
+			dateOfEvent: e.dateOfEvent,
+			base,
+			baseKind,
+			propertyIncome,
+			claim,
+			carryForwardBeforeTransfer: base - claim
+		};
+	});
+}
+function computeAlbertaSchedule5(input) {
+	const issues = [];
+	const crownCharges = nn$31(input.crownChargesNetOfReimbursements);
+	const resourceAllowance = nn$31(input.albertaResourceAllowance ?? input.federalResourceAllowance);
+	const reimbursements = nn$31(input.reimbursementsForCrownCharges);
+	const predecessorTransfersTotal = (input.predecessorTransfers ?? []).reduce((s, t) => s + nn$31(t.amountTransferred), 0);
+	const attributedRoyaltyIncomeCarryForwardIn = nn$31(input.openingUnsuccessoredPoolBalance) + predecessorTransfersTotal;
+	const unsuccessoredPoolAvailable = crownCharges - resourceAllowance - reimbursements + attributedRoyaltyIncomeCarryForwardIn;
+	const hasSuccessoredPools = input.hasSuccessoredPools ?? false;
+	if (!hasSuccessoredPools && ((input.secondSuccessoredPools?.length ?? 0) > 0 || (input.firstSuccessoredPools?.length ?? 0) > 0)) issues.push("Alberta Schedule 5: hasSuccessoredPools (005200) is false, but successored pool occurrences were supplied. Per the spec, 005101-005140 must not exist when 005200 = 2 (No); the supplied occurrences were ignored.");
+	const secondSuccessoredPools = hasSuccessoredPools ? processSuccessoredPool(input.secondSuccessoredPools, "second successored (SSPI)", issues) : [];
+	const firstSuccessoredPools = hasSuccessoredPools ? processSuccessoredPool(input.firstSuccessoredPools, "first successored (FSPI)", issues) : [];
+	const secondSuccessoredSubtotal = secondSuccessoredPools.reduce((s, e) => s + e.carryForwardBeforeTransfer, 0);
+	const firstSuccessoredSubtotal = firstSuccessoredPools.reduce((s, e) => s + e.carryForwardBeforeTransfer, 0);
+	const successoredTotal = secondSuccessoredPools.reduce((s, e) => s + e.claim, 0) + firstSuccessoredPools.reduce((s, e) => s + e.claim, 0);
+	const albertaTaxableIncome = num$2(input.albertaTaxableIncomeBeforeDeduction);
+	const crtdMaxClaimable = Math.max(0, Math.min(unsuccessoredPoolAvailable, albertaTaxableIncome - successoredTotal));
+	const crtdClaim = input.crtdAmountClaimed != null ? Math.max(0, Math.min(Math.round(input.crtdAmountClaimed), crtdMaxClaimable)) : crtdMaxClaimable;
+	const poolAvailableCarryForward = unsuccessoredPoolAvailable - crtdClaim;
+	const transferredOnDisposal = nn$31(input.transferredOnDisposal);
+	const uncappedTotal = crtdClaim + successoredTotal;
+	const totalRoyaltyTaxDeduction = Math.max(0, Math.min(uncappedTotal, albertaTaxableIncome));
+	if (totalRoyaltyTaxDeduction < uncappedTotal && uncappedTotal > albertaTaxableIncome) if (albertaTaxableIncome < 0) issues.push(`Alberta Schedule 5: Alberta taxable income before the deduction (AT1 line 062) is ${albertaTaxableIncome}, which is negative. AT1 line 064 is specified as "005016 + 005140, cannot exceed 000062" with no stated floor; this engine floors the combined deduction at zero rather than reporting a negative Royalty Tax Deduction. The successored-pool claims (005140 = ${successoredTotal}) are computed independently of line 062 and are NOT reduced by this cap — review manually if this scenario occurs.`);
+	else issues.push(`Alberta Schedule 5: the combined Royalty Tax Deduction (005016 + 005140 = ${uncappedTotal}) exceeds Alberta taxable income before the deduction (AT1 line 062 = ${albertaTaxableIncome}); AT1 line 064 is capped at ${totalRoyaltyTaxDeduction} per the spec.`);
+	const netOfResourceAllowance = crownCharges - resourceAllowance;
+	const carryForwardRaw = netOfResourceAllowance >= 0 ? netOfResourceAllowance + attributedRoyaltyIncomeCarryForwardIn - totalRoyaltyTaxDeduction - transferredOnDisposal : attributedRoyaltyIncomeCarryForwardIn - totalRoyaltyTaxDeduction - transferredOnDisposal;
+	const attributedRoyaltyIncomeCarryForwardOut = Math.max(0, carryForwardRaw);
+	if (input.poolTransfer) {
+		const { type, acquirerName } = input.poolTransfer;
+		if ((type === 1 || type === 2) && !acquirerName) issues.push("Alberta Schedule 5: pool transfer type (005026) is 1 or 2, but the acquiring corporation's legal name (005027) is missing.");
+		if (type === 3 && acquirerName) issues.push("Alberta Schedule 5: pool transfer type (005026) is 3 (no transfer), but an acquiring corporation name (005027) was supplied. Per the spec, 005027 must be blank when 005026 = 3.");
+	}
+	if (input.changeInControlEndedPrecedingYear !== void 0 && input.at1TaxYearEndChanged !== void 0 && input.at1TaxYearEndChangeReason !== void 0) {
+		const cicChangedYearEnd = input.at1TaxYearEndChanged && input.at1TaxYearEndChangeReason === 2;
+		if (input.changeInControlEndedPrecedingYear !== cicChangedYearEnd) issues.push(`Alberta Schedule 5: 005100 (change in control ended the preceding taxation year) is ${input.changeInControlEndedPrecedingYear}, which is inconsistent with AT1 core 000038/000039 (tax year end changed due to change in control = ${cicChangedYearEnd}). Per the spec, these must agree in both directions.`);
+	}
+	const formRequired = crownCharges > 0 || attributedRoyaltyIncomeCarryForwardIn > 0 || hasSuccessoredPools;
+	return {
+		crownCharges,
+		resourceAllowance,
+		reimbursements,
+		predecessorTransfersTotal,
+		attributedRoyaltyIncomeCarryForwardIn,
+		unsuccessoredPoolAvailable,
+		crtdMaxClaimable,
+		crtdClaim,
+		poolAvailableCarryForward,
+		transferredOnDisposal,
+		secondSuccessoredPools,
+		firstSuccessoredPools,
+		secondSuccessoredSubtotal,
+		firstSuccessoredSubtotal,
+		successoredTotal,
+		totalRoyaltyTaxDeduction,
+		attributedRoyaltyIncomeCarryForwardOut,
+		...input.poolTransfer !== void 0 ? { poolTransfer: input.poolTransfer } : {},
+		...input.changeInControlEndedPrecedingYear !== void 0 ? { changeInControlEndedPrecedingYear: input.changeInControlEndedPrecedingYear } : {},
+		formRequired,
+		issues
+	};
+}
+/** `005` + field id + 3-digit occurrence — the nine-digit AT1 line item id. */
+function schedule5LineItemId(fieldId, occurrence = 1) {
+	return `005${fieldId}${String(occurrence).padStart(3, "0")}`;
+}
+function putSuccessoredPool(values, entries, fields) {
+	entries.forEach((e, i) => {
+		const n = i + 1;
+		const put = (fieldId, value) => values.push({
+			lineItemId: schedule5LineItemId(fieldId, n),
+			value
+		});
+		put(fields.vendorName, e.vendorName);
+		put(fields.dateOfEvent, e.dateOfEvent);
+		if (e.baseKind === "broughtForward") put(fields.broughtForward, e.base);
+		else if (e.baseKind === "acquired") put(fields.acquired, e.base);
+		put(fields.propertyIncome, e.propertyIncome);
+		put(fields.claim, e.claim);
+		put(fields.carryForward, e.carryForwardBeforeTransfer);
+	});
+}
+function schedule5Values(result) {
+	const values = [];
+	const put = (fieldId, value) => values.push({
+		lineItemId: schedule5LineItemId(fieldId),
+		value
+	});
+	put("001", result.crownCharges);
+	put("005", result.resourceAllowance);
+	put("007", result.reimbursements);
+	put("011", result.attributedRoyaltyIncomeCarryForwardIn);
+	put("016", result.crtdClaim);
+	put("017", result.poolAvailableCarryForward);
+	put("023", result.transferredOnDisposal);
+	put("025", result.attributedRoyaltyIncomeCarryForwardOut);
+	if (result.poolTransfer) {
+		put("026", result.poolTransfer.type);
+		if (result.poolTransfer.acquirerName) put("027", result.poolTransfer.acquirerName);
+	}
+	if (result.changeInControlEndedPrecedingYear !== void 0) put("100", result.changeInControlEndedPrecedingYear ? 1 : 2);
+	putSuccessoredPool(values, result.secondSuccessoredPools, {
+		vendorName: "101",
+		dateOfEvent: "103",
+		broughtForward: "105",
+		acquired: "107",
+		propertyIncome: "109",
+		claim: "111",
+		carryForward: "113"
+	});
+	put("115", result.secondSuccessoredSubtotal);
+	putSuccessoredPool(values, result.firstSuccessoredPools, {
+		vendorName: "121",
+		dateOfEvent: "123",
+		broughtForward: "125",
+		acquired: "127",
+		propertyIncome: "129",
+		claim: "131",
+		carryForward: "133"
+	});
+	put("135", result.firstSuccessoredSubtotal);
+	put("140", result.successoredTotal);
+	return {
+		scheduleId: "005",
+		values
+	};
+}
+//#endregion
+//#region src/t2/at1/schedules/schedule6-royalty-tax-credit.ts
+const rd$1 = (v) => Math.round(v ?? 0);
+const nn$30 = (v) => Math.max(0, Math.round(v ?? 0));
+const round4$1 = (v) => Math.round(v * 1e4) / 1e4;
+function computeWeightedAverageRate(quarters, issues) {
+	if (quarters.length === 0) {
+		issues.push("Alberta Schedule 6: no quarters were supplied for the weighted average rate (006008 is mandatory). Defaulted to 0 — supply the RTC quarterly rate(s) from Alberta Treasury Board and Finance's published rate table.");
+		return 0;
+	}
+	const totalDays = quarters.reduce((s, q) => s + Math.max(0, q.days), 0);
+	if (totalDays <= 0) {
+		issues.push("Alberta Schedule 6: the quarters supplied for 006008 total zero days.");
+		return 0;
+	}
+	const weighted = quarters.reduce((s, q) => s + Math.max(0, q.days) / totalDays * q.rate, 0);
+	return round4$1(weighted);
+}
+function resolveAllocations(allocations, pool, issues) {
+	const totalRequested = allocations.reduce((s, a) => s + nn$30(a.allocatedAmount), 0);
+	if (totalRequested > pool) issues.push(`Alberta Schedule 6: the associated group allocated ${totalRequested} of a Crown Royalty Shelter pool of ${pool} (006034 occurrences exceed the $2,000,000 × (006028/365) limit). Allocations were capped in the order given — the group must agree a valid split.`);
+	let remaining = pool;
+	return allocations.map((a) => {
+		const requestedAmount = nn$30(a.allocatedAmount);
+		const allocatedAmount = Math.min(requestedAmount, remaining);
+		remaining -= allocatedAmount;
+		return {
+			name: a.name,
+			...a.albertaCan !== void 0 ? { albertaCan: a.albertaCan } : {},
+			allocatedAmount,
+			requestedAmount
+		};
+	});
+}
+function schedule6LineItemId(fieldId, occurrence = 1) {
+	return `006${fieldId}${String(occurrence).padStart(3, "0")}`;
+}
+/**
+* Emits every field this module's own MAPPINGS transcription actually defines
+* a number for: 006002/004/006/008, and — only when the corporation is
+* associated — the ACRS section (006022-028) and the AACRS allocation table
+* (006030-034, one occurrence per row).
+*
+* ── No credit amount is filed here, because none exists on this schedule ────
+*
+* See the module docstring's "CONFIRMED: there is no 'credit' dollar amount
+* to compute here" section — the Alberta Royalty Tax Credit is an instalment
+* program (AT1 jacket line 000082, the shared "Payments & Instalments"
+* schedule), not a value Schedule 6 computes and files. This builder emits
+* exactly the three components the schedule DOES define (006004, 006006,
+* 006008) plus the ACRS/AACRS detail when associated — matching
+* `schedule3Values`'s `At1ScheduleDataLike` shape exactly: `{ scheduleId,
+* values }`.
+*/
+function schedule6Values(result) {
+	const values = [];
+	const put = (fieldId, value, occurrence = 1) => values.push({
+		lineItemId: schedule6LineItemId(fieldId, occurrence),
+		value
+	});
+	put("002", result.associatedWithCrownRoyaltyCorporations ? 1 : 2);
+	put("004", result.albertaCrownRoyaltyIncurred);
+	put("006", result.crownRoyaltyShelter);
+	put("008", result.weightedAverageRate);
+	if (result.associatedWithCrownRoyaltyCorporations && result.longestAssociatedYear) {
+		if (result.longestAssociatedYear.albertaCan !== void 0) values.push({
+			lineItemId: schedule6LineItemId("022"),
+			value: result.longestAssociatedYear.albertaCan
+		});
+		if (result.longestAssociatedYear.taxationYearBeginning !== void 0) values.push({
+			lineItemId: schedule6LineItemId("024"),
+			value: result.longestAssociatedYear.taxationYearBeginning
+		});
+		if (result.longestAssociatedYear.taxationYearEnding !== void 0) values.push({
+			lineItemId: schedule6LineItemId("026"),
+			value: result.longestAssociatedYear.taxationYearEnding
+		});
+		put("028", result.longestAssociatedYear.days);
+		result.allocations.forEach((a, i) => {
+			const occurrence = i + 1;
+			values.push({
+				lineItemId: schedule6LineItemId("030", occurrence),
+				value: a.name
+			});
+			if (a.albertaCan !== void 0) values.push({
+				lineItemId: schedule6LineItemId("032", occurrence),
+				value: a.albertaCan
+			});
+			put("034", a.allocatedAmount, occurrence);
+		});
+	}
+	return {
+		scheduleId: "006",
+		values
+	};
+}
+function computeAlbertaSchedule6(input) {
+	const issues = [];
+	const associatedWithCrownRoyaltyCorporations = input.associatedWithCrownRoyaltyCorporations ?? false;
+	const albertaCrownRoyaltyIncurred = rd$1(input.albertaCrownRoyaltyIncurred);
+	const weightedAverageRate = computeWeightedAverageRate(input.quarters ?? [], issues);
+	const formRequired = albertaCrownRoyaltyIncurred > 0;
+	if (!associatedWithCrownRoyaltyCorporations) {
+		const days = Math.max(0, Math.min(input.taxationYearDays ?? 365, 365));
+		return {
+			associatedWithCrownRoyaltyCorporations,
+			albertaCrownRoyaltyIncurred,
+			crownRoyaltyShelter: Math.round(2e6 * (days / 365)),
+			weightedAverageRate,
+			aggregateShelterPool: 0,
+			allocations: [],
+			totalAllocated: 0,
+			formRequired,
+			issues
+		};
+	}
+	if (!input.longestAssociatedYear) issues.push("Alberta Schedule 6: the corporation is associated with one or more corporations that incurred Alberta Crown Royalty (006002 = 1), but no ACRS data (006022-006028, the associated corporation with the longest taxation year) was supplied. The Crown Royalty Shelter pool defaulted to zero.");
+	const days = Math.max(0, Math.min(input.longestAssociatedYear?.days ?? 0, 365));
+	const aggregateShelterPool = Math.round(2e6 * (days / 365));
+	const rawAllocations = input.allocations ?? [];
+	if (rawAllocations.length === 0) issues.push("Alberta Schedule 6: the corporation is associated (006002 = 1), but no AACRS allocation rows (006030-006034) were supplied. This filer's own Crown Royalty Shelter (006006) defaulted to zero.");
+	const allocations = resolveAllocations(rawAllocations, aggregateShelterPool, issues);
+	const totalAllocated = allocations.reduce((s, a) => s + a.allocatedAmount, 0);
+	return {
+		associatedWithCrownRoyaltyCorporations,
+		albertaCrownRoyaltyIncurred,
+		crownRoyaltyShelter: allocations[0]?.allocatedAmount ?? 0,
+		weightedAverageRate,
+		longestAssociatedYear: {
+			...input.longestAssociatedYear?.albertaCan !== void 0 ? { albertaCan: input.longestAssociatedYear.albertaCan } : {},
+			...input.longestAssociatedYear?.taxationYearBeginning !== void 0 ? { taxationYearBeginning: input.longestAssociatedYear.taxationYearBeginning } : {},
+			...input.longestAssociatedYear?.taxationYearEnding !== void 0 ? { taxationYearEnding: input.longestAssociatedYear.taxationYearEnding } : {},
+			days
+		},
+		aggregateShelterPool,
+		allocations,
+		totalAllocated,
+		formRequired,
+		issues
+	};
+}
+//#endregion
+//#region src/t2/at1/schedules/schedule7-royalty-supplemental.ts
+/** Signed whole-dollar rounding — no floor, several of these lines are marked "+/-". */
+const rd = (v) => Math.round(v ?? 0);
+/** Non-negative whole-dollar rounding, for the "+"-only lines. */
+const nn$29 = (v) => Math.max(0, Math.round(v ?? 0));
+const round4 = (v) => Math.round(v * 1e4) / 1e4;
+function resolvePartnership(p, index, issues) {
+	if (!p.name) issues.push(`Alberta Schedule 7: partnership row ${index + 1} has no name (007071 is mandatory for every PITI occurrence).`);
+	if (p.interestPercent < 0 || p.interestPercent > 1) issues.push(`Alberta Schedule 7: ${p.name || `partnership row ${index + 1}`} has an interest of ${p.interestPercent}, expected a decimal between 0 and 1 (007073, e.g. .7500 for 75%).`);
+	return {
+		name: p.name,
+		interestPercent: round4(p.interestPercent),
+		...p.fiscalPeriodEnd !== void 0 ? { fiscalPeriodEnd: p.fiscalPeriodEnd } : {},
+		shareEligibleForCredit: nn$29(p.shareEligibleForCredit),
+		shareOtherRoyaltiesNotEligible: nn$29(p.shareOtherRoyaltiesNotEligible),
+		shareOtherCrownChargesEligibleForDeduction: nn$29(p.shareOtherCrownChargesEligibleForDeduction)
+	};
+}
+function resolveAdjustment(a, index, issues) {
+	if (!a.priorProductionPeriodEnd) issues.push(`Alberta Schedule 7: prior-year adjustment row ${index + 1} has no prior production period (007083 is mandatory for every ACRA occurrence).`);
+	if (a.sourceOfAdjustment !== 1 && a.sourceOfAdjustment !== 2) issues.push(`Alberta Schedule 7: prior-year adjustment row ${index + 1} has no valid source code (007085 must be 1 = Dept. of Resource Development or 2 = Operator).`);
+	return {
+		...a.priorProductionPeriodEnd !== void 0 ? { priorProductionPeriodEnd: a.priorProductionPeriodEnd } : {},
+		...a.sourceOfAdjustment !== void 0 ? { sourceOfAdjustment: a.sourceOfAdjustment } : {},
+		increase: nn$29(a.increase),
+		decrease: nn$29(a.decrease),
+		adjustmentNotEligibleForCredit: rd(a.adjustmentNotEligibleForCredit)
+	};
+}
+function schedule7LineItemId(fieldId, occurrence = 1) {
+	return `007${fieldId}${String(occurrence).padStart(3, "0")}`;
+}
+/**
+* Emits CPI (007003-029), the computed totals 007051 and 007061, and the two
+* repeating sections — PITI (007071-081, one occurrence per partnership) and
+* ACRA (007083-091, one occurrence per prior-year adjustment).
+*
+* 007061 is filed even though it has no defining row of its own anywhere in
+* this schedule's MAPPINGS block (spec lines 6654-7251) — see the module
+* docstring's "Two totals with NO defining row of their own in this MAPPINGS
+* table" section. It is a real Schedule 7 output line: AT1 Schedule 5's own
+* field 005001 definition (spec lines 5237-5248) names it explicitly as
+* "Schedule 7, line 061" and gives its formula in full, so it is filed here
+* under that citation rather than omitted for lack of a home row.
+*/
+function schedule7Values(result) {
+	const values = [];
+	const put = (fieldId, value, occurrence = 1) => values.push({
+		lineItemId: schedule7LineItemId(fieldId, occurrence),
+		value
+	});
+	put("003", result.eligibleCrownRoyalty);
+	put("005", result.otherRoyaltiesNotEligible);
+	put("007", result.royaltyPaidToOtherJurisdictions);
+	put("009", result.nonDeductibleCrownLeaseRentals);
+	put("011", result.mineralTaxes);
+	put("013", result.saskatchewanResourcesSurcharge);
+	result.otherNonDeductibleCrownChargeTypes.forEach((name, i) => {
+		values.push({
+			lineItemId: schedule7LineItemId(String(14 + i).padStart(3, "0")),
+			value: name
+		});
+	});
+	put("017", result.otherNonDeductibleCrownCharges);
+	put("025", result.crownLeaseRentalsCapitalized);
+	if (result.otherBalanceSheetDeductionName !== void 0) values.push({
+		lineItemId: schedule7LineItemId("027"),
+		value: result.otherBalanceSheetDeductionName
+	});
+	put("029", result.otherBalanceSheetDeduction);
+	result.partnerships.forEach((p, i) => {
+		const occurrence = i + 1;
+		values.push({
+			lineItemId: schedule7LineItemId("071", occurrence),
+			value: p.name
+		});
+		put("073", p.interestPercent, occurrence);
+		if (p.fiscalPeriodEnd !== void 0) values.push({
+			lineItemId: schedule7LineItemId("075", occurrence),
+			value: p.fiscalPeriodEnd
+		});
+		put("077", p.shareEligibleForCredit, occurrence);
+		put("079", p.shareOtherRoyaltiesNotEligible, occurrence);
+		put("081", p.shareOtherCrownChargesEligibleForDeduction, occurrence);
+	});
+	result.priorYearAdjustments.forEach((a, i) => {
+		const occurrence = i + 1;
+		if (a.priorProductionPeriodEnd !== void 0) values.push({
+			lineItemId: schedule7LineItemId("083", occurrence),
+			value: a.priorProductionPeriodEnd
+		});
+		if (a.sourceOfAdjustment !== void 0) put("085", a.sourceOfAdjustment, occurrence);
+		put("087", a.increase, occurrence);
+		put("089", a.decrease, occurrence);
+		put("091", a.adjustmentNotEligibleForCredit, occurrence);
+	});
+	put("051", result.totalAdjustments);
+	put("061", result.crownChargesNetOfReimbursements);
+	return {
+		scheduleId: "007",
+		values
+	};
+}
+function computeAlbertaSchedule7(input) {
+	const issues = [];
+	const eligibleCrownRoyalty = rd(input.eligibleCrownRoyalty);
+	const otherRoyaltiesNotEligible = rd(input.otherRoyaltiesNotEligible);
+	const royaltyPaidToOtherJurisdictions = rd(input.royaltyPaidToOtherJurisdictions);
+	const nonDeductibleCrownLeaseRentals = rd(input.nonDeductibleCrownLeaseRentals);
+	const mineralTaxes = rd(input.mineralTaxes);
+	const saskatchewanResourcesSurcharge = rd(input.saskatchewanResourcesSurcharge);
+	const otherNonDeductibleCrownChargeTypes = (input.otherNonDeductibleCrownChargeTypes ?? []).slice(0, 3);
+	if ((input.otherNonDeductibleCrownChargeTypes?.length ?? 0) > 3) issues.push("Alberta Schedule 7: more than three other non-deductible crown charge types were supplied (007014/015/016 allow three); only the first three were kept.");
+	let otherNonDeductibleCrownCharges = rd(input.otherNonDeductibleCrownCharges);
+	if (otherNonDeductibleCrownChargeTypes.length === 0 && otherNonDeductibleCrownCharges !== 0) {
+		issues.push("Alberta Schedule 7: an amount was given for other non-deductible crown charges (007017) but no charge type was named (007014/015/016). The spec defaults 007017 to zero when no type is named; the amount was zeroed out.");
+		otherNonDeductibleCrownCharges = 0;
+	}
+	const crownLeaseRentalsCapitalized = rd(input.crownLeaseRentalsCapitalized);
+	let otherBalanceSheetDeduction = nn$29(input.otherBalanceSheetDeduction);
+	if (!input.otherBalanceSheetDeductionName && otherBalanceSheetDeduction !== 0) {
+		issues.push("Alberta Schedule 7: an amount was given for another balance sheet eligible deduction (007029) but no deduction was named (007027). The spec defaults 007029 to zero when no name is given; the amount was zeroed out.");
+		otherBalanceSheetDeduction = 0;
+	}
+	const partnerships = (input.partnerships ?? []).map((p, i) => resolvePartnership(p, i, issues));
+	const totalPartnershipShareEligibleForCredit = partnerships.reduce((s, p) => s + p.shareEligibleForCredit, 0);
+	const totalPartnershipShareOtherRoyaltiesNotEligible = partnerships.reduce((s, p) => s + p.shareOtherRoyaltiesNotEligible, 0);
+	const totalPartnershipShareOtherCrownCharges = partnerships.reduce((s, p) => s + p.shareOtherCrownChargesEligibleForDeduction, 0);
+	const priorYearAdjustments = (input.priorYearAdjustments ?? []).map((a, i) => resolveAdjustment(a, i, issues));
+	const totalIncrease = priorYearAdjustments.reduce((s, a) => s + a.increase, 0);
+	const totalDecrease = priorYearAdjustments.reduce((s, a) => s + a.decrease, 0);
+	const totalAdjustmentNotEligible = priorYearAdjustments.reduce((s, a) => s + a.adjustmentNotEligibleForCredit, 0);
+	const totalAdjustments = priorYearAdjustments.length === 0 ? 0 : totalIncrease - totalDecrease + totalAdjustmentNotEligible;
+	const crownChargesNetOfReimbursements = eligibleCrownRoyalty + otherRoyaltiesNotEligible + royaltyPaidToOtherJurisdictions + nonDeductibleCrownLeaseRentals + mineralTaxes + saskatchewanResourcesSurcharge + otherNonDeductibleCrownCharges + crownLeaseRentalsCapitalized + otherBalanceSheetDeduction + totalPartnershipShareEligibleForCredit + totalPartnershipShareOtherRoyaltiesNotEligible + totalPartnershipShareOtherCrownCharges - totalAdjustments;
+	const albertaCrownRoyaltyForSchedule6 = eligibleCrownRoyalty + totalPartnershipShareEligibleForCredit - totalIncrease + totalDecrease;
+	return {
+		eligibleCrownRoyalty,
+		otherRoyaltiesNotEligible,
+		royaltyPaidToOtherJurisdictions,
+		nonDeductibleCrownLeaseRentals,
+		mineralTaxes,
+		saskatchewanResourcesSurcharge,
+		otherNonDeductibleCrownChargeTypes,
+		otherNonDeductibleCrownCharges,
+		crownLeaseRentalsCapitalized,
+		...input.otherBalanceSheetDeductionName !== void 0 ? { otherBalanceSheetDeductionName: input.otherBalanceSheetDeductionName } : {},
+		otherBalanceSheetDeduction,
+		partnerships,
+		totalPartnershipShareEligibleForCredit,
+		totalPartnershipShareOtherRoyaltiesNotEligible,
+		totalPartnershipShareOtherCrownCharges,
+		priorYearAdjustments,
+		totalAdjustments,
+		crownChargesNetOfReimbursements,
+		albertaCrownRoyaltyForSchedule6,
+		issues
+	};
+}
+//#endregion
+//#region src/t2/at1/schedules/schedule8-political-contributions.ts
+const nn$28 = (v) => Math.max(0, Math.round(v ?? 0));
+function yearOf(dateIso) {
+	if (!dateIso || dateIso.length < 4) return void 0;
+	const y = Number(dateIso.slice(0, 4));
+	return Number.isFinite(y) ? y : void 0;
+}
+/** Tiered rate for the "all made in 2003 or earlier" branch. */
+function tierTo2003(a) {
+	if (a <= 150) return a * .75;
+	if (a <= 825) return 112.5 + (a - 150) * .5;
+	return 450 + (a - 825) * .333;
+}
+/** Tiered rate for the "all made in 2004 or later" branch. */
+function tierFrom2004(a) {
+	if (a <= 200) return a * .75;
+	if (a <= 900) return 150 + (a - 200) * .5;
+	return 600 + (a - 900) * .333;
+}
+function computeSchedule8$1(input) {
+	const issues = [];
+	const contributions = input.contributions ?? [];
+	contributions.forEach((c, i) => {
+		if (!c.dateOfDonation) issues.push(`Alberta Schedule 8: contribution #${i + 1} (${c.name || "unnamed"}) has no date of donation (008006) — the spec requires one for every receipted contribution.`);
+		if (!c.receiptNumber) issues.push(`Alberta Schedule 8: contribution #${i + 1} (${c.name || "unnamed"}) has no official receipt number (008004).`);
+	});
+	const partnershipContributionsTo2003 = nn$28(input.partnershipContributionsTo2003);
+	const partnershipContributionsFrom2004 = nn$28(input.partnershipContributionsFrom2004);
+	const totalDirect = contributions.reduce((sum, c) => sum + nn$28(c.amount), 0);
+	const directTo2003 = contributions.filter((c) => (yearOf(c.dateOfDonation) ?? 0) <= 2003).reduce((sum, c) => sum + nn$28(c.amount), 0);
+	const directFrom2004 = contributions.filter((c) => (yearOf(c.dateOfDonation) ?? 9999) >= 2004).reduce((sum, c) => sum + nn$28(c.amount), 0);
+	const directIn2004Only = contributions.filter((c) => yearOf(c.dateOfDonation) === 2004).reduce((sum, c) => sum + nn$28(c.amount), 0);
+	const hasTo2003 = directTo2003 > 0 || partnershipContributionsTo2003 > 0;
+	const hasFrom2004 = directFrom2004 > 0 || partnershipContributionsFrom2004 > 0;
+	if (!hasTo2003 && !hasFrom2004) return {
+		contributions,
+		partnershipContributionsTo2003,
+		partnershipContributionsFrom2004,
+		period: "none",
+		creditBeforeCeiling: 0,
+		credit: 0,
+		issues
+	};
+	const taxYearBeginYear = yearOf(input.taxYearBegin);
+	const taxYearEndYear = yearOf(input.taxYearEnd);
+	const taxYearStraddles2003to2004 = taxYearBeginYear === 2003 && taxYearEndYear === 2004;
+	const ceiling = input.remainingBasicTax;
+	let period;
+	let rawCredit;
+	let credit;
+	if (hasTo2003 && !hasFrom2004) {
+		period = "to-2003";
+		rawCredit = tierTo2003(totalDirect + partnershipContributionsTo2003);
+		if (ceiling == null) {
+			issues.push("Alberta Schedule 8: remainingBasicTax (000068 − (000070+000071+000072)) was not supplied, so no political contributions credit can be claimed for the 2003-or-earlier rate period.");
+			credit = 0;
+		} else credit = Math.max(0, Math.round(Math.min(rawCredit, 750, ceiling)));
+	} else if (hasFrom2004 && !hasTo2003) {
+		period = "from-2004";
+		rawCredit = tierFrom2004(totalDirect + partnershipContributionsFrom2004);
+		if (ceiling == null) {
+			issues.push("Alberta Schedule 8: remainingBasicTax (000068 − (000070+000071+000072)) was not supplied, so no political contributions credit can be claimed for the 2004-or-later rate period.");
+			credit = 0;
+		} else credit = Math.max(0, Math.round(Math.min(rawCredit, 1e3, ceiling)));
+	} else if (taxYearStraddles2003to2004) {
+		period = "straddle-2003-2004";
+		const x = directIn2004Only + partnershipContributionsFrom2004;
+		const y = totalDirect + partnershipContributionsTo2003 + partnershipContributionsFrom2004;
+		const a = Math.min(y, 150);
+		const b = Math.min(Math.max(0, x - a), 50);
+		const c = Math.min(Math.max(0, y - (a + b)), 675);
+		const d = Math.min(Math.max(0, x - (a + b + c)), 225);
+		const e = Math.min(Math.max(0, y - (a + b + c + d)), 900);
+		const f = Math.min(Math.max(0, x - (a + b + c + d + e)), 300);
+		rawCredit = .75 * a + .75 * b + .5 * c + .5 * d + e / 3 + f / 3;
+		credit = Math.max(0, Math.round(rawCredit));
+	} else {
+		period = "none";
+		rawCredit = 0;
+		credit = 0;
+		issues.push("Alberta Schedule 8: contributions span both the 2003-or-earlier and 2004-or-later rate periods, but the tax year does not begin in 2003 and end in 2004 — the spec only defines a mixed-period formula for that straddling tax year. No credit computed.");
+	}
+	return {
+		contributions,
+		partnershipContributionsTo2003,
+		partnershipContributionsFrom2004,
+		period,
+		creditBeforeCeiling: Math.round(rawCredit),
+		credit,
+		issues
+	};
+}
+/**
+* Net File line items for AT1 Schedule 8: one PCD occurrence per contribution
+* (002 name, 004 receipt number, 006 date, 008 amount), plus the two APC
+* partnership totals (012, 013).
+*
+* Does NOT emit jacket line 000074 (the actual tax credit) — that is a
+* jacket line, not a Schedule 8 line. Use `result.credit` for that.
+*/
+function schedule8Values(result) {
+	const values = [];
+	result.contributions.forEach((c, i) => {
+		const n = i + 1;
+		const put = (fieldId, value) => values.push({
+			lineItemId: at1LineItemId("008", fieldId, n),
+			value
+		});
+		put("002", c.name);
+		put("004", c.receiptNumber);
+		put("006", c.dateOfDonation);
+		put("008", Math.max(0, Math.round(c.amount)));
+	});
+	values.push({
+		lineItemId: at1LineItemId("008", "012"),
+		value: result.partnershipContributionsTo2003
+	});
+	values.push({
+		lineItemId: at1LineItemId("008", "013"),
+		value: result.partnershipContributionsFrom2004
+	});
+	return {
+		scheduleId: "008",
+		values
+	};
+}
+//#endregion
+//#region src/t2/at1/schedules/schedule9-sred-tax-credit.ts
+const nn$27 = (v) => Math.max(0, Math.round(v ?? 0));
+/** Signed whole-dollar rounding, for fields the spec marks "+/-". */
+const signed = (v) => Math.round(v);
+/** 009120's flat rate — "lesser of line 009031 and 009108 X 10%". */
+const ALBERTA_SRED_TAX_CREDIT_RATE = .1;
+/** Alberta's SR&ED program did not exist before this date (line 009104's note). */
+const ALBERTA_SRED_PROGRAM_START = "2009-01-01";
+/** Alberta SR&ED expenditures carried out after this date are not eligible (module docstring). */
+const ALBERTA_SRED_EXPENDITURE_CUTOFF = "2019-12-31";
+/**
+* 009104 / 009206's day-prorated $4,000,000 expenditure limit. Days are clamped
+* to [0, 366] — 366 only for a year genuinely spanning a February 29, per the
+* spec's own note.
+*/
+function computeSchedule9MaximumExpenditureLimit(daysInTaxYear = 365) {
+	return Math.round(4e6 * (Math.max(0, Math.min(daysInTaxYear, 366)) / 365));
+}
+function computeAlbertaSchedule9(input) {
+	const issues = [];
+	const federalQualifiedExpenditures = nn$27(input.federalQualifiedExpenditures);
+	const albertaPortionOfExpenditures = nn$27(input.albertaPortionOfExpenditures);
+	const federalProxyAmountInAlbertaPortion = nn$27(input.federalProxyAmountInAlbertaPortion);
+	const albertaProxyAmount = nn$27(input.albertaProxyAmount);
+	const albertaCreditReducingFederalExpense = nn$27(input.albertaCreditReducingFederalExpense);
+	const priorYearFederalItcReceived = nn$27(input.priorYearFederalItcReceived);
+	const totalAlbertaExpendituresAllYears = nn$27(input.totalAlbertaExpendituresAllYears);
+	const totalFederalExpendituresAllYears = nn$27(input.totalFederalExpendituresAllYears);
+	const albertaPortionOfRepayments = nn$27(input.albertaPortionOfRepayments);
+	const disposalRecapture = nn$27(input.disposalRecapture);
+	const priorYearFederalItcAdjustment = nn$27(input.priorYearFederalItcAdjustment);
+	if (albertaPortionOfExpenditures > federalQualifiedExpenditures) issues.push(`Alberta Schedule 9: the Alberta portion of expenditures (009005 = ${albertaPortionOfExpenditures}) exceeds the federal total (009003 = ${federalQualifiedExpenditures}). 009005 must not exceed 009003.`);
+	const priorYearItcAlbertaPortion = totalFederalExpendituresAllYears > 0 ? Math.round(priorYearFederalItcReceived * totalAlbertaExpendituresAllYears / totalFederalExpendituresAllYears) : 0;
+	if (totalFederalExpendituresAllYears === 0 && priorYearFederalItcReceived > 0) issues.push("Alberta Schedule 9: a prior-year federal ITC (009015) was supplied but total federal expenditures for those years (009019) is nil, so no Alberta portion (009023) could be allocated. Supply 009019 if a prior-year ITC allocation is expected.");
+	const derivedEligibleExpenditures = albertaPortionOfExpenditures - federalProxyAmountInAlbertaPortion + albertaProxyAmount + albertaCreditReducingFederalExpense - priorYearItcAlbertaPortion + albertaPortionOfRepayments;
+	const eligibleExpenditures = input.eligibleExpenditures !== void 0 ? signed(input.eligibleExpenditures) : derivedEligibleExpenditures;
+	if (input.eligibleExpenditures === void 0) issues.push(`Alberta Schedule 9: line 009031 ("Total eligible expenditures for Alberta purposes") has no formula in the TRA spec's mapping tables (the text jumps from 009025 to 009040). Derived here as 005 − 007 + 009 + 011 − 023 + 025 = ${derivedEligibleExpenditures}, from the lines the spec captions unambiguously "Deduct"/"Add". Supply eligibleExpenditures directly to override with the authoritative figure — see the Guide to Claiming the Alberta SR&ED Tax Credit.`);
+	if (input.fieldOfScience === void 0) issues.push("Alberta Schedule 9: line 009040 (primary field of science or technology) is mandatory on the live form and was not supplied.");
+	const isAssociated = input.isAssociated ?? false;
+	const nonAssociatedMaximumExpenditureLimit = computeSchedule9MaximumExpenditureLimit(input.daysInTaxYear ?? 365);
+	let maximumExpenditureLimit;
+	if (isAssociated) if (input.allocatedExpenditureLimit === void 0) {
+		issues.push("Alberta Schedule 9: the corporation is associated (009100 = 1) but no allocated expenditure limit (009102) was supplied. Complete the Allocation of the Maximum Expenditure Limit (page 3) and pass its result as allocatedExpenditureLimit — see allocateSchedule9ExpenditureLimit.");
+		maximumExpenditureLimit = 0;
+	} else maximumExpenditureLimit = nn$27(input.allocatedExpenditureLimit);
+	else maximumExpenditureLimit = nonAssociatedMaximumExpenditureLimit;
+	if (input.taxationYearEnd !== void 0 && input.taxationYearEnd > "2019-12-31") issues.push(`Alberta Schedule 9: the taxation year end (${input.taxationYearEnd}) falls after ${ALBERTA_SRED_EXPENDITURE_CUTOFF}. The Alberta SR&ED Tax Credit may not be claimed for expenditures carried out in Alberta after that date — confirm albertaPortionOfExpenditures (009005) excludes any post-cutoff spending.`);
+	const netCredit = Math.round(Math.min(eligibleExpenditures, maximumExpenditureLimit) * ALBERTA_SRED_TAX_CREDIT_RATE) - disposalRecapture - priorYearFederalItcAdjustment;
+	return {
+		federalQualifiedExpenditures,
+		albertaPortionOfExpenditures,
+		federalProxyAmountInAlbertaPortion,
+		albertaProxyAmount,
+		albertaCreditReducingFederalExpense,
+		priorYearFederalItcReceived,
+		totalAlbertaExpendituresAllYears,
+		totalFederalExpendituresAllYears,
+		priorYearItcAlbertaPortion,
+		albertaPortionOfRepayments,
+		eligibleExpenditures,
+		derivedEligibleExpenditures,
+		fieldOfScience: input.fieldOfScience,
+		isAssociated,
+		nonAssociatedMaximumExpenditureLimit,
+		maximumExpenditureLimit,
+		disposalRecapture,
+		priorYearFederalItcAdjustment,
+		netCredit,
+		issues
+	};
+}
+/**
+* Allocate the day-prorated $4,000,000 maximum expenditure limit among an
+* associated group (page 3). Per the spec, EACH occurrence of 009240 and the
+* SUM of all occurrences are independently capped at the limit — unlike a
+* running-remainder split, one member requesting more than the limit does not
+* consume another member's room; it is simply capped and flagged.
+*/
+function allocateSchedule9ExpenditureLimit(daysInLongestYear, requested) {
+	const issues = [];
+	const days = Math.max(0, Math.min(daysInLongestYear, 366));
+	const maximumExpenditureLimit = computeSchedule9MaximumExpenditureLimit(days);
+	const members = requested.map((m) => {
+		const requestedAmount = nn$27(m.allocated);
+		if (requestedAmount > maximumExpenditureLimit) issues.push(`Alberta Schedule 9: ${m.name} was allocated ${requestedAmount}, exceeding the maximum expenditure limit of ${maximumExpenditureLimit} (009240 cannot exceed $4,000,000 x 009206/365). Capped at ${maximumExpenditureLimit}.`);
+		return {
+			name: m.name,
+			...m.albertaCan !== void 0 ? { albertaCan: m.albertaCan } : {},
+			allocated: Math.min(requestedAmount, maximumExpenditureLimit)
+		};
+	});
+	const totalAllocated = members.reduce((s, m) => s + m.allocated, 0);
+	if (totalAllocated > maximumExpenditureLimit) issues.push(`Alberta Schedule 9: the associated group allocated a total of ${totalAllocated}, exceeding the maximum expenditure limit of ${maximumExpenditureLimit} (the sum of all 009240 occurrences cannot exceed $4,000,000 x 009206/365). The group must agree a valid split.`);
+	return {
+		daysInLongestYear: days,
+		maximumExpenditureLimit,
+		members,
+		totalAllocated,
+		claimantAllocatedAmount: members[0]?.allocated ?? 0,
+		unallocated: Math.max(0, maximumExpenditureLimit - totalAllocated),
+		issues
+	};
+}
+function schedule9LineItemId(fieldId, occurrence = 1) {
+	return `009${fieldId}${String(occurrence).padStart(3, "0")}`;
+}
+/**
+* Field ids per the spec transcription in the module docstring: 003-025 (the
+* expenditure buildup), 040 (field of science), 100-120 (the credit
+* calculation), and — when `group` is supplied — 200-240 (page 3's
+* allocation). Line 031 has no confirmed transmitted status of its own (see
+* the module docstring's "line 009031 has no formula in the spec text"), but
+* is filed anyway alongside 106 since both carry the identical "Total
+* eligible expenditures for Alberta purposes" figure per the spec's own
+* cross-reference ("106 ... Value must equal 009031").
+*/
+function schedule9Values(result, group) {
+	const values = [];
+	const put = (fieldId, value) => values.push({
+		lineItemId: schedule9LineItemId(fieldId),
+		value
+	});
+	put("003", result.federalQualifiedExpenditures);
+	put("005", result.albertaPortionOfExpenditures);
+	put("007", result.federalProxyAmountInAlbertaPortion);
+	put("009", result.albertaProxyAmount);
+	put("011", result.albertaCreditReducingFederalExpense);
+	put("015", result.priorYearFederalItcReceived);
+	put("017", result.totalAlbertaExpendituresAllYears);
+	put("019", result.totalFederalExpendituresAllYears);
+	put("023", result.priorYearItcAlbertaPortion);
+	put("025", result.albertaPortionOfRepayments);
+	put("031", result.eligibleExpenditures);
+	if (result.fieldOfScience !== void 0) put("040", result.fieldOfScience);
+	put("100", result.isAssociated ? 1 : 2);
+	if (result.isAssociated) put("102", result.maximumExpenditureLimit);
+	else put("104", result.nonAssociatedMaximumExpenditureLimit);
+	put("106", result.eligibleExpenditures);
+	put("108", result.maximumExpenditureLimit);
+	put("112", result.disposalRecapture);
+	put("116", result.priorYearFederalItcAdjustment);
+	put("120", result.netCredit);
+	if (group) {
+		if (group.longestYearCan !== void 0) values.push({
+			lineItemId: schedule9LineItemId("200"),
+			value: group.longestYearCan
+		});
+		if (group.longestYearBegin !== void 0) values.push({
+			lineItemId: schedule9LineItemId("202"),
+			value: group.longestYearBegin
+		});
+		if (group.longestYearEnd !== void 0) values.push({
+			lineItemId: schedule9LineItemId("204"),
+			value: group.longestYearEnd
+		});
+		values.push({
+			lineItemId: schedule9LineItemId("206"),
+			value: group.allocation.daysInLongestYear
+		});
+		group.allocation.members.forEach((m, i) => {
+			const occurrence = i + 1;
+			values.push({
+				lineItemId: schedule9LineItemId("220", occurrence),
+				value: m.name
+			});
+			if (m.albertaCan !== void 0) values.push({
+				lineItemId: schedule9LineItemId("230", occurrence),
+				value: m.albertaCan
+			});
+			values.push({
+				lineItemId: schedule9LineItemId("240", occurrence),
+				value: m.allocated
+			});
+		});
+	}
+	return {
+		scheduleId: "009",
+		values
+	};
+}
+//#endregion
+//#region src/t2/at1/schedules/schedule11-manufacturing-processing.ts
+const nn$26 = (v) => Math.max(0, Math.round(v ?? 0));
+function computeSchedule11(input) {
+	const issues = [];
+	const dateEligible = input.taxYearStart < "2001-04-01";
+	if (!dateEligible) issues.push(`Schedule 11: the Alberta Manufacturing and Processing Profits Deduction applies only where the tax year begins before 2001-04-01 (TRA-spec lines 9135-9146). This tax year begins ${input.taxYearStart}, so no deduction applies; line 011042 is reported as nil regardless of the workings below.`);
+	let grossRevenueRatio;
+	let revenueEligible = true;
+	if (dateEligible) if (input.manufacturingGrossRevenue == null || input.totalGrossRevenue == null) {
+		revenueEligible = false;
+		issues.push("Schedule 11: the 10% manufacturing gross-revenue test (TRA-spec lines 9138-9142) could not be run because gross revenue figures were not supplied, so form 011 is treated as not applicable.");
+	} else {
+		const total = nn$26(input.totalGrossRevenue);
+		grossRevenueRatio = total > 0 ? nn$26(input.manufacturingGrossRevenue) / total : 0;
+		if (grossRevenueRatio < .1) {
+			revenueEligible = false;
+			issues.push(`Schedule 11: manufacturing gross revenue is ${(grossRevenueRatio * 100).toFixed(1)}% of total gross revenue, below the 10% threshold in the AT1 spec, so form 011 is not applicable.`);
+		}
+	}
+	const eligible = dateEligible && revenueEligible;
+	let albertaAdjubi;
+	if (input.albertaAdjubiFromSchedule12) albertaAdjubi = Math.max(0, Math.round(input.albertaAdjubiFromSchedule12.line112 + input.albertaAdjubiFromSchedule12.line114));
+	else {
+		albertaAdjubi = nn$26(input.federalAdjubi);
+		if (input.federalAdjubi == null && eligible) issues.push("Schedule 11: neither `federalAdjubi` (fed 027130) nor `albertaAdjubiFromSchedule12` was supplied; line 011001 defaults to nil.");
+	}
+	let aggregateInvestmentIncome;
+	if (input.isCcpc) if (input.schedule12Exists) aggregateInvestmentIncome = nn$26(input.albertaAggregateInvestmentIncome);
+	else {
+		aggregateInvestmentIncome = nn$26(input.federalAggregateInvestmentIncome);
+		if (input.federalAggregateInvestmentIncome == null) issues.push("Schedule 11: the corp is a CCPC and no Alberta Schedule 12 exists, so line 011013 must equal fed 200440, but `federalAggregateInvestmentIncome` was not supplied; line 011013 defaults to nil.");
+	}
+	const isSmallManufacturingCorp = input.isSmallManufacturingCorp ?? false;
+	let costOfCapital = 0;
+	let albertaCostOfCapital = 0;
+	let costOfLabour = 0;
+	let albertaCostOfLabour = 0;
+	let albertaManufacturingProcessingProfits = 0;
+	if (isSmallManufacturingCorp) {
+		if (input.costOfCapital != null || input.albertaCostOfCapital != null || input.costOfLabour != null || input.albertaCostOfLabour != null) issues.push("Schedule 11: lines 011031-011039 must not exist for a small manufacturing corp, but capital/labour figures were supplied; they are ignored for line 011042.");
+		if (input.smallManufacturerAmpp != null) albertaManufacturingProcessingProfits = nn$26(input.smallManufacturerAmpp);
+		else if (eligible) issues.push("Schedule 11: the small-manufacturing-corp formula for line 011042 is not stated in the transcribed spec range (TRA-spec lines 9082-9397); supply `smallManufacturerAmpp` directly per the AT1 Guide criteria. Line 011042 defaults to nil.");
+	} else {
+		costOfCapital = nn$26(input.costOfCapital);
+		albertaCostOfCapital = nn$26(input.albertaCostOfCapital);
+		costOfLabour = nn$26(input.costOfLabour);
+		albertaCostOfLabour = nn$26(input.albertaCostOfLabour);
+		if (albertaCostOfCapital > costOfCapital) {
+			issues.push(`Schedule 11: line 011033 (Alberta Cost of Manufacturing and Processing Capital, ${albertaCostOfCapital}) exceeds line 011031 (Cost of Capital, ${costOfCapital}); the AT1 spec requires 011033 ≤ 011031. Clamped to ${costOfCapital}.`);
+			albertaCostOfCapital = costOfCapital;
+		}
+		if (albertaCostOfLabour > costOfLabour) {
+			issues.push(`Schedule 11: line 011039 (Alberta Cost of Manufacturing and Processing Labour, ${albertaCostOfLabour}) exceeds line 011037 (Cost of Labour, ${costOfLabour}); the AT1 spec requires 011039 ≤ 011037. Clamped to ${costOfLabour}.`);
+			albertaCostOfLabour = costOfLabour;
+		}
+		const denominator = costOfCapital + costOfLabour;
+		if (denominator === 0) {
+			if (albertaAdjubi > 0 && eligible) issues.push("Schedule 11: Cost of Capital (011031) and Cost of Labour (011037) are both nil, so the line 011042 proration cannot be computed; supply them. Line 011042 defaults to nil.");
+		} else {
+			const factor = (Math.min(albertaCostOfCapital * 100 / 85, costOfCapital) + Math.min(albertaCostOfLabour * 100 / 75, costOfLabour)) / denominator;
+			albertaManufacturingProcessingProfits = Math.round(albertaAdjubi * factor);
+		}
+	}
+	if (!eligible && albertaManufacturingProcessingProfits > 0) issues.push(`Schedule 11: the workings above yield ${albertaManufacturingProcessingProfits}, but the deduction is not applicable this year (see the eligibility issue above); line 011042 is reported as nil.`);
+	if (!eligible) albertaManufacturingProcessingProfits = 0;
+	return {
+		eligible,
+		isSmallManufacturingCorp,
+		albertaAdjubi,
+		...aggregateInvestmentIncome !== void 0 ? { aggregateInvestmentIncome } : {},
+		costOfCapital,
+		albertaCostOfCapital,
+		costOfLabour,
+		albertaCostOfLabour,
+		albertaManufacturingProcessingProfits,
+		...grossRevenueRatio !== void 0 ? { grossRevenueRatio } : {},
+		issues
+	};
+}
+function schedule11LineItemId(fieldId, occurrence = 1) {
+	return `011${fieldId}${String(occurrence).padStart(3, "0")}`;
+}
+/**
+* Field ids per the spec transcription above: 001 (AMPPD/ADJUBI), 013 (CCPC
+* aggregate investment income), 031/033/037/039 (cost of capital/labour, both
+* jurisdictions) and 042 (Alberta M&P Profits).
+*
+* Line 042 is ALWAYS emitted, including when the historical-eligibility gate
+* (pre-2001-04-01 tax year AND the 10% gross-revenue test) has forced it to
+* nil — an ineligible year still has a line 011042 on the form, and it reads
+* nil, so this files nil rather than omitting the line entirely. The REASON
+* it is nil (a `Schedule 11: … applies only where the tax year begins before
+* 2001-04-01 …` / `… below the 10% threshold …` entry) lives on
+* `result.issues`, which this builder does not carry onto the wire itself —
+* the caller already has `result` (this function's own input) and so already
+* has `result.issues` sitting beside whatever this returns; duplicating it
+* onto `At1ScheduleDataLike`, which has no field for prose, would only be
+* losing information conversion by not adding any.
+*
+* Line 013 (CCPC aggregate investment income) is the one line legitimately
+* OMITTED rather than filed as nil: it is undefined, not zero, for a non-CCPC
+* corporation — the spec's own business rule gates it on `000029 = 1 or 2`,
+* so a non-CCPC has no box to fill here at all, unlike line 042's "nil is a
+* real answer" case above.
+*/
+function schedule11Values(result) {
+	const values = [];
+	const put = (fieldId, value) => values.push({
+		lineItemId: schedule11LineItemId(fieldId),
+		value
+	});
+	put("001", result.albertaAdjubi);
+	if (result.aggregateInvestmentIncome !== void 0) put("013", result.aggregateInvestmentIncome);
+	put("031", result.costOfCapital);
+	put("033", result.albertaCostOfCapital);
+	put("037", result.costOfLabour);
+	put("039", result.albertaCostOfLabour);
+	put("042", result.albertaManufacturingProcessingProfits);
+	return {
+		scheduleId: "011",
+		values
+	};
+}
+//#endregion
+//#region src/t2/at1/schedules/schedule15-resource-related-deductions.ts
+/**
+* Alberta AT1 Schedule 15 — Alberta Resource Related Deductions.
+*
+* Source: `research/sources/tra-spec/AT1-Chapter3-2025.2-full.txt`, lines
+* 12394-15937 (§3.2.3.16 "Schedule 15 - Alberta Resource Related Deductions").
+* There is NO standalone AT1SCH15 PDF under `research/sources/tra-forms/pdf/`
+* (unlike schedules 1, 2, 10, 12, 13, 16, 17, 18, 20, 21, 29, which all have
+* one) — the NetFile mapping spec above is the ONLY source available for this
+* schedule, so every field below is cited to that text file alone and cannot
+* be cross-checked against a rendered form layout.
+*
+* Like AT1 Schedule 18 (dispositions) and Schedule 13 (CCA), this is a
+* RECONCILIATION overlay, not a second engine: for most lines, the Alberta
+* figure defaults to the corresponding FEDERAL pool figure, and only the
+* lines where Alberta actually diverges are entered. The form is forbidden
+* when the return declares no Alberta/federal divergence (000060 AND 000061
+* both 2) and required when the opening balance or the claim for Alberta
+* purposes differs from federal (line 015 gating text, source lines
+* 12444-12456).
+*
+* Despite the task brief's expectation of a "resource allowance" pool, THERE
+* IS NO resource-allowance computation on this schedule — the federal
+* resource allowance deduction was repealed for taxation years after 1989
+* (phased out through the mid-1990s) and this schedule is entirely about the
+* EIGHT resource-expense CONTINUITY pools that survive it:
+*
+*   EDA    — Continuity of Earned Depletion Base (grandfathered; regular +
+*            successor expenses), lines 001-021.
+*   CMEDB  — Continuity of Mining Exploration Depletion Base, lines 023-033.
+*   CEE    — Cumulative Canadian Exploration Expenses (regular + successor),
+*            lines 041-083.
+*   CDE    — Cumulative Canadian Development Expenses (regular + successor),
+*            lines 091-143.
+*   CCOGPE — Cumulative Canadian Oil and Gas Property Expenses (regular +
+*            successor), lines 151-191.
+*   FEDE   — Foreign Exploration and Development Expenses (regular +
+*            successor), lines 201-233.
+*   SFEDE  — Specified Foreign Exploration and Development Expenses, PER
+*            COUNTRY (regular + successor), lines 241-277.
+*   CFRE   — Cumulative Foreign Resource Expenses, PER COUNTRY (regular +
+*            successor), lines 281-317.
+*
+* Each pool is modelled as its own `Input`/`Result` pair and its own pure
+* `computeXxx` function, per this directory's convention (see
+* `schedule18-dispositions.ts`, `schedule21-year-of-origin.ts`). A single
+* `computeAlbertaSchedule15` at the bottom composes all eight (accepting the
+* already-computed CCOGPE results where CDE needs them — see "CCOGPE ↔ CDE
+* cross-linkage" below) and applies the schedule-level 000060/000061 gate.
+*
+* ── Two proration conventions, NOT interchangeable ──────────────────────────
+*
+* The current-year-claim caps use TWO different short-tax-year formulas, and
+* the spec is explicit that they differ:
+*
+*   - CDE (lines 115, 141) and CCOGPE (lines 169, 189) use a STEP function:
+*     "if days in tax year ≥ 357, cap = rate × pool; if < 357, cap = rate ×
+*     (days/365) × pool" — i.e. the proration is skipped entirely for a
+*     near-full year.
+*   - FEDE (line 209), SFEDE (line 253) and CFRE (lines 293, 313) use a
+*     PLAIN `days/365` multiplier with no 357-day step.
+*
+* `stepYearFactor` implements the first; `linearYearFactor` the second. CEE
+* (lines 061, 081) and EDA/CMEDB have no day-proration at all — CEE is fully
+* claimable up to the pool balance in one year, no percentage rate applies.
+*
+* ── CCOGPE ↔ CDE cross-linkage (FLAGGED, not fully auto-wired) ──────────────
+*
+* When a CCOGPE pool's pre-claim subtotal is NEGATIVE, three things in the
+* spec text interact in a way this module resolves only PARTIALLY:
+*
+*   1. CDE line 105 ("Deduct: credit balance in the cumulative Canadian oil
+*      and gas property expense pool", source lines 13604-13622) has its OWN
+*      self-contained formula: `A = 015151+015153+015155+015157-015159-
+*      015161-015165-015167; if A < 0, value = A; otherwise enter fed
+*      012330`. This is unconditional — it does not mention the designation
+*      election. This module implements 105 EXACTLY this way, computed from
+*      the already-computed CCOGPE-regular pool subtotal (see
+*      `computeCdeRegular`'s `ccogpeRegular` parameter).
+*   2. CCOGPE line 169 ("Deduct: current year claim...", source lines
+*      14281-14370) separately says that when that SAME subtotal A is
+*      negative, it "must be carried forward to 015105" ONLY if the
+*      corporation "has made a designation pursuant to subparagraph
+*      66.7(4)(a)(iii)" — and to 015133 (CDE SUCCESSOR, not 105) if it has
+*      NOT. This CONTRADICTS (1)'s unconditional reading. Line 189 (source
+*      lines 14646-14661) makes the analogous claim for the CCOGPE-successor
+*      pool: negative → 015133 if designated, or "included in 015167"
+*      (CCOGPE's OWN regular-pool deduction line, not a CDE line) if not.
+*
+* This module resolves (1) literally (105 is auto-computed, unconditionally,
+* from the CCOGPE-regular subtotal) because that is the more specific,
+* self-contained rule attached directly to line 105 itself. It does NOT
+* auto-route a negative CCOGPE-successor subtotal into CDE line 133 or back
+* into CCOGPE-regular line 167, because (a) line 133 has no unconditional
+* formula of its own — only the ambiguous "value may not exceed amount A"
+* (source lines 13945-13962), and (b) whether it should land on 133 or 167
+* hinges on the 66.7(4)(a)(iii) designation, which this schedule has no
+* source for and no sibling schedule to pull it from. Whenever the CCOGPE-
+* successor subtotal goes negative, `computeCcogpeSuccessor` raises an issue
+* naming lines 133/167/189 so a preparer resolves the routing by hand; the
+* pool's own claim and closing balance are zeroed per the schedule's
+* unconditional instruction ("enter zero at 015189 and 015191").
+*
+* A second, independent anomaly: CCOGPE-successor's own closing balance
+* formula (line 191, source lines 14731-14740) reads literally as "value =
+* 015173+015175+015177-015181-015185-015187-015189 **-015167-015169**" when
+* the pre-subtraction total is positive — i.e. it appears to subtract the
+* CCOGPE-REGULAR pool's OWN deduction (167) and claim (169) from the
+* SUCCESSOR pool's closing balance. No other continuity balance on this
+* schedule mixes fields across the regular/successor split this way, and
+* nothing else in the 000-series explains why a successor balance would
+* absorb the regular pool's claim. This module computes 191 with the clean,
+* schedule-consistent formula (additions − deductions − claim, floored at
+* zero) and raises an issue quoting the literal spec text whenever 167 or
+* 169 is non-zero (the only case where the two readings diverge), so a
+* reviewer can check it against the real form — which, again, has no PDF in
+* this engine's sources to check against.
+*
+* ── Other flagged items ─────────────────────────────────────────────────────
+*
+*   - CDE line 107 ("Deduct: other deductions or transfers", source lines
+*     13681-13691) carries a parenthetical "(Note: If 015139 is negative,
+*     include the amount at 015107 as a positive value.)" — there is NO line
+*     139 anywhere else in this schedule's field list (CDE regular runs
+*     091-117 with no 108/109/113/114/116/139 gaps that resolve to it, and
+*     no other pool numbers into the 130s except CDE-successor's own 133-137,
+*     which are a different pool entirely). This looks like either an OCR
+*     artifact or a reference to a paper-form-only field outside the NetFile
+*     schema (the same category as Schedule 21's RIFE section). Not modelled;
+*     flagged verbatim whenever the schedule is computed.
+*   - Negative-pool amounts on FEDE, SFEDE and CFRE (claim lines 209, 221,
+*     253, 273, 293, 313) are, per the spec, "include[d] in 012040" — a
+*     FEDERAL T2 line, entirely outside this schedule and this engine's
+*     stated scope for Schedule 15. This module zeroes the claim/closing per
+*     the schedule's own instruction and raises an issue noting the federal
+*     inclusion is the caller's responsibility elsewhere.
+*   - CFRE line 293's "B" component is capped at "the global foreign
+*     resource limit for the year designated for that country" (source lines
+*     15703-15711) — a quantity with no definition or source anywhere in
+*     this spec excerpt. Modelled as an optional plain-number INPUT per
+*     country (`globalForeignResourceLimit`); omitting it makes B = 0 (the
+*     conservative, under-claim direction) and raises an issue rather than
+*     inventing a limit.
+*
+* Whole dollars, pure functions, no I/O.
+*/
+const nn$25 = (v) => Math.max(0, v ?? 0);
+const num$1 = (v) => v ?? 0;
+const round = (v) => Math.round(v);
+/** `override ?? federal`, tracking whether an Alberta-specific figure was actually entered. */
+function reconcile(federal, override) {
+	return override !== void 0 ? {
+		value: override,
+		differs: true
+	} : {
+		value: num$1(federal),
+		differs: false
+	};
+}
+/**
+* CDE / CCOGPE style short-tax-year proration: the full rate applies with NO
+* proration once the tax year reaches 357 days; below that, rate × days/365.
+*/
+function stepYearFactor(daysInTaxYear) {
+	const days = daysInTaxYear ?? 365;
+	return days >= 357 ? 1 : Math.max(0, days) / 365;
+}
+/** FEDE / SFEDE / CFRE style proration: plain days/365, no 357-day step. */
+function linearYearFactor(daysInTaxYear) {
+	return Math.max(0, daysInTaxYear ?? 365) / 365;
+}
+/** A discretionary claim capped at `cap` (≥ 0), defaulting to the maximum (`cap`) when omitted. */
+function claimUpToCap(requested, cap, issues, label) {
+	const c = Math.max(0, round(cap));
+	if (requested === void 0) return c;
+	if (requested < 0) {
+		issues.push(`${label}: a requested claim of ${requested} is negative; treated as 0.`);
+		return 0;
+	}
+	if (round(requested) > c) {
+		issues.push(`${label}: the requested claim of ${requested} exceeds the maximum allowable ${c} for the year; capped at ${c}.`);
+		return c;
+	}
+	return round(requested);
+}
+/**
+* CEE-style claim: when the pool subtotal is ≤ 0 the claim MUST equal that
+* (negative or zero) subtotal — an income inclusion, not a deduction — and
+* any requested figure is overridden. When positive, it is a discretionary
+* claim up to the subtotal (100% claimable, no percentage rate), defaulting
+* to the maximum.
+*/
+function forcedOrCappedClaim(requested, subtotal, issues, label) {
+	if (subtotal <= 0) {
+		if (requested !== void 0 && round(requested) !== round(subtotal)) issues.push(`${label}: the pool subtotal is ${subtotal} (≤ 0), so the claim must equal the subtotal (an income inclusion) — overriding the requested ${requested}.`);
+		return round(subtotal);
+	}
+	return claimUpToCap(requested, subtotal, issues, label);
+}
+function computeEdaRegular(input) {
+	const issues = [];
+	const f = input.federal;
+	const o = input.albertaOverride ?? {};
+	const opening = reconcile(f.openingBalance, o.openingBalance);
+	const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+	const sale = reconcile(f.saleTransfer, o.saleTransfer);
+	const poolBeforeClaim = opening.value + amalg.value - sale.value;
+	const claim = pool_cappedClaim(reconcile(f.regulation1201Claim, o.regulation1201Claim), poolBeforeClaim, issues, "Schedule 15 EDA regular (015007)");
+	const closingBalance = poolBeforeClaim - claim.value;
+	return {
+		openingBalance: opening.value,
+		amalgamationTransfer: amalg.value,
+		saleTransfer: sale.value,
+		poolBeforeClaim,
+		claim: claim.value,
+		closingBalance,
+		differsFromFederal: opening.differs || amalg.differs || sale.differs || claim.differs,
+		issues
+	};
+}
+/** A reconciled figure that is ALSO capped by a pool — the EDA/CMEDB claim shape (015007, 015019). */
+function pool_cappedClaim(reconciled, pool, issues, label) {
+	const cap = Math.max(0, round(pool));
+	if (pool <= 0) return {
+		value: 0,
+		differs: reconciled.differs
+	};
+	if (round(reconciled.value) > cap) {
+		issues.push(`${label}: the entered claim ${reconciled.value} exceeds the pool ${cap}; capped.`);
+		return {
+			value: cap,
+			differs: reconciled.differs
+		};
+	}
+	return {
+		value: Math.max(0, round(reconciled.value)),
+		differs: reconciled.differs
+	};
+}
+function computeEdaSuccessor(input) {
+	const issues = [];
+	const f = input.federal;
+	const o = input.albertaOverride ?? {};
+	const opening = reconcile(f.openingBalance, o.openingBalance);
+	const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+	const other = reconcile(f.otherTransfer, o.otherTransfer);
+	const sale = reconcile(f.saleTransfer, o.saleTransfer);
+	const poolBeforeClaim = opening.value + amalg.value + other.value - sale.value;
+	const claim = pool_cappedClaim(reconcile(f.regulation1202Claim, o.regulation1202Claim), poolBeforeClaim, issues, "Schedule 15 EDA successor (015019)");
+	const closingBalance = poolBeforeClaim - claim.value;
+	return {
+		openingBalance: opening.value,
+		amalgamationTransfer: amalg.value,
+		otherTransfer: other.value,
+		saleTransfer: sale.value,
+		poolBeforeClaim,
+		claim: claim.value,
+		closingBalance,
+		differsFromFederal: opening.differs || amalg.differs || other.differs || sale.differs || claim.differs,
+		issues
+	};
+}
+function computeCmedb(input) {
+	const issues = [];
+	const f = input.federal;
+	const o = input.albertaOverride ?? {};
+	const opening = reconcile(f.openingBalance, o.openingBalance);
+	const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+	const other = reconcile(f.otherTransfer, o.otherTransfer);
+	const disposal = reconcile(f.disposalTransfer, o.disposalTransfer);
+	const poolBeforeClaim = opening.value + amalg.value + other.value - disposal.value;
+	const claim = poolBeforeClaim <= 0 ? 0 : claimUpToCap(input.claimed, poolBeforeClaim, issues, "Schedule 15 CMEDB (015031)");
+	const closingBalance = poolBeforeClaim - claim;
+	return {
+		openingBalance: opening.value,
+		amalgamationTransfer: amalg.value,
+		otherTransfer: other.value,
+		disposalTransfer: disposal.value,
+		poolBeforeClaim,
+		claim,
+		closingBalance,
+		differsFromFederal: opening.differs || amalg.differs || other.differs || disposal.differs,
+		issues
+	};
+}
+function computeCeeRegular(input) {
+	const issues = [];
+	const f = input.federal;
+	const o = input.albertaOverride ?? {};
+	const opening = reconcile(f.openingBalance, o.openingBalance);
+	const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+	const otherAdd = reconcile(f.otherAdditions, o.otherAdditions);
+	const otherDed = reconcile(f.otherDeductions, o.otherDeductions);
+	const toSuccessor = reconcile(f.transferredToSuccessor, o.transferredToSuccessor);
+	const currentYearExpenses = num$1(f.currentYearExpenses);
+	const lookBackExpenses = num$1(f.lookBackExpenses);
+	const reclassifiedFromCde = num$1(f.reclassifiedFromCde);
+	const renewableConservationExpenses = num$1(f.renewableConservationExpenses);
+	const governmentAssistance = num$1(f.governmentAssistance);
+	const renouncedFlowThrough = num$1(f.renouncedFlowThrough);
+	const renouncedLookBack = num$1(f.renouncedLookBack);
+	const subtotal = opening.value + currentYearExpenses + lookBackExpenses + reclassifiedFromCde + amalg.value + renewableConservationExpenses + otherAdd.value - governmentAssistance - otherDed.value - renouncedFlowThrough - toSuccessor.value - renouncedLookBack;
+	const claim = forcedOrCappedClaim(input.claimed, subtotal, issues, "Schedule 15 CEE regular (015061)");
+	const closingBalance = subtotal > 0 ? subtotal - claim : 0;
+	return {
+		openingBalance: opening.value,
+		currentYearExpenses,
+		lookBackExpenses,
+		reclassifiedFromCde,
+		amalgamationTransfer: amalg.value,
+		renewableConservationExpenses,
+		otherAdditions: otherAdd.value,
+		governmentAssistance,
+		otherDeductions: otherDed.value,
+		renouncedFlowThrough,
+		transferredToSuccessor: toSuccessor.value,
+		renouncedLookBack,
+		subtotal,
+		claim,
+		closingBalance,
+		differsFromFederal: opening.differs || amalg.differs || otherAdd.differs || otherDed.differs || toSuccessor.differs,
+		issues
+	};
+}
+function computeCeeSuccessor(input) {
+	const issues = [];
+	const f = input.federal;
+	const o = input.albertaOverride ?? {};
+	const opening = reconcile(f.openingBalance, o.openingBalance);
+	const reclassified = num$1(f.reclassifiedFromCde);
+	const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+	const other = reconcile(f.otherTransfer, o.otherTransfer);
+	const otherDed = reconcile(f.otherDeductions, o.otherDeductions);
+	const toSuccessor = reconcile(f.transferredToSuccessor, o.transferredToSuccessor);
+	const subtotal = opening.value + reclassified + amalg.value + other.value - otherDed.value - toSuccessor.value;
+	const claim = forcedOrCappedClaim(input.claimed, subtotal, issues, "Schedule 15 CEE successor (015081)");
+	const closingBalance = subtotal - claim;
+	return {
+		openingBalance: opening.value,
+		reclassifiedFromCde: reclassified,
+		amalgamationTransfer: amalg.value,
+		otherTransfer: other.value,
+		otherDeductions: otherDed.value,
+		transferredToSuccessor: toSuccessor.value,
+		subtotal,
+		claim,
+		closingBalance,
+		differsFromFederal: opening.differs || amalg.differs || other.differs || otherDed.differs || toSuccessor.differs,
+		issues
+	};
+}
+/** CDE / CCOGPE claim rate — 30% for CDE (ITA s.66.2(2)), applied via `stepYearFactor`. */
+const CDE_CLAIM_RATE = .3;
+/** CCOGPE claim rate — 10% (ITA s.66.4(2)/66.7(5)), applied via `stepYearFactor`. */
+const CCOGPE_CLAIM_RATE = .1;
+function computeCdeRegular(input, ccogpeRegular) {
+	const issues = [];
+	const f = input.federal;
+	const o = input.albertaOverride ?? {};
+	const opening = reconcile(f.openingBalance, o.openingBalance);
+	const currentYearExpenses = num$1(f.currentYearExpenses);
+	const lookBackExpenses = num$1(f.lookBackExpenses);
+	const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+	const otherAdd = reconcile(f.otherAdditions, o.otherAdditions);
+	const reclassified = num$1(f.reclassifiedFromCee);
+	const governmentAssistance = num$1(f.governmentAssistance);
+	const receivable = reconcile(f.receivableOnDisposition, o.receivableOnDisposition);
+	const creditBalanceReconciled = reconcile(f.creditBalanceInCogpePool, o.creditBalanceInCogpePool);
+	const creditBalance = ccogpeRegular.subtotal < 0 ? {
+		value: round(ccogpeRegular.subtotal),
+		differs: true
+	} : creditBalanceReconciled;
+	const otherDed = reconcile(f.otherDeductions, o.otherDeductions);
+	const renouncedFlowThrough = num$1(f.renouncedFlowThrough);
+	const toSuccessor = reconcile(f.transferredToSuccessor, o.transferredToSuccessor);
+	const renouncedLookBack = num$1(f.renouncedLookBack);
+	const subtotal = opening.value + currentYearExpenses + lookBackExpenses + amalg.value + otherAdd.value - reclassified - governmentAssistance - receivable.value - creditBalance.value - otherDed.value - toSuccessor.value - renouncedFlowThrough - renouncedLookBack;
+	if (f.otherDeductions !== void 0 || o.otherDeductions !== void 0) issues.push("Schedule 15 CDE regular (015107): the spec's own business rule for this line adds \"If 015139 is negative, include the amount at 015107 as a positive value\" — line 015139 does not exist anywhere else in Schedule 15 as extracted from the source text (source lines 13681-13691). Not modelled; verify against the live TRA form, which has no PDF in this engine's sources for Schedule 15.");
+	const claim = subtotal > 0 ? claimUpToCap(input.claimed, CDE_CLAIM_RATE * stepYearFactor(input.daysInTaxYear) * subtotal, issues, "Schedule 15 CDE regular (015115)") : 0;
+	const closingBalance = Math.max(0, subtotal - claim);
+	return {
+		openingBalance: opening.value,
+		currentYearExpenses,
+		lookBackExpenses,
+		amalgamationTransfer: amalg.value,
+		otherAdditions: otherAdd.value,
+		reclassifiedFromCee: reclassified,
+		governmentAssistance,
+		receivableOnDisposition: receivable.value,
+		creditBalanceInCogpePool: creditBalance.value,
+		otherDeductions: otherDed.value,
+		renouncedFlowThrough,
+		transferredToSuccessor: toSuccessor.value,
+		renouncedLookBack,
+		subtotal,
+		claim,
+		closingBalance,
+		differsFromFederal: opening.differs || amalg.differs || otherAdd.differs || receivable.differs || creditBalance.differs || otherDed.differs || toSuccessor.differs,
+		issues
+	};
+}
+function computeCdeSuccessor(input, ccogpeSuccessor) {
+	const issues = [];
+	const f = input.federal;
+	const o = input.albertaOverride ?? {};
+	const opening = reconcile(f.openingBalance, o.openingBalance);
+	const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+	const other = reconcile(f.otherTransfer, o.otherTransfer);
+	const reclassified = num$1(f.reclassifiedFromCee);
+	const creditBalanceReconciled = reconcile(f.creditBalanceInCogpePool, o.creditBalanceInCogpePool);
+	const creditBalance = ccogpeSuccessor.subtotal < 0 ? {
+		value: round(ccogpeSuccessor.subtotal),
+		differs: true
+	} : creditBalanceReconciled;
+	if (creditBalance.value !== 0) issues.push("Schedule 15 CDE successor (015133): the \"value may not exceed amount A\" wording (source lines 13945-13962) is ambiguous — this module treats it as \"value = A\" (matching line 015105's unconditional wording) whenever the CCOGPE-successor subtotal is negative. Verify against the live TRA form.");
+	const otherDed = reconcile(f.otherDeductions, o.otherDeductions);
+	const toSuccessor = reconcile(f.transferredToSuccessor, o.transferredToSuccessor);
+	const subtotal = opening.value + amalg.value + other.value - reclassified - creditBalance.value - otherDed.value - toSuccessor.value;
+	const claim = subtotal > 0 ? claimUpToCap(input.claimed, CDE_CLAIM_RATE * stepYearFactor(input.daysInTaxYear) * subtotal, issues, "Schedule 15 CDE successor (015141)") : 0;
+	const closingBalance = Math.max(0, subtotal - claim);
+	return {
+		openingBalance: opening.value,
+		amalgamationTransfer: amalg.value,
+		otherTransfer: other.value,
+		reclassifiedFromCee: reclassified,
+		creditBalanceInCogpePool: creditBalance.value,
+		otherDeductions: otherDed.value,
+		transferredToSuccessor: toSuccessor.value,
+		subtotal,
+		claim,
+		closingBalance,
+		differsFromFederal: opening.differs || amalg.differs || other.differs || creditBalance.differs || otherDed.differs || toSuccessor.differs,
+		issues
+	};
+}
+function computeCcogpeRegular(input) {
+	const issues = [];
+	const f = input.federal;
+	const o = input.albertaOverride ?? {};
+	const opening = reconcile(f.openingBalance, o.openingBalance);
+	const currentYearExpenses = num$1(f.currentYearExpenses);
+	const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+	const otherAdd = reconcile(f.otherAdditions, o.otherAdditions);
+	const receivable = reconcile(f.receivableOnDisposition, o.receivableOnDisposition);
+	const governmentAssistance = num$1(f.governmentAssistance);
+	const toSuccessor = reconcile(f.transferredToSuccessor, o.transferredToSuccessor);
+	const otherDed = reconcile(f.otherDeductions, o.otherDeductions);
+	const subtotal = opening.value + currentYearExpenses + amalg.value + otherAdd.value - receivable.value - governmentAssistance - toSuccessor.value - otherDed.value;
+	let claim = 0;
+	if (subtotal < 0) issues.push("Schedule 15 CCOGPE regular (015169): the pool subtotal is negative. Per source lines 14346-14359, this must be carried forward to line 015105 (CDE regular) if the corporation has made a designation under subparagraph 66.7(4)(a)(iii), or to line 015133 (CDE successor) if it has not. computeCdeRegular auto-applies the 015105 route unconditionally (see that function's doc comment) — confirm the designation status before relying on that routing when it should instead land on 015133.");
+	else if (subtotal > 0) claim = claimUpToCap(input.claimed, CCOGPE_CLAIM_RATE * stepYearFactor(input.daysInTaxYear) * subtotal, issues, "Schedule 15 CCOGPE regular (015169)");
+	const closingBalance = subtotal > 0 ? subtotal - claim : 0;
+	return {
+		openingBalance: opening.value,
+		currentYearExpenses,
+		amalgamationTransfer: amalg.value,
+		otherAdditions: otherAdd.value,
+		receivableOnDisposition: receivable.value,
+		governmentAssistance,
+		transferredToSuccessor: toSuccessor.value,
+		otherDeductions: otherDed.value,
+		subtotal,
+		claim,
+		closingBalance,
+		differsFromFederal: opening.differs || amalg.differs || otherAdd.differs || receivable.differs || toSuccessor.differs || otherDed.differs,
+		issues
+	};
+}
+function computeCcogpeSuccessor(input) {
+	const issues = [];
+	const f = input.federal;
+	const o = input.albertaOverride ?? {};
+	const opening = reconcile(f.openingBalance, o.openingBalance);
+	const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+	const other = reconcile(f.otherTransfer, o.otherTransfer);
+	const receivable = reconcile(f.receivableOnDisposition, o.receivableOnDisposition);
+	const toSuccessor = reconcile(f.transferredToSuccessor, o.transferredToSuccessor);
+	const otherDed = reconcile(f.otherDeductions, o.otherDeductions);
+	const subtotal = opening.value + amalg.value + other.value - receivable.value - toSuccessor.value - otherDed.value;
+	let claim = 0;
+	if (subtotal < 0) issues.push("Schedule 15 CCOGPE successor (015189): the pool subtotal is negative. Per source lines 14646-14660, this must be carried forward to line 015133 (CDE successor) if the corporation has made a designation under subparagraph 66.7(4)(a)(iii), or included in line 015167 (this SAME pool's own regular-side deduction line) if it has not. Neither route is auto-applied by this function; supply the appropriate override manually. See module doc comment.");
+	else if (subtotal > 0) claim = claimUpToCap(input.claimed, CCOGPE_CLAIM_RATE * stepYearFactor(input.daysInTaxYear) * subtotal, issues, "Schedule 15 CCOGPE successor (015189)");
+	const closingBalance = Math.max(0, subtotal - claim);
+	return {
+		openingBalance: opening.value,
+		amalgamationTransfer: amalg.value,
+		otherTransfer: other.value,
+		receivableOnDisposition: receivable.value,
+		transferredToSuccessor: toSuccessor.value,
+		otherDeductions: otherDed.value,
+		subtotal,
+		claim,
+		closingBalance,
+		differsFromFederal: opening.differs || amalg.differs || other.differs || receivable.differs || toSuccessor.differs || otherDed.differs,
+		issues
+	};
+}
+function computeFedeRegular(input) {
+	const issues = [];
+	const f = input.federal;
+	const o = input.albertaOverride ?? {};
+	const opening = reconcile(f.openingBalance, o.openingBalance);
+	const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+	const otherDed = reconcile(f.otherDeductions, o.otherDeductions);
+	const foreignResourceIncome = num$1(f.foreignResourceIncome);
+	const pool = opening.value + amalg.value - otherDed.value;
+	let claim = 0;
+	if (pool < 0) issues.push("Schedule 15 FEDE regular (015209): the pool balance is negative. Per source lines 14855-14858 this is included in federal T2 line 012040 — outside AT1 Schedule 15 and this engine's scope. Claim and closing balance are zeroed per the schedule's own instruction.");
+	else if (pool > 0) {
+		const cap = Math.max(CCOGPE_CLAIM_RATE * linearYearFactor(input.daysInTaxYear) * pool, foreignResourceIncome);
+		claim = claimUpToCap(input.claimed, Math.min(pool, cap), issues, "Schedule 15 FEDE regular (015209)");
+	}
+	const closingBalance = pool - claim;
+	return {
+		openingBalance: opening.value,
+		amalgamationTransfer: amalg.value,
+		otherDeductions: otherDed.value,
+		foreignResourceIncome,
+		pool,
+		claim,
+		closingBalance,
+		differsFromFederal: opening.differs || amalg.differs || otherDed.differs,
+		issues
+	};
+}
+function computeFedeSuccessor(input) {
+	const issues = [];
+	const f = input.federal;
+	const o = input.albertaOverride ?? {};
+	const opening = reconcile(f.openingBalance, o.openingBalance);
+	const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+	const other = reconcile(f.otherTransfer, o.otherTransfer);
+	const otherDed = reconcile(f.otherDeductions, o.otherDeductions);
+	const foreignResourceIncome = num$1(f.foreignResourceIncome);
+	const pool = opening.value + amalg.value + other.value - otherDed.value;
+	let claim = 0;
+	if (pool < 0) issues.push("Schedule 15 FEDE successor (015221): the pool balance is negative. Per source lines 14855-14858-style wording (successor variant, source lines ~15045-15048) this is included in federal T2 line 012040 — outside AT1 Schedule 15 and this engine's scope.");
+	else if (pool > 0) claim = claimUpToCap(input.claimed, Math.min(pool, foreignResourceIncome), issues, "Schedule 15 FEDE successor (015221)");
+	const closingBalance = pool - claim;
+	return {
+		openingBalance: opening.value,
+		amalgamationTransfer: amalg.value,
+		otherTransfer: other.value,
+		otherDeductions: otherDed.value,
+		foreignResourceIncome,
+		pool,
+		claim,
+		closingBalance,
+		differsFromFederal: opening.differs || amalg.differs || other.differs || otherDed.differs,
+		issues
+	};
+}
+function computeSfedeCountryRegular(input) {
+	const issues = [];
+	const f = input.federal;
+	const o = input.albertaOverride ?? {};
+	const opening = reconcile(f.openingBalance, o.openingBalance);
+	const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+	const otherAdd = reconcile(f.otherAdditions, o.otherAdditions);
+	const otherDed = reconcile(f.otherDeductions, o.otherDeductions);
+	const foreignResourceIncome = num$1(f.foreignResourceIncome);
+	const pool = opening.value + amalg.value + otherAdd.value - otherDed.value;
+	let claim = 0;
+	if (pool < 0) issues.push(`Schedule 15 SFEDE regular, country ${f.countryCode} (015253): the pool balance is negative. Per the schedule's pattern for foreign pools (source lines 15262-15265), this is included in federal T2 line 012040 — outside this engine's scope.`);
+	else if (pool > 0) {
+		const cap = Math.max(CCOGPE_CLAIM_RATE * linearYearFactor(input.daysInTaxYear) * pool, foreignResourceIncome);
+		claim = claimUpToCap(input.claimed, Math.min(pool, cap), issues, `Schedule 15 SFEDE regular, country ${f.countryCode} (015253)`);
+	}
+	const closingBalance = pool - claim;
+	return {
+		countryCode: f.countryCode,
+		openingBalance: opening.value,
+		amalgamationTransfer: amalg.value,
+		otherAdditions: otherAdd.value,
+		otherDeductions: otherDed.value,
+		foreignResourceIncome,
+		pool,
+		claim,
+		closingBalance,
+		differsFromFederal: opening.differs || amalg.differs || otherAdd.differs || otherDed.differs,
+		issues
+	};
+}
+function computeSfedeCountrySuccessor(input) {
+	const issues = [];
+	const f = input.federal;
+	const o = input.albertaOverride ?? {};
+	const opening = reconcile(f.openingBalance, o.openingBalance);
+	const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+	const other = reconcile(f.otherTransfer, o.otherTransfer);
+	const otherDed = reconcile(f.otherDeductions, o.otherDeductions);
+	const foreignResourceIncome = num$1(f.foreignResourceIncome);
+	const pool = opening.value + amalg.value + other.value - otherDed.value;
+	let claim = 0;
+	if (pool < 0) issues.push(`Schedule 15 SFEDE successor, country ${f.countryCode} (015273): the pool balance is negative. Per the schedule's pattern for foreign pools this is included in federal T2 line 012040 — outside this engine's scope.`);
+	else if (pool > 0) claim = claimUpToCap(input.claimed, Math.min(pool, foreignResourceIncome), issues, `Schedule 15 SFEDE successor, country ${f.countryCode} (015273)`);
+	const closingBalance = pool - claim;
+	return {
+		countryCode: f.countryCode,
+		openingBalance: opening.value,
+		amalgamationTransfer: amalg.value,
+		otherTransfer: other.value,
+		otherDeductions: otherDed.value,
+		foreignResourceIncome,
+		pool,
+		claim,
+		closingBalance,
+		differsFromFederal: opening.differs || amalg.differs || other.differs || otherDed.differs,
+		issues
+	};
+}
+/**
+* CFRE regular claims need a second pass across all countries (line 015293's
+* "A" component caps at "total of all occurrences of 015297"), so this takes
+* the whole array and the pre-summed `sumForeignResourceIncome` across every
+* country's own 015297 rather than being called per-entry like the other
+* per-country pools.
+*/
+function computeCfreRegular(entries) {
+	const issues = [];
+	const pools = entries.map((e) => {
+		const f = e.federal;
+		const o = e.albertaOverride ?? {};
+		const opening = reconcile(f.openingBalance, o.openingBalance);
+		const currentYearExpenses = num$1(f.currentYearExpenses);
+		const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+		const otherAdd = reconcile(f.otherAdditions, o.otherAdditions);
+		const otherDed = reconcile(f.otherDeductions, o.otherDeductions);
+		return {
+			e,
+			opening,
+			currentYearExpenses,
+			amalg,
+			otherAdd,
+			otherDed,
+			foreignResourceIncome: num$1(f.foreignResourceIncome),
+			pool: opening.value + currentYearExpenses + amalg.value + otherAdd.value - otherDed.value
+		};
+	});
+	const sumForeignResourceIncome = pools.reduce((s, p) => s + p.foreignResourceIncome, 0);
+	return {
+		entries: pools.map((p) => {
+			const { e, opening, currentYearExpenses, amalg, otherAdd, otherDed, foreignResourceIncome, pool } = p;
+			let claim = 0;
+			if (pool < 0) issues.push(`Schedule 15 CFRE regular, country ${e.federal.countryCode} (015293): the pool balance is negative. Per the schedule's pattern for foreign pools this is included in federal T2 line 012040 — outside this engine's scope.`);
+			else if (pool > 0) {
+				const linear = linearYearFactor(e.daysInTaxYear);
+				const partA = Math.max(CCOGPE_CLAIM_RATE * linear * pool, Math.min(CDE_CLAIM_RATE * linear * pool, foreignResourceIncome, sumForeignResourceIncome));
+				const remainder = Math.max(0, pool - partA);
+				if (e.globalForeignResourceLimit === void 0) issues.push(`Schedule 15 CFRE regular, country ${e.federal.countryCode} (015293): the "global foreign resource limit for the year designated for that country" (source lines 15703-15711) was not supplied — this quantity has no source anywhere in this engine, so the B-component of the claim is treated as 0 (conservative — the pool may be under-claimed relative to what the corporation is actually entitled to).`);
+				const partB = Math.min(remainder, nn$25(e.globalForeignResourceLimit));
+				claim = claimUpToCap(e.claimed, partA + partB, issues, `Schedule 15 CFRE regular, country ${e.federal.countryCode} (015293)`);
+			}
+			const closingBalance = pool - claim;
+			return {
+				countryCode: e.federal.countryCode,
+				openingBalance: opening.value,
+				currentYearExpenses,
+				amalgamationTransfer: amalg.value,
+				otherAdditions: otherAdd.value,
+				otherDeductions: otherDed.value,
+				foreignResourceIncome,
+				pool,
+				claim,
+				closingBalance,
+				differsFromFederal: opening.differs || amalg.differs || otherAdd.differs || otherDed.differs,
+				issues
+			};
+		}),
+		issues
+	};
+}
+function computeAlbertaSchedule15(input) {
+	const issues = [];
+	const differsFlags = [];
+	const eda = input.eda ? {
+		regular: computeEdaRegular(input.eda.regular),
+		successor: computeEdaSuccessor(input.eda.successor)
+	} : void 0;
+	if (eda) {
+		issues.push(...eda.regular.issues, ...eda.successor.issues);
+		differsFlags.push(eda.regular.differsFromFederal, eda.successor.differsFromFederal);
+	}
+	const cmedb = input.cmedb ? computeCmedb(input.cmedb) : void 0;
+	if (cmedb) {
+		issues.push(...cmedb.issues);
+		differsFlags.push(cmedb.differsFromFederal);
+	}
+	const cee = input.cee ? {
+		regular: computeCeeRegular(input.cee.regular),
+		successor: computeCeeSuccessor(input.cee.successor)
+	} : void 0;
+	if (cee) {
+		issues.push(...cee.regular.issues, ...cee.successor.issues);
+		differsFlags.push(cee.regular.differsFromFederal, cee.successor.differsFromFederal);
+	}
+	const ccogpe = input.ccogpe ? {
+		regular: computeCcogpeRegular(input.ccogpe.regular),
+		successor: computeCcogpeSuccessor(input.ccogpe.successor)
+	} : void 0;
+	if (ccogpe) {
+		issues.push(...ccogpe.regular.issues, ...ccogpe.successor.issues);
+		differsFlags.push(ccogpe.regular.differsFromFederal, ccogpe.successor.differsFromFederal);
+	}
+	const cde = input.cde ? {
+		regular: computeCdeRegular(input.cde.regular, { subtotal: ccogpe?.regular.subtotal ?? 0 }),
+		successor: computeCdeSuccessor(input.cde.successor, { subtotal: ccogpe?.successor.subtotal ?? 0 })
+	} : void 0;
+	if (cde) {
+		issues.push(...cde.regular.issues, ...cde.successor.issues);
+		differsFlags.push(cde.regular.differsFromFederal, cde.successor.differsFromFederal);
+		if (ccogpe && (ccogpe.regular.otherDeductions !== 0 || ccogpe.regular.claim !== 0)) issues.push("Schedule 15 CCOGPE successor (015191): source lines 14731-14740 read literally as subtracting the CCOGPE-REGULAR pool's own 015167 and 015169 from the SUCCESSOR pool's closing balance, and 015167/015169 are non-zero this year. This module used the clean additions−deductions−claim formula instead (see module doc comment) — confirm against the live TRA form before relying on 015191.");
+	}
+	const fede = input.fede ? {
+		regular: computeFedeRegular(input.fede.regular),
+		successor: computeFedeSuccessor(input.fede.successor)
+	} : void 0;
+	if (fede) {
+		issues.push(...fede.regular.issues, ...fede.successor.issues);
+		differsFlags.push(fede.regular.differsFromFederal, fede.successor.differsFromFederal);
 	}
+	const sfede = input.sfede ? {
+		regular: input.sfede.regular.map(computeSfedeCountryRegular),
+		successor: input.sfede.successor.map(computeSfedeCountrySuccessor)
+	} : void 0;
+	if (sfede) {
+		for (const r of sfede.regular) {
+			issues.push(...r.issues);
+			differsFlags.push(r.differsFromFederal);
+		}
+		for (const s of sfede.successor) {
+			issues.push(...s.issues);
+			differsFlags.push(s.differsFromFederal);
+		}
+	}
+	const cfre = input.cfre ? {
+		regular: computeCfreRegular(input.cfre.regular),
+		successor: computeCfreSuccessor(input.cfre.successor)
+	} : void 0;
+	if (cfre) {
+		issues.push(...cfre.regular.issues, ...cfre.successor.issues);
+		for (const r of cfre.regular.entries) differsFlags.push(r.differsFromFederal);
+		for (const s of cfre.successor.entries) differsFlags.push(s.differsFromFederal);
+	}
+	if (input.cde) issues.push("Schedule 15 CDE regular (015107): the field's own business rule references line 015139, which does not exist elsewhere in this schedule. See module doc comment.");
+	const formRequired = differsFlags.some(Boolean);
+	const formPermitted = (input.reportsDifferentAlbertaIncome ?? false) || (input.electsDifferentDiscretionaryAmounts ?? false);
+	if (formRequired && !formPermitted) issues.push("Alberta Schedule 15: an opening balance or claim differs from federal, so the form is required, but neither line 000060 nor 000061 is set to 1. Set line 000061 and file a Schedule 12.");
 	return {
-		scheduleId: "010",
-		values
+		...eda ? { eda } : {},
+		...cmedb ? { cmedb } : {},
+		...cee ? { cee } : {},
+		...cde ? { cde } : {},
+		...ccogpe ? { ccogpe } : {},
+		...fede ? { fede } : {},
+		...sfede ? { sfede: {
+			regular: sfede.regular,
+			successor: sfede.successor
+		} } : {},
+		...cfre ? { cfre: {
+			regular: cfre.regular.entries,
+			successor: cfre.successor.entries
+		} } : {},
+		formRequired,
+		formPermitted,
+		issues
 	};
 }
-const S20_CHARITABLE = {
-	opening: "002",
-	expired: "004",
-	beginning: "006",
-	transferred: "008",
-	currentYear: "010",
-	subtotal: "012",
-	acquisitionOfControl: "013",
-	available: "014",
-	applied: "016",
-	closing: "018"
-};
-const S20_GIFTS = {
-	opening: "062",
-	expired: "064",
-	beginning: "066",
-	transferred: "068",
-	currentYear: "070",
-	subtotal: "072",
-	acquisitionOfControl: "073",
-	available: "074",
-	applied: "076",
-	closing: "078"
-};
-function donationContinuityValues(result, f) {
-	const put = (fieldId, value) => ({
-		lineItemId: at1LineItemId("020", fieldId),
-		value
+/** Line 015313 caps at "total of all occurrence of 015317", so this also processes the whole array. */
+function computeCfreSuccessor(entries) {
+	const issues = [];
+	const pools = entries.map((e) => {
+		const f = e.federal;
+		const o = e.albertaOverride ?? {};
+		const opening = reconcile(f.openingBalance, o.openingBalance);
+		const amalg = reconcile(f.amalgamationTransfer, o.amalgamationTransfer);
+		const other = reconcile(f.otherTransfer, o.otherTransfer);
+		const otherDed = reconcile(f.otherDeductions, o.otherDeductions);
+		return {
+			e,
+			opening,
+			amalg,
+			other,
+			otherDed,
+			foreignResourceIncome: num$1(f.foreignResourceIncome),
+			pool: opening.value + amalg.value + other.value - otherDed.value
+		};
 	});
-	return [
-		put(f.opening, result.openingBalance),
-		put(f.expired, result.expired),
-		put(f.beginning, Math.max(0, result.openingBalance - result.expired)),
-		put(f.transferred, result.transferredIn),
-		put(f.currentYear, result.currentYearGifts),
-		put(f.subtotal, result.transferredIn + result.currentYearGifts),
-		put(f.acquisitionOfControl, result.acquisitionOfControlAdjustment),
-		put(f.available, result.availableBeforeClaim),
-		put(f.applied, result.amountApplied),
-		put(f.closing, result.closingBalance)
-	];
-}
-function schedule20Values(input) {
-	const values = [];
-	if (input.charitable) values.push(...donationContinuityValues(input.charitable, S20_CHARITABLE));
-	if (input.gifts) values.push(...donationContinuityValues(input.gifts, S20_GIFTS));
-	if (input.maximum) {
-		const put = (fieldId, value) => values.push({
-			lineItemId: at1LineItemId("020", fieldId),
-			value
-		});
-		put("030", input.maximum.incomeComponent);
-		put("042", input.maximum.lesserOfProceedsAndCost);
-		put("044", input.maximum.allowableRecapture);
-		put("046", input.maximum.gainsComponent);
-		put("048", input.maximum.maximumDeduction);
-	}
+	const sumForeignResourceIncome = pools.reduce((s, p) => s + p.foreignResourceIncome, 0);
 	return {
-		scheduleId: "020",
-		values
+		entries: pools.map((p) => {
+			const { e, opening, amalg, other, otherDed, foreignResourceIncome, pool } = p;
+			let claim = 0;
+			if (pool < 0) issues.push(`Schedule 15 CFRE successor, country ${e.federal.countryCode} (015313): the pool balance is negative. Per the schedule's pattern for foreign pools this is included in federal T2 line 012040 — outside this engine's scope.`);
+			else if (pool > 0) {
+				const cap = Math.min(CDE_CLAIM_RATE * linearYearFactor(e.daysInTaxYear) * pool, sumForeignResourceIncome);
+				claim = claimUpToCap(e.claimed, cap, issues, `Schedule 15 CFRE successor, country ${e.federal.countryCode} (015313)`);
+			}
+			const closingBalance = pool - claim;
+			return {
+				countryCode: e.federal.countryCode,
+				openingBalance: opening.value,
+				amalgamationTransfer: amalg.value,
+				otherTransfer: other.value,
+				otherDeductions: otherDed.value,
+				foreignResourceIncome,
+				pool,
+				claim,
+				closingBalance,
+				differsFromFederal: opening.differs || amalg.differs || other.differs || otherDed.differs,
+				issues
+			};
+		}),
+		issues
 	};
 }
+function schedule15LineItemId(fieldId, occurrence = 1) {
+	return `015${fieldId}${String(occurrence).padStart(3, "0")}`;
+}
 /**
-* The SR&ED expenditure POOL — a deduction against income, not the investment tax
-* credit and not the innovation grant.
-*
-* Line numbers and the subtotal formula verified against the live form, which
-* states it exactly as transcribed:
-*
-*   016 = 002 − (004 + 006 + 008) + 010 + 012 + 014 + 015
-*
-* and closes the year-over-year chain in as many words: line 022 is *"the carry
-* forward amount for next year, line 012"*.
+* Field ids per the spec transcription in the module doc comment:
+*   EDA    001-021   CMEDB  023-033   CEE    041-083   CDE    091-143
+*   CCOGPE 151-191   FEDE   201-233   SFEDE  241-277 (per country)
+*   CFRE   281-317 (per country)
+* A pool absent from `result` (never supplied to `computeAlbertaSchedule15`)
+* emits NOTHING — there is no zero-filled line for a pool the corporation
+* does not carry, matching every other reconciliation-style AT1 schedule
+* builder in this package (e.g. `schedule18Values` only emits categories that
+* were actually computed).
 */
-function schedule16Values(result) {
+function schedule15Values(result) {
 	const values = [];
-	const put = (fieldId, value) => values.push({
-		lineItemId: at1LineItemId("016", fieldId),
+	const put = (fieldId, value, occurrence = 1) => values.push({
+		lineItemId: schedule15LineItemId(fieldId, occurrence),
 		value
 	});
-	put("002", result.currentYearExpenditures);
-	put("016", result.subtotal);
-	put("018", result.deductionAvailable);
-	put("020", result.amountClaimed);
-	put("022", result.unclaimedPoolBalance);
+	const putStr = (fieldId, value, occurrence = 1) => values.push({
+		lineItemId: schedule15LineItemId(fieldId, occurrence),
+		value
+	});
+	if (result.eda) {
+		const { regular, successor } = result.eda;
+		put("001", regular.openingBalance);
+		put("003", regular.amalgamationTransfer);
+		put("005", regular.saleTransfer);
+		put("007", regular.claim);
+		put("009", regular.closingBalance);
+		put("011", successor.openingBalance);
+		put("013", successor.amalgamationTransfer);
+		put("015", successor.otherTransfer);
+		put("017", successor.saleTransfer);
+		put("019", successor.claim);
+		put("021", successor.closingBalance);
+	}
+	if (result.cmedb) {
+		const c = result.cmedb;
+		put("023", c.openingBalance);
+		put("025", c.amalgamationTransfer);
+		put("027", c.otherTransfer);
+		put("029", c.disposalTransfer);
+		put("031", c.claim);
+		put("033", c.closingBalance);
+	}
+	if (result.cee) {
+		const { regular, successor } = result.cee;
+		put("041", regular.openingBalance);
+		put("043", regular.currentYearExpenses);
+		put("044", regular.lookBackExpenses);
+		put("045", regular.reclassifiedFromCde);
+		put("047", regular.amalgamationTransfer);
+		put("049", regular.renewableConservationExpenses);
+		put("051", regular.otherAdditions);
+		put("053", regular.governmentAssistance);
+		put("055", regular.otherDeductions);
+		put("058", regular.renouncedFlowThrough);
+		put("059", regular.transferredToSuccessor);
+		put("060", regular.renouncedLookBack);
+		put("061", regular.claim);
+		put("063", regular.closingBalance);
+		put("064", successor.openingBalance);
+		put("065", successor.reclassifiedFromCde);
+		put("067", successor.amalgamationTransfer);
+		put("069", successor.otherTransfer);
+		put("077", successor.otherDeductions);
+		put("079", successor.transferredToSuccessor);
+		put("081", successor.claim);
+		put("083", successor.closingBalance);
+	}
+	if (result.cde) {
+		const { regular, successor } = result.cde;
+		put("091", regular.openingBalance);
+		put("093", regular.currentYearExpenses);
+		put("094", regular.lookBackExpenses);
+		put("095", regular.amalgamationTransfer);
+		put("097", regular.otherAdditions);
+		put("099", regular.reclassifiedFromCee);
+		put("101", regular.governmentAssistance);
+		put("103", regular.receivableOnDisposition);
+		put("105", regular.creditBalanceInCogpePool);
+		put("107", regular.otherDeductions);
+		put("110", regular.renouncedFlowThrough);
+		put("111", regular.transferredToSuccessor);
+		put("112", regular.renouncedLookBack);
+		put("115", regular.claim);
+		put("117", regular.closingBalance);
+		put("119", successor.openingBalance);
+		put("121", successor.amalgamationTransfer);
+		put("123", successor.otherTransfer);
+		put("127", successor.reclassifiedFromCee);
+		put("133", successor.creditBalanceInCogpePool);
+		put("135", successor.otherDeductions);
+		put("137", successor.transferredToSuccessor);
+		put("141", successor.claim);
+		put("143", successor.closingBalance);
+	}
+	if (result.ccogpe) {
+		const { regular, successor } = result.ccogpe;
+		put("151", regular.openingBalance);
+		put("153", regular.currentYearExpenses);
+		put("155", regular.amalgamationTransfer);
+		put("157", regular.otherAdditions);
+		put("159", regular.receivableOnDisposition);
+		put("161", regular.governmentAssistance);
+		put("165", regular.transferredToSuccessor);
+		put("167", regular.otherDeductions);
+		put("169", regular.claim);
+		put("171", regular.closingBalance);
+		put("173", successor.openingBalance);
+		put("175", successor.amalgamationTransfer);
+		put("177", successor.otherTransfer);
+		put("181", successor.receivableOnDisposition);
+		put("185", successor.transferredToSuccessor);
+		put("187", successor.otherDeductions);
+		put("189", successor.claim);
+		put("191", successor.closingBalance);
+	}
+	if (result.fede) {
+		const { regular, successor } = result.fede;
+		put("201", regular.openingBalance);
+		put("205", regular.amalgamationTransfer);
+		put("207", regular.otherDeductions);
+		put("209", regular.claim);
+		put("211", regular.closingBalance);
+		put("231", regular.foreignResourceIncome);
+		put("213", successor.openingBalance);
+		put("215", successor.amalgamationTransfer);
+		put("217", successor.otherTransfer);
+		put("219", successor.otherDeductions);
+		put("221", successor.claim);
+		put("223", successor.closingBalance);
+		put("233", successor.foreignResourceIncome);
+	}
+	if (result.sfede) {
+		result.sfede.regular.forEach((r, i) => {
+			const occ = i + 1;
+			putStr("241", r.countryCode, occ);
+			put("243", r.openingBalance, occ);
+			put("247", r.amalgamationTransfer, occ);
+			put("249", r.otherAdditions, occ);
+			put("251", r.otherDeductions, occ);
+			put("253", r.claim, occ);
+			put("255", r.closingBalance, occ);
+			put("257", r.foreignResourceIncome, occ);
+		});
+		result.sfede.successor.forEach((s, i) => {
+			const occ = i + 1;
+			putStr("261", s.countryCode, occ);
+			put("263", s.openingBalance, occ);
+			put("265", s.amalgamationTransfer, occ);
+			put("267", s.otherTransfer, occ);
+			put("269", s.otherDeductions, occ);
+			put("273", s.claim, occ);
+			put("275", s.closingBalance, occ);
+			put("277", s.foreignResourceIncome, occ);
+		});
+	}
+	if (result.cfre) {
+		result.cfre.regular.forEach((r, i) => {
+			const occ = i + 1;
+			putStr("281", r.countryCode, occ);
+			put("283", r.openingBalance, occ);
+			put("285", r.currentYearExpenses, occ);
+			put("287", r.amalgamationTransfer, occ);
+			put("289", r.otherAdditions, occ);
+			put("291", r.otherDeductions, occ);
+			put("293", r.claim, occ);
+			put("295", r.closingBalance, occ);
+			put("297", r.foreignResourceIncome, occ);
+		});
+		result.cfre.successor.forEach((s, i) => {
+			const occ = i + 1;
+			putStr("301", s.countryCode, occ);
+			put("303", s.openingBalance, occ);
+			put("305", s.amalgamationTransfer, occ);
+			put("307", s.otherTransfer, occ);
+			put("309", s.otherDeductions, occ);
+			put("313", s.claim, occ);
+			put("315", s.closingBalance, occ);
+			put("317", s.foreignResourceIncome, occ);
+		});
+	}
 	return {
-		scheduleId: "016",
-		values
+		scheduleId: "015",
+		values,
+		issues: result.issues
 	};
 }
 //#endregion
-//#region src/t2/at1/schedules/schedule2.ts
-/** Round to six decimal places — the AT1 allocation-factor precision. */
-function round6(n) {
-	return Math.round(n * 1e6) / 1e6;
-}
-/** Single Alberta PE, none elsewhere → all income is Alberta income. */
-const SINGLE_JURISDICTION_ALBERTA_FACTOR = 1;
-function computeAllocationFactor(input) {
-	const hasRevenue = input.totalGrossRevenue > 0;
-	const hasSalaries = input.totalSalaries > 0;
-	const revenueRatio = hasRevenue ? input.albertaGrossRevenue / input.totalGrossRevenue : 0;
-	const salariesRatio = hasSalaries ? input.albertaSalaries / input.totalSalaries : 0;
-	let factor;
-	if (hasRevenue && hasSalaries) factor = (revenueRatio + salariesRatio) / 2;
-	else if (hasRevenue) factor = revenueRatio;
-	else if (hasSalaries) factor = salariesRatio;
-	else factor = 0;
-	return round6(factor);
+//#region src/t2/at1/schedules/schedule29-eligible-expenditures.ts
+/**
+* AT1 Schedule 29 page 1 — Eligible Expenditures for IEG Purposes (lines
+* 001–040). AT29's own worksheet for deriving the "eligible expenditures"
+* figure (line 031) that everything else on this schedule — the base amount,
+* the increment, the Agreement's per-member 245/250/260 — is built from.
+*
+* ── Why this module exists separately from `schedule29-ieg.ts` ─────────────
+*
+* `computeIeg` took `eligibleExpenditures` as a bare number input. It is not
+* one — it is DERIVED, by a six-line formula off federal T661, and a prior
+* version of this package never modelled that derivation at all: it skipped
+* page 1 of the live form entirely (only pages 2 and 3 were ever rendered),
+* so every caller had to compute line 031 by hand outside the engine, with
+* nothing here to check the arithmetic. Confirmed missing by rendering the
+* live, TRA-certified form (`research/sources/tra-forms/pdf/AT1SCH29-*.pdf`,
+* page 1) and independently re-verified against two of TRA's own published
+* worked examples (`research/sources/tra-guides/tra-guide-claiming-the-
+* innovation-employment-grant.pdf`, Examples 3 and 4) — see
+* `research/knowledge-base/at1-schedule-29-ieg-mechanics.md`.
+*
+* ── The formula ──────────────────────────────────────────────────────────
+*
+*   003  federal amount of qualified/current SR&ED expenditures, T661 line
+*        559 or 557 (see below)
+*   005  portion of 003 carried out in Alberta — normally the sum of every
+*        AT4970 project row's own 105 column (`at4970-ieg-projects.ts`)
+*   007  deduct: federal prescribed proxy amount included in the Alberta
+*        portion of 003 — normally Σ AT4970's 111 column
+*   009  add: Alberta proxy amount — normally Σ AT4970's 113 column
+*   011  add: IEG that reduced the federal expenditure IN THE TAXATION YEAR
+*        — zero for a first-time current-year claim reported on the
+*        pre-deduction federal figures (see the Step 1 / Step 2 note below)
+*   025  add: the Alberta portion of a repayment of government assistance
+*        (other than an IEG) OR A CONTRACT PAYMENT, relating to amounts in
+*        005 from the current year or ANY PRECEDING taxation year — two
+*        independent triggers, not one
+*   031  TOTAL = 005 − 007 + 009 + 011 + 025
+*
+* 031 is what `computeIeg` calls `eligibleExpenditures` and what an
+* Agreement member's own `currentYearExpenditures` (line 245) is — the same
+* formula, computed once per corporation per year, whether or not that
+* corporation is associated.
+*
+* ── The federal T661 line 557 vs 559 split (Fall 2026 re-certification) ────
+*
+* TRA's own certification correspondence and the live form agree: for a
+* taxation year ending ON OR BEFORE 2024-12-15, line 003 comes from federal
+* T661 line 559 (qualified SR&ED expenditures); for a taxation year ending
+* ON OR AFTER 2024-12-16, it comes from T661 line 557 (CURRENT SR&ED
+* expenditures) instead — a different federal figure, not a renumbering.
+* `iegT661SourceLine` below is purely informational (which federal line a
+* preparer should be told to copy from); it does not change the Alberta
+* arithmetic itself, which is identical either way.
+*
+* ── The "Step 1 / Step 2" columns in TRA's Guide are not two form fields ────
+*
+* The Guide illustrates every page-1 line twice — once using the federal
+* figures BEFORE the current year's own IEG is netted against them as
+* government assistance (T661 line 513), once AFTER, with line 011 adding
+* the IEG back. Both worked examples land on the IDENTICAL line 031 either
+* way (011 exists specifically to undo the 513 netting for ALBERTA's own
+* base, so it cannot shrink itself). Only ONE set of figures is filed. Every
+* TRA test case gives the pre-deduction ("Step 1") federal figures — use
+* those directly, with 011 = 0 for a first-time current-year claim. Do not
+* build a literal two-pass loop; there is nothing for it to converge on that
+* isn't already true of the Step 1 figures alone.
+*
+* Whole dollars, pure.
+*/
+/** Which federal T661 line line 003 sources from, given a taxation year end. */
+function iegT661SourceLine(taxationYearEnd) {
+	return taxationYearEnd >= "2024-12-16" ? "557" : "559";
+}
+const nn$24 = (v) => Math.round(v ?? 0);
+/** Line 031 = 005 − 007 + 009 + 011 + 025. Every term but 005 defaults to nil. */
+function computeIegEligibleExpenditures(input) {
+	const federalAmount = nn$24(input.federalAmount);
+	const albertaPortion = nn$24(input.albertaPortion);
+	const federalProxyAmount = nn$24(input.federalProxyAmount);
+	const albertaProxyAmount = nn$24(input.albertaProxyAmount);
+	const iegReducingFederalExpenditure = nn$24(input.iegReducingFederalExpenditure);
+	const repaymentOrContractPayment = nn$24(input.repaymentOrContractPayment);
+	return {
+		federalAmount,
+		albertaPortion,
+		federalProxyAmount,
+		albertaProxyAmount,
+		iegReducingFederalExpenditure,
+		repaymentOrContractPayment,
+		totalEligibleExpenditures: albertaPortion - federalProxyAmount + albertaProxyAmount + iegReducingFederalExpenditure + repaymentOrContractPayment
+	};
 }
 //#endregion
 //#region src/t2/at1/schedules/schedule29-ieg.ts
@@ -1014,6 +3537,37 @@ function computeIeg(input) {
 * contributes its taxable capital to the grind. Both cases appear in the Alberta
 * certification material and both are modelled.
 *
+* ── ⚠ This module's "group aggregated base amount" has no line on the real form ──
+*
+* Rendering Schedule 29 page 2 in full (a prior version of this package only
+* ever rendered pages 2 and 3's CREDIT section, never page 1) shows the base
+* amount (lines 114/116/118) captioned "*If the corporation is NOT
+* associated with one or more corporations in the taxation year, the Base
+* Amount is the amount that is the average of the eligible expenditures OF
+* THE CORPORATION for the two immediately preceding taxation years" — the
+* CLAIMANT's own figures alone, no group aggregation, and used ONLY for the
+* non-associated path (line 112). Confirmed blank in both of TRA's own
+* published worked examples whenever the corporation IS associated — the
+* associated path (line 125) uses no base amount at all, replacing the
+* whole mechanism with the Agreement's Allowed Amount instead (see
+* `computeIegAgreement` below). The live form also states an associated
+* corporation MUST complete the Agreement ("If 'Yes', complete page 3") —
+* so there is no scenario on the real form where a group is associated but
+* has not filed one. `computeIegGroupFigures`'s "aggregate every member's
+* prior-two-years spending into one shared base amount", used regardless of
+* associated/non-associated status by `computeAlbertaReturn`, therefore
+* does not correspond to anything a preparer could actually file — it is
+* harmless ONLY because `computeIeg`'s associated branch ignores
+* `baseAmount` entirely. Left in place rather than removed: not exercised by
+* any of TRA's Fall 2026 certification test cases (all either non-associated
+* with a genuine single-corporation base, or associated with a filed
+* Agreement whose own figures are what actually reach the credit), so a full
+* rearchitecture is deferred rather than rushed. `taxableCapital` for the
+* associated path is already sourced from the Agreement, not from here — see
+* `alberta-return.ts`. See `research/knowledge-base/
+* at1-schedule-29-ieg-mechanics.md` for the full comparison against the live
+* form and both of TRA's published worked examples.
+*
 * Whole dollars, pure.
 */
 const nn$23 = (v) => Math.max(0, Math.round(v ?? 0));
@@ -1095,17 +3649,20 @@ function allocateIegEvenly(groupExpenditureLimit, names) {
 		allocated: i === 0 ? each + remainder : each
 	})));
 }
-function computeAgreementMember(m) {
+function computeAgreementMember(m, index, issues) {
 	const allocatedExpenditureLimit = nn$23(m.allocatedExpenditureLimit);
 	const currentYearExpenditures = nn$23(m.currentYearExpenditures);
 	const priorYear1 = nn$23(m.priorYear1);
 	const priorYear2 = nn$23(m.priorYear2);
 	const base = Math.round((priorYear1 + priorYear2) / 2);
-	const individualMaximumAllowedAmount = Math.max(0, currentYearExpenditures - base);
+	const individualMaximumAllowedAmount = currentYearExpenditures - base;
 	const days = Math.max(0, Math.min(m.daysInTaxYear ?? 365, 366));
 	const dayProratedLimit = Math.round(4e6 * (days / 365));
-	const dayProratedComponent = Math.max(0, Math.min(dayProratedLimit, currentYearExpenditures) - base);
-	const allocatedAllowedAmount = Math.min(allocatedExpenditureLimit, individualMaximumAllowedAmount, dayProratedComponent);
+	const dayProratedComponent = Math.min(dayProratedLimit, currentYearExpenditures) - base;
+	const isClaimant = index === 0;
+	if (m.hasAlbertaPermanentEstablishment === void 0 && !isClaimant) issues.push(`Alberta Schedule 29 Agreement: ${m.name} did not state whether it has a permanent establishment in Alberta. Treated as no permanent establishment (line 268 = nil) — a member without one is not eligible for the IEG even when its own formula would allow an amount. Confirm and re-enter if this member does have an Alberta PE.`);
+	const hasAlbertaPermanentEstablishment = m.hasAlbertaPermanentEstablishment ?? isClaimant;
+	const allocatedAllowedAmount = hasAlbertaPermanentEstablishment ? Math.max(0, Math.min(allocatedExpenditureLimit, individualMaximumAllowedAmount, dayProratedComponent)) : 0;
 	return {
 		name: m.name,
 		...m.federalBusinessNumber !== void 0 ? { federalBusinessNumber: m.federalBusinessNumber } : {},
@@ -1116,6 +3673,7 @@ function computeAgreementMember(m) {
 		priorYear1,
 		priorYear2,
 		taxableCapitalPriorYear: nn$23(m.taxableCapitalPriorYear),
+		hasAlbertaPermanentEstablishment,
 		individualMaximumAllowedAmount,
 		allocatedAllowedAmount
 	};
@@ -1130,7 +3688,7 @@ function computeIegAgreement(input) {
 	if (input.members.length === 0) issues.push("Alberta Schedule 29 Agreement: no members were supplied. The claiming corporation must appear as the first row even in a two-corporation group.");
 	const days = Math.max(0, Math.min(input.daysInLongestYear, 366));
 	const maximumExpenditureLimit = Math.round(4e6 * (days / 365));
-	const members = input.members.map(computeAgreementMember);
+	const members = input.members.map((m, i) => computeAgreementMember(m, i, issues));
 	const sum = (get) => members.reduce((s, m) => s + get(m), 0);
 	const totalAllocatedLimit = sum((m) => m.allocatedExpenditureLimit);
 	const totalCurrentYearExpenditures = sum((m) => m.currentYearExpenditures);
@@ -1190,42 +3748,72 @@ function computeAlbertaReturn(input) {
 	const issues = [];
 	let iegGroup;
 	let iegAgreement;
+	let iegEligibleExpenditures;
 	let ieg;
-	if (input.ieg) if (input.ieg.group.length === 0) issues.push("AT1 Schedule 29: no associated-group members were supplied, so no grant was claimed. Pass the claimant itself even when it has no associated corporations — an empty group would otherwise imply no taxable-capital grind and a nil base, producing the maximum possible grant on absent data.");
-	else {
-		iegGroup = computeIegGroupFigures(input.ieg.group);
-		issues.push(...iegGroup.issues);
-		const allocation = allocateIegExpenditureLimit(iegGroup.groupExpenditureLimit, [{
-			name: "claimant",
-			allocated: input.ieg.allocatedLimit ?? iegGroup.groupExpenditureLimit
-		}]);
-		issues.push(...allocation.issues);
-		if (input.ieg.agreement) {
-			iegAgreement = computeIegAgreement(input.ieg.agreement);
-			issues.push(...iegAgreement.issues);
+	let at4970;
+	if (input.ieg) {
+		if (input.ieg.at4970) at4970 = computeAt4970(input.ieg.at4970);
+		let resolvedEligibleExpenditures = input.ieg.eligibleExpenditures ?? 0;
+		if (input.ieg.eligible) {
+			const e = input.ieg.eligible;
+			const federalProxyAmount = e.federalProxyAmount ?? at4970?.totals.federalProxyAmount;
+			const albertaProxyAmount = e.albertaProxyAmount ?? at4970?.totals.albertaProxyAmount;
+			iegEligibleExpenditures = computeIegEligibleExpenditures({
+				federalAmount: e.federalAmount,
+				albertaPortion: e.albertaPortion ?? at4970?.totals.albertaPortion ?? 0,
+				...federalProxyAmount !== void 0 ? { federalProxyAmount } : {},
+				...albertaProxyAmount !== void 0 ? { albertaProxyAmount } : {},
+				...e.iegReducingFederalExpenditure !== void 0 ? { iegReducingFederalExpenditure: e.iegReducingFederalExpenditure } : {},
+				...e.repaymentOrContractPayment !== void 0 ? { repaymentOrContractPayment: e.repaymentOrContractPayment } : {}
+			});
+			resolvedEligibleExpenditures = iegEligibleExpenditures.totalEligibleExpenditures;
+		}
+		if (input.ieg.group.length === 0) issues.push("AT1 Schedule 29: no associated-group members were supplied, so no grant was claimed. Pass the claimant itself even when it has no associated corporations — an empty group would otherwise imply no taxable-capital grind and a nil base, producing the maximum possible grant on absent data.");
+		else {
+			iegGroup = computeIegGroupFigures(input.ieg.group);
+			issues.push(...iegGroup.issues);
+			const allocation = allocateIegExpenditureLimit(iegGroup.groupExpenditureLimit, [{
+				name: "claimant",
+				allocated: input.ieg.allocatedLimit ?? iegGroup.groupExpenditureLimit
+			}]);
+			issues.push(...allocation.issues);
+			if (input.ieg.agreement) {
+				iegAgreement = computeIegAgreement(input.ieg.agreement);
+				issues.push(...iegAgreement.issues);
+			}
+			ieg = computeIeg({
+				eligibleExpenditures: resolvedEligibleExpenditures,
+				baseAmount: iegGroup.groupBaseAmount,
+				expenditureLimit: allocation.allocations[0]?.allocated ?? 0,
+				taxableCapital: iegAgreement ? iegAgreement.totalTaxableCapitalPriorYear : iegGroup.groupTaxableCapital,
+				...input.ieg.recapture !== void 0 ? { recapture: input.ieg.recapture } : {},
+				...iegAgreement ? { associatedAllowedAmount: iegAgreement.claimantAllocatedAllowedAmount } : {}
+			});
 		}
-		ieg = computeIeg({
-			eligibleExpenditures: input.ieg.eligibleExpenditures,
-			baseAmount: iegGroup.groupBaseAmount,
-			expenditureLimit: allocation.allocations[0]?.allocated ?? 0,
-			taxableCapital: iegGroup.groupTaxableCapital,
-			...input.ieg.recapture !== void 0 ? { recapture: input.ieg.recapture } : {},
-			...iegAgreement ? { associatedAllowedAmount: iegAgreement.claimantAllocatedAllowedAmount } : {}
-		});
 	}
 	const schedulePayloads = [];
 	const sched = input.schedules;
 	if (sched?.smallBusinessDeduction) schedulePayloads.push(schedule1Values(sched.smallBusinessDeduction));
 	if (sched?.allocation) schedulePayloads.push(schedule2Values(sched.allocation));
+	if (sched?.otherDeductionsCredits) schedulePayloads.push(schedule3Values(sched.otherDeductionsCredits));
+	if (sched?.foreignInvestmentTaxCredit) schedulePayloads.push(schedule4Values(sched.foreignInvestmentTaxCredit));
+	if (sched?.royaltyTaxDeduction) schedulePayloads.push(schedule5Values(sched.royaltyTaxDeduction));
+	if (sched?.royaltyTaxCredit) schedulePayloads.push(schedule6Values(sched.royaltyTaxCredit));
+	if (sched?.royaltySupplemental) schedulePayloads.push(schedule7Values(sched.royaltySupplemental));
+	if (sched?.politicalContributions) schedulePayloads.push(schedule8Values(sched.politicalContributions));
+	if (sched?.sredTaxCredit) schedulePayloads.push(schedule9Values(sched.sredTaxCredit.result, sched.sredTaxCredit.group));
 	if (sched?.lossCarryback) schedulePayloads.push(schedule10Values(sched.lossCarryback));
+	if (sched?.manufacturingProcessing) schedulePayloads.push(schedule11Values(sched.manufacturingProcessing));
 	if (sched?.reconciliation) schedulePayloads.push(schedule12Values(sched.reconciliation));
 	if (sched?.cca) schedulePayloads.push(schedule13Values(sched.cca));
+	if (sched?.resourceDeductions) schedulePayloads.push(schedule15Values(sched.resourceDeductions));
 	if (sched?.scientificResearch) schedulePayloads.push(schedule16Values(sched.scientificResearch));
 	if (sched?.reserves) schedulePayloads.push(schedule17Values(sched.reserves));
 	if (sched?.dispositions) schedulePayloads.push(schedule18Values(sched.dispositions));
 	if (sched?.donations) schedulePayloads.push(schedule20Values(sched.donations));
 	if (sched?.losses) schedulePayloads.push(schedule21Values(sched.losses));
-	if (ieg) schedulePayloads.push(schedule29Values(ieg, iegAgreement));
+	if (ieg) schedulePayloads.push(schedule29Values(ieg, iegAgreement, iegEligibleExpenditures, input.ieg?.primaryFieldCode));
+	if (at4970) schedulePayloads.push(schedule4970Values(at4970));
 	return {
 		allocationFactor,
 		albertaTax,
@@ -1233,6 +3821,7 @@ function computeAlbertaReturn(input) {
 		schedulePayloads,
 		...iegGroup ? { iegGroup } : {},
 		...iegAgreement ? { iegAgreement } : {},
+		...iegEligibleExpenditures ? { iegEligibleExpenditures } : {},
 		...ieg ? { ieg } : {},
 		innovationEmploymentGrant: ieg?.ieg ?? 0,
 		issues
@@ -1382,6 +3971,7 @@ const AT1_MANDATORY_WITHOUT_DEFAULT = Object.freeze([
 function assertAt1MandatoryComplete(d) {
 	const blank = (v) => v === void 0 || v === null || String(v).trim() === "";
 	const missing = AT1_MANDATORY_WITHOUT_DEFAULT.filter(([key]) => blank(d[key])).map(([, label]) => label);
+	if (d.transmitter?.isAmended && blank(d.transmitter.amendmentDescription)) missing.push("EDI073 description of changes (required when the amended return indicator is set)");
 	if (missing.length > 0) throw new At1MandatoryFieldMissingError(missing);
 }
 /** Refuse to render when any critical mandatory field is absent. */
@@ -1741,6 +4331,16 @@ const AT1_EDI_LINE_ITEMS = [
 		id: "EDI041001",
 		get: (t) => t.contact.email,
 		fmt: "text"
+	},
+	{
+		id: "EDI071001",
+		get: (t) => t.isAmended ? "1" : void 0,
+		fmt: "text"
+	},
+	{
+		id: "EDI073001",
+		get: (t) => t.isAmended ? t.amendmentDescription : void 0,
+		fmt: "text"
 	}
 ];
 //#endregion
@@ -2232,8 +4832,9 @@ function albertaCurrentYearLoss(result) {
 *
 * The STRAIGHT-LINE classes (13 leasehold interests, 14 limited-life intangibles)
 * are deliberately NOT here — they use their own arithmetic in Reg 1100(1)(b) and
-* 1100(1)(c), so `computeCcaClass` throws for them rather than silently applying
-* a declining-balance rate. See `schedules/cca-straight-line.ts`.
+* 1100(1)(c), so `computeCcaClass` never looks them up in this table. It handles
+* an EXISTING opening-UCC pool for them directly (see `schedule8.ts`); a NEW
+* addition needs the full layer/property mechanics in `schedules/cca-straight-line.ts`.
 *
 * Class 14.1 IS a declining-balance class (5%) and belongs here. Its pre-2027
 * transitional additional allowance — which keeps pre-2017 expenditures moving at
@@ -2519,19 +5120,79 @@ function computeClass141AdditionalAllowance(input) {
 * Terminal loss: if the class is EMPTIED (no assets left) with positive UCC, the
 * remaining UCC is deducted as a terminal loss, no CCA, closing UCC nil.
 *
-* NOT modelled (caller / other schedules): class 13/14/14.1 straight-line, the
-* shared $1.5M immediate-expensing limit across an associated group (caller passes
-* the already-capped eligible amount), and the 2024+ AIIP phase-out factor.
+* Class 13/14 (straight-line, Reg 1100(1)(b)/(c)): this function accepts them
+* too, but ONLY as an existing opening-UCC pool being drawn down — no rate, no
+* half-year rule, no AIIP; the claim is capped at the UCC before CCA and
+* nothing else. A current-year ADDITION on one of these classes is refused
+* (see `UnsupportedCcaClassError`) rather than silently claimed without the
+* 5-year floor / remaining-life proration Schedule III and Reg 1100(1)(c)
+* require for a NEW layer or property — that full mechanic is
+* `computeClass13` / `computeClass14` in `cca-straight-line.ts`, which this
+* entry point does not have layer/remaining-life data to drive.
+*
+* NOT modelled (caller / other schedules): a NEW class 13/14 addition (see
+* above), class 14.1's transitional additional allowance, the shared $1.5M
+* immediate-expensing limit across an associated group (caller passes the
+* already-capped eligible amount), and the 2024+ AIIP phase-out factor.
 */
 var UnsupportedCcaClassError = class extends Error {
 	ccaClass;
-	constructor(ccaClass) {
-		super(`CCA class ${ccaClass} is not a declining-balance class this engine computes yet (straight-line / special classes like 13, 14, 14.1 use different mechanics).`);
+	constructor(ccaClass, reason) {
+		super(reason ?? `CCA class ${ccaClass} is not a declining-balance class this engine computes yet (straight-line / special classes like 13, 14, 14.1 use different mechanics).`);
 		this.name = "UnsupportedCcaClassError";
 		this.ccaClass = ccaClass;
 	}
 };
+/** Class 13/14 accept only an opening-UCC drawdown here — see the file docstring. */
+const STRAIGHT_LINE_OPENING_BALANCE_ONLY = /* @__PURE__ */ new Set(["13", "14"]);
+/**
+* Class 13/14, opening-balance drawdown only: no rate, no half-year rule, no
+* AIIP, no immediate expensing — none of those concepts apply to a
+* straight-line class. The claim is simply capped at the UCC before CCA.
+* Recapture and terminal loss reuse the same general rules as every other
+* class (s.13(1) / s.20(16) are not declining-balance-specific).
+*/
+function computeStraightLineOpeningBalanceClass(input) {
+	if (Math.max(0, input.additions ?? 0) > 0) throw new UnsupportedCcaClassError(input.ccaClass, `CCA class ${input.ccaClass}: a current-year addition needs the detailed leasehold/limited-life schedule (computeClass13 / computeClass14 in cca-straight-line.ts), which this entry point has no lease-term / remaining-life data to drive. Drawing down an EXISTING opening balance (no addition this year) is supported directly.`);
+	const dispositions = Math.max(0, input.dispositions ?? 0);
+	const netAdjustments = input.netAdjustments ?? 0;
+	const uccBeforeCca = input.openingUCC + netAdjustments - dispositions;
+	const base = {
+		ccaClass: input.ccaClass,
+		rate: 0,
+		uccBeforeCca,
+		immediateExpensingClaim: 0,
+		halfYearAdjustment: 0,
+		aiipEnhancement: 0,
+		ccaBase: 0,
+		maxCca: 0,
+		ccaClaimed: 0,
+		closingUCC: 0,
+		recapture: 0,
+		terminalLoss: 0
+	};
+	if (uccBeforeCca < 0) return {
+		...base,
+		closingUCC: 0,
+		recapture: -uccBeforeCca
+	};
+	if (input.classEmptied && uccBeforeCca > 0) return {
+		...base,
+		closingUCC: 0,
+		terminalLoss: uccBeforeCca
+	};
+	const maxCca = uccBeforeCca;
+	const ccaClaimed = input.claim != null ? Math.min(Math.max(0, input.claim), maxCca) : maxCca;
+	return {
+		...base,
+		ccaBase: uccBeforeCca,
+		maxCca,
+		ccaClaimed,
+		closingUCC: uccBeforeCca - ccaClaimed
+	};
+}
 function computeCcaClass(input, rates = CCA_DECLINING_BALANCE_RATES_2024, prorationFactor = 1) {
+	if (STRAIGHT_LINE_OPENING_BALANCE_ONLY.has(input.ccaClass)) return computeStraightLineOpeningBalanceClass(input);
 	const rate = rates[input.ccaClass];
 	if (rate === void 0) throw new UnsupportedCcaClassError(input.ccaClass);
 	const additions = Math.max(0, input.additions ?? 0);
@@ -2710,6 +5371,83 @@ function applyOverride(federal, o) {
 	opt("applyHalfYearRule", federal.applyHalfYearRule);
 	return merged;
 }
+/**
+* Adapts a straight-line {@link Class13Result}/{@link Class14Result} into the
+* SAME shape every declining-balance class uses, so `classes` stays one
+* homogeneous array and the filing layer (`schedule13Values`, which reads
+* only the shared `CcaClassResult` fields) needs no changes at all. Rate/
+* half-year/AIIP/immediate-expensing are inapplicable to a straight-line
+* class and reported as 0; neither mechanic produces recapture here.
+*/
+function straightLineAsCcaClassResult(ccaClass, r) {
+	return {
+		ccaClass,
+		rate: 0,
+		uccBeforeCca: r.uccBeforeCca,
+		immediateExpensingClaim: 0,
+		halfYearAdjustment: 0,
+		aiipEnhancement: 0,
+		ccaBase: 0,
+		maxCca: r.maxCca,
+		ccaClaimed: r.ccaClaimed,
+		closingUCC: r.closingUCC,
+		recapture: 0,
+		terminalLoss: 0
+	};
+}
+/** Federal claims `federalClaim` (max if omitted); Alberta defaults to federal's ACTUAL claim, not federal's max. */
+function computeClass13Pair(input, issues) {
+	const shared = {
+		layers: input.layers,
+		openingUCC: input.openingUCC
+	};
+	const applyHalfYearRule = input.applyHalfYearRule !== void 0 ? { applyHalfYearRule: input.applyHalfYearRule } : {};
+	const federal = computeClass13({
+		...shared,
+		...applyHalfYearRule,
+		...input.federalClaim !== void 0 ? { claim: input.federalClaim } : {}
+	});
+	const albertaClaim = input.albertaClaim !== void 0 ? input.albertaClaim : federal.ccaClaimed;
+	const alberta = computeClass13({
+		...shared,
+		...applyHalfYearRule,
+		claim: albertaClaim
+	});
+	issues.push(...federal.issues, ...alberta.issues);
+	return {
+		ccaClass: "13",
+		alberta: straightLineAsCcaClassResult("13", alberta),
+		federal: straightLineAsCcaClassResult("13", federal),
+		openingUccDiffers: false,
+		claimDiffers: alberta.ccaClaimed !== federal.ccaClaimed,
+		ccaDifference: alberta.ccaClaimed - federal.ccaClaimed
+	};
+}
+function computeClass14Pair(input, issues) {
+	const shared = {
+		properties: input.properties,
+		openingUCC: input.openingUCC,
+		...input.daysInTaxYear !== void 0 ? { daysInTaxYear: input.daysInTaxYear } : {}
+	};
+	const federal = computeClass14({
+		...shared,
+		...input.federalClaim !== void 0 ? { claim: input.federalClaim } : {}
+	});
+	const albertaClaim = input.albertaClaim !== void 0 ? input.albertaClaim : federal.ccaClaimed;
+	const alberta = computeClass14({
+		...shared,
+		claim: albertaClaim
+	});
+	issues.push(...federal.issues, ...alberta.issues);
+	return {
+		ccaClass: "14",
+		alberta: straightLineAsCcaClassResult("14", alberta),
+		federal: straightLineAsCcaClassResult("14", federal),
+		openingUccDiffers: false,
+		claimDiffers: alberta.ccaClaimed !== federal.ccaClaimed,
+		ccaDifference: alberta.ccaClaimed - federal.ccaClaimed
+	};
+}
 function computeAlbertaSchedule13(input) {
 	const rates = input.rates ?? CCA_DECLINING_BALANCE_RATES_2024;
 	const issues = [];
@@ -2730,6 +5468,8 @@ function computeAlbertaSchedule13(input) {
 			ccaDifference: alberta.ccaClaimed - federal.ccaClaimed
 		};
 	});
+	if (input.class13) classes.push(computeClass13Pair(input.class13, issues));
+	if (input.class14) classes.push(computeClass14Pair(input.class14, issues));
 	const sum = (pickFn) => classes.reduce((s, c) => s + pickFn(c), 0);
 	const albertaTotalCca = sum((c) => c.alberta.ccaClaimed);
 	const federalTotalCca = sum((c) => c.federal.ccaClaimed);
@@ -3324,19 +6064,58 @@ function computeDonationMaximum(input) {
 	};
 }
 //#endregion
+//#region src/t2/at1/schedules/schedule21-limited-partnership.ts
+function computeLimitedPartnershipLossRow(row) {
+	const issues = [];
+	const precedingYearBalance = Math.max(0, row.precedingYearBalance);
+	const transferredOnWindUp = Math.max(0, row.transferredOnWindUp ?? 0);
+	const currentYearLoss = Math.max(0, row.currentYearLoss ?? 0);
+	const maxApplied = precedingYearBalance + transferredOnWindUp;
+	const requestedApplied = Math.max(0, row.applied ?? 0);
+	if (requestedApplied > maxApplied) issues.push(`Limited partnership loss${row.identifier ? ` (${row.identifier})` : ""}: the amount applied (${requestedApplied}) cannot exceed the preceding-year balance plus any wind-up transfer (${maxApplied}). Capped at ${maxApplied}.`);
+	const applied = Math.min(requestedApplied, maxApplied);
+	const closingBalance = precedingYearBalance + transferredOnWindUp + currentYearLoss - applied;
+	return {
+		...row.identifier !== void 0 ? { identifier: row.identifier } : {},
+		precedingYearBalance,
+		transferredOnWindUp,
+		currentYearLoss,
+		applied,
+		closingBalance,
+		issues
+	};
+}
+function computeLimitedPartnershipLosses(rows) {
+	const computedRows = rows.map(computeLimitedPartnershipLossRow);
+	return {
+		rows: computedRows,
+		totalApplied: computedRows.reduce((s, r) => s + r.applied, 0),
+		totalClosingBalance: computedRows.reduce((s, r) => s + r.closingBalance, 0),
+		issues: computedRows.flatMap((r) => r.issues)
+	};
+}
+//#endregion
 //#region src/t2/schedules/loss-continuity.ts
 function computeLossContinuity(input) {
 	const currentYearLoss = input.currentYearLoss ?? 0;
 	const carriedBack = input.carriedBack ?? 0;
 	const appliedCurrentYear = input.appliedCurrentYear ?? 0;
 	const expired = input.expired ?? 0;
-	const closingBalance = Math.max(0, input.openingBalance + currentYearLoss - carriedBack - appliedCurrentYear - expired);
+	const windUpTransfer = input.windUpTransfer ?? 0;
+	const section80Adjustment = input.section80Adjustment ?? 0;
+	const otherAdjustments = input.otherAdjustments ?? 0;
+	const balanceAtBeginningOfYear = input.openingBalance - expired;
+	const closingBalance = Math.max(0, balanceAtBeginningOfYear + windUpTransfer + currentYearLoss - appliedCurrentYear - section80Adjustment - otherAdjustments - carriedBack);
 	return {
 		openingBalance: input.openingBalance,
 		currentYearLoss,
 		carriedBack,
 		appliedCurrentYear,
 		expired,
+		windUpTransfer,
+		section80Adjustment,
+		otherAdjustments,
+		balanceAtBeginningOfYear,
 		closingBalance
 	};
 }
@@ -3368,6 +6147,76 @@ function computeLossSchedule(input) {
 	};
 }
 //#endregion
+//#region src/t2/at1/schedules/schedule21-year-of-origin.ts
+function sumRows(rows) {
+	const sum = (f) => rows.reduce((s, r) => s + f(r), 0);
+	return {
+		balanceAtBeginning: sum((r) => r.balanceAtBeginning),
+		lossIncurred: sum((r) => r.lossIncurred),
+		adjustments: sum((r) => r.adjustments),
+		carriedBack: sum((r) => r.carriedBack),
+		applied: sum((r) => r.applied),
+		balanceAtEnd: sum((r) => r.balanceAtEnd)
+	};
+}
+function computeNonCapitalLossByYearOfOrigin(input) {
+	const issues = [];
+	const lossIncurred = Math.max(0, input.currentYearLoss);
+	const carriedBack = Math.max(0, input.currentYearCarriedBack);
+	const rows = [{
+		yearIndex: 0,
+		balanceAtBeginning: 0,
+		lossIncurred,
+		adjustments: 0,
+		carriedBack,
+		applied: 0,
+		balanceAtEnd: Math.max(0, lossIncurred - carriedBack)
+	}, ...(input.priorVintages ?? []).map((v) => {
+		if (v.yearsAgo < 1 || v.yearsAgo > 20) issues.push(`Non-capital loss year of origin: yearsAgo (${v.yearsAgo}) must be 1-20 — a non-capital loss expires after 20 years.`);
+		const balanceAtBeginning = Math.max(0, v.balanceAtBeginning ?? 0);
+		const adjustments = v.adjustments ?? 0;
+		const applied = Math.max(0, v.applied ?? 0);
+		return {
+			yearIndex: v.yearsAgo,
+			...v.taxYearEnd !== void 0 ? { taxYearEnd: v.taxYearEnd } : {},
+			balanceAtBeginning,
+			lossIncurred: 0,
+			adjustments,
+			carriedBack: 0,
+			applied,
+			balanceAtEnd: Math.max(0, balanceAtBeginning + adjustments - applied)
+		};
+	})];
+	return {
+		rows,
+		totals: sumRows(rows),
+		issues
+	};
+}
+function computeOtherLossByYearOfOrigin(rows) {
+	const issues = [];
+	const computed = rows.map((r) => {
+		if (r.yearIndex < 0 || r.yearIndex > 20) issues.push(`Other-loss year of origin: yearIndex (${r.yearIndex}) must be 0-20 — a farm/restricted-farm loss expires after 20 years.`);
+		const listedPersonalPropertyLosses = Math.max(0, r.listedPersonalPropertyLosses ?? 0);
+		if (r.yearIndex > 7 && listedPersonalPropertyLosses > 0) issues.push(`Other-loss year of origin: listed personal property losses cannot exist for occurrence ${r.yearIndex} — that loss type expires after 7 taxation years, not 20.`);
+		return {
+			yearIndex: r.yearIndex,
+			farmLosses: Math.max(0, r.farmLosses ?? 0),
+			restrictedFarmLosses: Math.max(0, r.restrictedFarmLosses ?? 0),
+			listedPersonalPropertyLosses: r.yearIndex > 7 ? 0 : listedPersonalPropertyLosses
+		};
+	});
+	return {
+		rows: computed,
+		totals: {
+			farmLosses: computed.reduce((s, r) => s + r.farmLosses, 0),
+			restrictedFarmLosses: computed.reduce((s, r) => s + r.restrictedFarmLosses, 0),
+			listedPersonalPropertyLosses: computed.reduce((s, r) => s + r.listedPersonalPropertyLosses, 0)
+		},
+		issues
+	};
+}
+//#endregion
 //#region src/t2/certification/fixtures.ts
 const T2_CERTIFICATION_FIXTURES = [
 	{
@@ -5051,15 +7900,18 @@ function computeFederalT2(input) {
 	const rates = input.rates ?? resolveCorpTaxRates(taxYear, book);
 	const prorationFactor = shortYearProrationFactor(input.periodStart, input.periodEnd);
 	const cca = input.ccaClasses?.length ? computeCcaSchedule(input.ccaClasses, resolveCcaRates(taxYear), prorationFactor) : void 0;
+	const class13 = input.class13 ? computeClass13(input.class13) : void 0;
+	const class14 = input.class14 ? computeClass14(input.class14) : void 0;
 	const capitalGains = input.capitalDispositions?.length ? computeSchedule6(input.capitalDispositions, rates.CAPITAL_GAINS_INCLUSION_RATE) : void 0;
 	const schedule1Additions = [...input.schedule1Additions ?? []];
 	const schedule1Deductions = [...input.schedule1Deductions ?? []];
+	const totalCcaDeduction = (cca?.totalCca ?? 0) + (class13?.ccaClaimed ?? 0) + (class14?.ccaClaimed ?? 0);
+	if (totalCcaDeduction > 0) schedule1Deductions.push({
+		line: "403",
+		label: "Capital cost allowance from Schedule 8",
+		amount: totalCcaDeduction
+	});
 	if (cca) {
-		if (cca.totalCca > 0) schedule1Deductions.push({
-			line: "403",
-			label: "Capital cost allowance from Schedule 8",
-			amount: cca.totalCca
-		});
 		if (cca.totalTerminalLoss > 0) schedule1Deductions.push({
 			line: "404",
 			label: "Terminal loss from Schedule 8",
@@ -5259,6 +8111,8 @@ function computeFederalT2(input) {
 		...donations ? { donations } : {},
 		...lossCarryback ? { lossCarryback } : {},
 		...cca ? { cca } : {},
+		...class13 ? { class13 } : {},
+		...class14 ? { class14 } : {},
 		...capitalGains ? { capitalGains } : {},
 		...provincial ? { provincial } : {},
 		...provincialAllocation ? { provincialAllocation } : {},
@@ -6389,4 +9243,4 @@ function computeMpDeduction(input, rates = MP_RATES_2024) {
 	};
 }
 //#endregion
-export { computeProvincialAllocation as $, at1TaxPayableDeductions as $n, CEC_DEDUCTION_RATE as $t, runConformance as A, reconcileAlbertaNetIncome as An, computeAlbertaSbd as Ar, computeCcpcActiveBusinessTax as At, computeGrip as B, formatRsiText as Bn, resolveRates as Br, AT1_DONATION_GAIN_RATE as Bt, computeQuebecTax as C, albertaCcaScheduleAdjustments as Cn, schedule18Values as Cr, blendProvinceRateTable as Ct, T2_LINE_META as D, albertaReserveDifference as Dn, schedule29Values as Dr, dividendsDeductibleS112 as Dt, resolveQuebecTaxRates as E, albertaRecaptureDifference as En, schedule21Values as Er, computeTaxableIncome as Et, normalizeSchedule88 as F, RSI_NEGATIVE_PREFIX as Fn, resolveAlbertaTaxRates as Fr, CORP_TAX_RATE_BOOK as Ft, ITC_RECAPTURE_PERIOD_YEARS as G, AT1_CRITICAL_MANDATORY_FIELDS as Gn, SECTION_34_2_GROSS_UP as Gt, LARGE_CORPORATION_THRESHOLD as H, renderRsiHeader as Hn, computeDonationMaximum as Ht, computeSchedule55 as I, RSI_WORD_GAP as In, earliestRateYear as Ir, resolveCorpTaxRates as It, allocateEvenly as J, At1TaxPayableMismatchError as Jn, AT1_RESERVE_LINES as Jt, computeItcRecapture as K, At1CriticalFieldMissingError as Kn, computeAlbertaSchedule18 as Kt, LRIP_INVESTMENT_CORPORATION_MULTIPLE as L, RsiLineItemError as Ln, extendRateBook as Lr, T2_CERTIFICATION_FIXTURES as Lt, computeFederalT2 as M, computeLossCarryback as Mn, computeDayWeightedGeneralTax as Mr, computeBusinessLimit as Mt, computeSchedule101 as N, RSI_COLUMN_GAP as Nn, AB_TAX_2024 as Nr, computeSBD as Nt, foldT2Lines as O, albertaTerminalLossDifference as On, schedule2Values as Or, netCapitalLossApplied as Ot, SCHEDULE_88_MAX_URLS as P, RSI_DELIMITER as Pn, AB_TAX_RATE_BOOK as Pr, CORP_TAX_2024 as Pt, computeSchedule6 as Q, assertCriticalFields as Qn, computeAlbertaSchedule16 as Qt, LRIP_INVESTMENT_INCOME_FACTOR as R, formatRsiAmount as Rn, hasExactRateYear as Rr, computeLossSchedule as Rt, computeQuebecAllocationFactor as S, albertaCcaDifference as Sn, schedule17Values as Sr, resolveProvinceRates as St, QC_TAX_RATE_BOOK as T, albertaDispositionAdjustments as Tn, schedule20Values as Tr, charitableDonationsDeduction as Tt, computeTaxableCapital as U, renderRsiLineItem as Un, computeSchedule20 as Ut, computeSchedule43 as V, renderAt1Rsi as Vn, AT1_DONATION_INCOME_RATE as Vt, computeSchedule31 as W, renderAt1NetFile as Wn, AT1_DISPOSITION_CATEGORIES as Wt, computeSchedule21 as X, assertAt1MandatoryComplete as Xn, computeAlbertaSchedule17 as Xt, computeBusinessLimitAllocation as Y, albertaBalanceUnpaid as Yn, AT1_RESERVE_TOTAL_LINES as Yt, computeSchedule13 as Z, assertAt1TaxPayableReconciles as Zn, assistanceFrom as Zt, renderT2DraftReturn as _, CCA_RATE_BOOK as _n, schedule10Values as _r, EIFEL_EFFECTIVE_FROM as _t, PART_VI_1_DEDUCTION_BANDS as a, computeCcaClass as an, allocateIegExpenditureLimit as ar, computeSchedule2 as at, co17Engine as b, albertaAbilDifference as bn, schedule13Values as br, PROVINCE_RATE_BOOK as bt, EIFEL_FIRST_YEAR_START as c, CLASS_14_1_MINIMUM_DEDUCTION as cn, IEG_2024 as cr, assertSchedule1Fileable as ct, EIFEL_TRANSITIONAL_RATIO as d, MIN_LEASEHOLD_PERIODS as dn, computeIegReductionFactor as dr, deferredIncomeTaxProvisionAddBack as dt, CEC_INCLUSION_RATE as en, at1YesNo as er, computeSchedule5 as et, computeEifelLimitation as f, computeClass13 as fn, SINGLE_JURISDICTION_ALBERTA_FACTOR as fr, findSchedule1LineDefects as ft, computeT2Settlement as g, CCA_DECLINING_BALANCE_RATES_2024 as gn, at1LineItemId as gr, terminalLossDeduction as gt, computeAdjustedTaxableIncome as h, leaseholdPeriods as hn, AT1_SCHEDULES_WITH_BUILDERS as hr, recaptureAddBack as ht, computeMpDeduction as i, UnsupportedCcaClassError as in, allocateIegEvenly as ir, computePart4Rdtoh as it, runConformanceSuite as j, LossCarrybackError as jn, AB_GENERAL_RATE_BANDS as jr, computePartITax as jt, formatConformanceReport as k, computeSchedule12 as kn, computeAlbertaTax as kr, nonCapitalLossApplied as kt, EIFEL_STANDARD_RATIO as l, CLASS_14_1_TRANSITIONAL_RATE as ln, computeIeg as lr, ccaDeduction as lt, FOREIGN_TAX_CREDIT_GROSS_UP as m, computeClass141AdditionalAllowance as mn, AT1_SCHEDULES_WITHOUT_BUILDERS as mr, mealsAndEntertainmentAddBack as mt, MP_GROSS_REVENUE_THRESHOLD as n, computeAlbertaSchedule14 as nn, at1Engine as nr, PART_IV_RATE as nt, computePartVI1Deduction as o, computeCcaSchedule as on, computeIegAgreement as or, Schedule1NotFileableError as ot, ratioOfPermissibleExpenses as p, computeClass14 as pn, computeAllocationFactor as pr, incomeTaxProvisionAddBack as pt, computeZetm as q, At1MandatoryFieldMissingError as qn, AT1_RESERVE_KINDS as qt, MP_RATES_2024 as r, computeAlbertaSchedule13 as rn, computeAlbertaReturn as rr, REFUNDABLE_PART_I_RATE as rt, partVI1DeductionMultiple as s, computeSchedule8 as sn, computeIegGroupFigures as sr, amortizationAddBack as st, MP_EXCLUDED_ACTIVITIES as t, cecScheduleAppliesToTaxYear as tn, xmlEscape as tr, computeSchedule4Losses as tt, EIFEL_STANDARD_RATIO_FROM as u, MAX_LEASEHOLD_PERIODS as un, computeIegBaseAmount as ur, computeSchedule1 as ut, t2Engine as v, isDecliningBalanceClass as vn, schedule12LossDeductions as vr, assessEifel as vt, QC_TAX_2024 as w, albertaCurrentYearLoss as wn, schedule1Values as wr, dayWeightedRate as wt, computeQuebecReturn as x, albertaCapitalGainDifference as xn, schedule16Values as xr, isSchedule5Province as xt, renderCo17DraftReturn as y, resolveCcaRates as yn, schedule12Values as yr, PROVINCE_RATES_2024 as yt, computeSchedule54 as z, formatRsiDate as zn, latestRateYear as zr, computeLossContinuity as zt };
+export { computeProvincialAllocation as $, albertaBalanceUnpaid as $n, schedule4Values as $r, AT1_RESERVE_TOTAL_LINES as $t, runConformance as A, hasExactRateYear as Ai, albertaRecaptureDifference as An, computeFedeRegular as Ar, computeCcpcActiveBusinessTax as At, computeGrip as B, RSI_WORD_GAP as Bn, allocateSchedule9ExpenditureLimit as Br, computeLossSchedule as Bt, computeQuebecTax as C, AB_GENERAL_RATE_BANDS as Ci, resolveCcaRates as Cn, computeCeeRegular as Cr, blendProvinceRateTable as Ct, T2_LINE_META as D, resolveAlbertaTaxRates as Di, albertaCcaScheduleAdjustments as Dn, computeCmedb as Dr, dividendsDeductibleS112 as Dt, resolveQuebecTaxRates as E, AB_TAX_RATE_BOOK as Ei, albertaCcaDifference as En, computeCfreSuccessor as Er, computeTaxableIncome as Et, normalizeSchedule88 as F, LossCarrybackError as Fn, computeSchedule11 as Fr, CORP_TAX_RATE_BOOK as Ft, ITC_RECAPTURE_PERIOD_YEARS as G, renderAt1Rsi as Gn, schedule8Values as Gr, AT1_DONATION_INCOME_RATE as Gt, LARGE_CORPORATION_THRESHOLD as H, formatRsiAmount as Hn, computeSchedule9MaximumExpenditureLimit as Hr, computeLimitedPartnershipLossRow as Ht, computeSchedule55 as I, computeLossCarryback as In, schedule11Values as Ir, resolveCorpTaxRates as It, allocateEvenly as J, renderAt1NetFile as Jn, computeAlbertaSchedule6 as Jr, AT1_DISPOSITION_CATEGORIES as Jt, computeItcRecapture as K, renderRsiHeader as Kn, computeAlbertaSchedule7 as Kr, computeDonationMaximum as Kt, LRIP_INVESTMENT_CORPORATION_MULTIPLE as L, RSI_COLUMN_GAP as Ln, ALBERTA_SRED_EXPENDITURE_CUTOFF as Lr, T2_CERTIFICATION_FIXTURES as Lt, computeFederalT2 as M, resolveRates as Mi, albertaTerminalLossDifference as Mn, computeSfedeCountryRegular as Mr, computeBusinessLimit as Mt, computeSchedule101 as N, computeSchedule12 as Nn, computeSfedeCountrySuccessor as Nr, computeSBD as Nt, foldT2Lines as O, earliestRateYear as Oi, albertaCurrentYearLoss as On, computeEdaRegular as Or, netCapitalLossApplied as Ot, SCHEDULE_88_MAX_URLS as P, reconcileAlbertaNetIncome as Pn, schedule15Values as Pr, CORP_TAX_2024 as Pt, computeSchedule6 as Q, At1TaxPayableMismatchError as Qn, computeSchedule4 as Qr, AT1_RESERVE_LINES as Qt, LRIP_INVESTMENT_INCOME_FACTOR as R, RSI_DELIMITER as Rn, ALBERTA_SRED_PROGRAM_START as Rr, computeNonCapitalLossByYearOfOrigin as Rt, computeQuebecAllocationFactor as S, computeAlbertaSbd as Si, isDecliningBalanceClass as Sn, computeCdeSuccessor as Sr, resolveProvinceRates as St, QC_TAX_RATE_BOOK as T, AB_TAX_2024 as Ti, albertaCapitalGainDifference as Tn, computeCfreRegular as Tr, charitableDonationsDeduction as Tt, computeTaxableCapital as U, formatRsiDate as Un, schedule9Values as Ur, computeLimitedPartnershipLosses as Ut, computeSchedule43 as V, RsiLineItemError as Vn, computeAlbertaSchedule9 as Vr, computeLossContinuity as Vt, computeSchedule31 as W, formatRsiText as Wn, computeSchedule8$1 as Wr, AT1_DONATION_GAIN_RATE as Wt, computeSchedule21 as X, At1CriticalFieldMissingError as Xn, computeAlbertaSchedule5 as Xr, computeAlbertaSchedule18 as Xt, computeBusinessLimitAllocation as Y, AT1_CRITICAL_MANDATORY_FIELDS as Yn, schedule6Values as Yr, SECTION_34_2_GROSS_UP as Yt, computeSchedule13 as Z, At1MandatoryFieldMissingError as Zn, schedule5Values as Zr, AT1_RESERVE_KINDS as Zt, renderT2DraftReturn as _, schedule21Values as _i, computeClass14 as _n, iegT661SourceLine as _r, EIFEL_EFFECTIVE_FROM as _t, PART_VI_1_DEDUCTION_BANDS as a, AT1_SCHEDULES_WITHOUT_BUILDERS as ai, cecScheduleAppliesToTaxYear as an, xmlEscape as ar, computeSchedule2 as at, co17Engine as b, schedule4970Values as bi, CCA_DECLINING_BALANCE_RATES_2024 as bn, computeCcogpeSuccessor as br, PROVINCE_RATE_BOOK as bt, EIFEL_FIRST_YEAR_START as c, schedule10Values as ci, UnsupportedCcaClassError as cn, allocateIegEvenly as cr, assertSchedule1Fileable as ct, EIFEL_TRANSITIONAL_RATIO as d, schedule13Values as di, computeSchedule8 as dn, computeIegGroupFigures as dr, deferredIncomeTaxProvisionAddBack as dt, computeSchedule3 as ei, computeAlbertaSchedule17 as en, assertAt1MandatoryComplete as er, computeSchedule5 as et, computeEifelLimitation as f, schedule16Values as fi, CLASS_14_1_MINIMUM_DEDUCTION as fn, IEG_2024 as fr, findSchedule1LineDefects as ft, computeT2Settlement as g, schedule20Values as gi, computeClass13 as gn, computeIegEligibleExpenditures as gr, terminalLossDeduction as gt, computeAdjustedTaxableIncome as h, schedule1Values as hi, MIN_LEASEHOLD_PERIODS as hn, computeIegReductionFactor as hr, recaptureAddBack as ht, computeMpDeduction as i, computeAt4970 as ii, CEC_INCLUSION_RATE as in, at1YesNo as ir, computePart4Rdtoh as it, runConformanceSuite as j, latestRateYear as ji, albertaReserveDifference as jn, computeFedeSuccessor as jr, computePartITax as jt, formatConformanceReport as k, extendRateBook as ki, albertaDispositionAdjustments as kn, computeEdaSuccessor as kr, nonCapitalLossApplied as kt, EIFEL_STANDARD_RATIO as l, schedule12LossDeductions as li, computeCcaClass as ln, allocateIegExpenditureLimit as lr, ccaDeduction as lt, FOREIGN_TAX_CREDIT_GROSS_UP as m, schedule18Values as mi, MAX_LEASEHOLD_PERIODS as mn, computeIegBaseAmount as mr, mealsAndEntertainmentAddBack as mt, MP_GROSS_REVENUE_THRESHOLD as n, SINGLE_JURISDICTION_ALBERTA_FACTOR as ni, computeAlbertaSchedule16 as nn, assertCriticalFields as nr, PART_IV_RATE as nt, computePartVI1Deduction as o, AT1_SCHEDULES_WITH_BUILDERS as oi, computeAlbertaSchedule14 as on, at1Engine as or, Schedule1NotFileableError as ot, ratioOfPermissibleExpenses as p, schedule17Values as pi, CLASS_14_1_TRANSITIONAL_RATE as pn, computeIeg as pr, incomeTaxProvisionAddBack as pt, computeZetm as q, renderRsiLineItem as qn, schedule7Values as qr, computeSchedule20 as qt, MP_RATES_2024 as r, computeAllocationFactor as ri, CEC_DEDUCTION_RATE as rn, at1TaxPayableDeductions as rr, REFUNDABLE_PART_I_RATE as rt, partVI1DeductionMultiple as s, at1LineItemId as si, computeAlbertaSchedule13 as sn, computeAlbertaReturn as sr, amortizationAddBack as st, MP_EXCLUDED_ACTIVITIES as t, schedule3Values as ti, assistanceFrom as tn, assertAt1TaxPayableReconciles as tr, computeSchedule4Losses as tt, EIFEL_STANDARD_RATIO_FROM as u, schedule12Values as ui, computeCcaSchedule as un, computeIegAgreement as ur, computeSchedule1 as ut, t2Engine as v, schedule29Values as vi, computeClass141AdditionalAllowance as vn, computeAlbertaSchedule15 as vr, assessEifel as vt, QC_TAX_2024 as w, computeDayWeightedGeneralTax as wi, albertaAbilDifference as wn, computeCeeSuccessor as wr, dayWeightedRate as wt, computeQuebecReturn as x, computeAlbertaTax as xi, CCA_RATE_BOOK as xn, computeCdeRegular as xr, isSchedule5Province as xt, renderCo17DraftReturn as y, schedule2Values as yi, leaseholdPeriods as yn, computeCcogpeRegular as yr, PROVINCE_RATES_2024 as yt, computeSchedule54 as z, RSI_NEGATIVE_PREFIX as zn, ALBERTA_SRED_TAX_CREDIT_RATE as zr, computeOtherLossByYearOfOrigin as zt };