@classytic/ca-tax 0.0.1 → 0.0.5

package/dist/t2.mjs

@@ -262,7 +262,8 @@ const AT1_SCHEDULES_WITH_BUILDERS = Object.freeze([
 	"018",
 	"020",
 	"021",
-	"029"
+	"029",
+	"4970"
 ]);
 /**
 * Schedules the engine computes but cannot yet file.
@@ -431,21 +432,182 @@ function schedule18Values(result) {
 		values
 	};
 }
-function schedule29Values(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
+*        INSTEAD of 125, never alongside it.
+*   125  12% of the associated path's allocated allowed amount — filed
+*        instead of 112 when `result.enhancedRateBasis === 'associated'`.
+*   126  taxable capital the line-128 factor was computed from
+*   128  the taxable-capital reduction factor, 0 to 1
+*   130  (110 + 112-or-125) × 128 — the credit before recapture
+*   132  recapture, only where the caller supplied one
+*   134  NET IEG — the figure AT1 page 2, line 129 carries forward
+*
+* Page 3 — the Agreement Among Associated Corporations, filed only when the
+* group agreed one (`agreement`, from `computeIegAgreement` in
+* `schedule29-ieg-group.ts`); omitted entirely for a non-associated claim:
+*   200/202/204/206/208  the longest-year member's CAN, that member's own
+*        tax year begin/end, days in that year, and the resulting $4M-pool
+*        maximum for the group
+*   Per member, occurrence incrementing in the order given (claimant first):
+*     220 Federal Business Number, 230 Alberta CAN, 235 current taxation
+*     year end, 240 allocated expenditure limit, 245 current-year
+*     expenditures, 250 prior year 1, 260 prior year 2, 265 taxable capital
+*     (prior year), 267 individual maximum allowed amount, 268 allocated
+*     allowed amount. The form has NO line for the member's NAME — 220 is
+*     the Federal Business Number, confirmed by re-rendering page 3 of the
+*     live form (a prior version of this function filed `name` at 220,
+*     which put free text in a box the form defines as a 9-10 digit account
+*     number; `name` is not transmitted at all, matching the form).
+*   270/275/280/290/300  Σ 240/245/250/260/265 across every member
+*   310  the group Allowed Amount — 275 − (280 + 290) / 2
+*   320  Σ 268
+*   325  the claiming corporation's own 268 — this is what feeds line 125
+*        above (`associatedAllowedAmount` in `computeIeg`'s input)
+*
+* 128 is a RATIO, not a dollar figure — formatted to 6 decimal places, the
+* same precision `schedule2.ts`'s Reg 402 allocation factor uses. That
+* precision is this codebase's own convention, not something confirmed
+* against TRA's certification validator for THIS field; verify before relying
+* on it for a corporation whose taxable capital sits inside the $10M–$50M
+* 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, eligible, primaryFieldCode) {
 	const values = [];
-	const put = (fieldId, value) => values.push({
-		lineItemId: at1LineItemId("029", fieldId),
+	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("112", result.creditAtEnhancedRate);
-	put("128", result.incrementalExpenditures);
+	put(result.enhancedRateBasis === "associated" ? "125" : "112", result.creditAtEnhancedRate);
+	put("126", result.taxableCapital);
+	put("128", result.reductionFactor.toFixed(6));
+	put("130", result.grossIeg);
+	if (result.recapture > 0) put("132", result.recapture);
+	put("134", result.ieg);
+	if (agreement) {
+		put("200", agreement.longestYearCan);
+		put("202", agreement.longestYearBegin);
+		put("204", agreement.longestYearEnd);
+		put("206", agreement.daysInLongestYear);
+		put("208", agreement.maximumExpenditureLimit);
+		agreement.members.forEach((m, i) => {
+			const n = i + 1;
+			if (m.federalBusinessNumber !== void 0) put("220", m.federalBusinessNumber, n);
+			if (m.albertaCan !== void 0) put("230", m.albertaCan, n);
+			if (m.currentTaxationYearEnd !== void 0) put("235", m.currentTaxationYearEnd, n);
+			put("240", m.allocatedExpenditureLimit, n);
+			put("245", m.currentYearExpenditures, n);
+			put("250", m.priorYear1, n);
+			put("260", m.priorYear2, n);
+			put("265", m.taxableCapitalPriorYear, n);
+			put("267", m.individualMaximumAllowedAmount, n);
+			put("268", m.allocatedAllowedAmount, n);
+		});
+		put("270", agreement.totalAllocatedLimit);
+		put("275", agreement.totalCurrentYearExpenditures);
+		put("280", agreement.totalPriorYear1);
+		put("290", agreement.totalPriorYear2);
+		put("300", agreement.totalTaxableCapitalPriorYear);
+		put("310", agreement.groupAllowedAmount);
+		put("320", agreement.totalAllocatedAllowedAmount);
+		put("325", agreement.claimantAllocatedAllowedAmount);
+	}
 	return {
 		scheduleId: "029",
 		values
 	};
 }
 /**
+* 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:
 *
@@ -744,6 +906,37 @@ function schedule16Values(result) {
 	};
 }
 //#endregion
+//#region src/t2/at1/schedules/at4970-ieg-projects.ts
+const nn$25 = (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$25(p.albertaPortion),
+		otherPortion: nn$25(p.otherPortion),
+		salariesAndWages: nn$25(p.salariesAndWages),
+		federalProxyAmount: nn$25(p.federalProxyAmount),
+		albertaProxyAmount: nn$25(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$25(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) {
@@ -764,40 +957,182 @@ function computeAllocationFactor(input) {
 	return round6(factor);
 }
 //#endregion
+//#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
 /**
 * AT1 Schedule 29 — Alberta Innovation Employment Grant (IEG). AT1 line 129.
 *
 * A refundable grant on eligible R&D (SR&ED) carried out in Alberta:
-*   - 8%  base rate on eligible expenditures up to the base level of spending
-*   - 20% enhanced rate on the INCREMENT above the base level
-*     (equivalently: 8% on everything + an extra 12% on the increment)
-*   base level = average of the prior two years' eligible Alberta expenditures
-*   (associated group aggregated — pass all members' figures)
-*
-* Eligible expenditures are capped at a $4,000,000 annual limit, reduced on a
-* straight-line taxable-capital grind ($10M → $50M), shared across an associated
-* group. Pure, integer whole dollars.
-*
-* NOT modelled here (a later associated-group layer): allocation of the shared
-* $4M limit across associated corporations (Test Case 3's A/B/C/D grind). This
-* computes one corporation's grant given its eligible expenditures, its (group)
-* base amount, and its allocated expenditure limit.
+*   - line 110:  8% of the CAPPED eligible expenditures (the full amount, not
+*                just the portion below base)
+*   - line 112 (non-associated): 12% of the increment ABOVE the base level of
+*                spending — base level = average of the prior two years'
+*                eligible Alberta expenditures (associated group aggregated —
+*                pass all members' figures)
+*   - line 125 (associated, via a filed agreement): 12% of the LESSER of the
+*                expenditure limit and the agreement's allocated allowed
+*                amount — see `computeIegAgreement` in `schedule29-ieg-group.ts`.
+*                A genuinely different formula, not a variant of 112's — it does
+*                not reference actual spending at all once the agreement exists.
+*
+* Eligible expenditures are capped at a $4,000,000 annual limit (shared across an
+* associated group; NOT reduced by taxable capital — see below). Pure, integer
+* whole dollars.
+*
+* ── The taxable-capital grind applies to the CREDIT, not the limit ──────────
+*
+* A prior version of this module reduced the $4,000,000 expenditure limit itself
+* on a straight-line taxable-capital grind ($10M → $50M) — modelled on the
+* federal SBD grind's shape, but wrong for this form. Rendering the live,
+* TRA-certified Schedule 29 (`research/sources/tra-forms/pdf/AT1SCH29-*.pdf`,
+* Rev. 2026-06 — cross-checked against AuraTax's live rendering of the same
+* schedule, `research/validation/auratax/2026-08-25-at1-schedule1-royalty/`)
+* shows the grind lives at **line 128**, a REDUCTION FACTOR from 0 to 1:
+*
+*   line 128 = (($40,000,000 − (line 126 − $10,000,000)) / $40,000,000)
+*              (enter 1 if taxable capital ≤ $10,000,000)
+*   line 130 = (line 110 + (line 112 or line 125)) × line 128
+*
+* i.e. the credit is computed in FULL against the unreduced $4M limit, and ONLY
+* THEN scaled by the taxable-capital factor — not the limit ground down first
+* and the credit computed against the smaller number. The two are NOT
+* equivalent except at the band's endpoints (TC ≤ $10M ⇒ both give the full
+* credit; TC ≥ $50M ⇒ both give nil).
+*
+* ── One thing not yet resolved, and worth raising with TRA directly ─────────
+*
+* The AT1 jacket's OWN business-rule table (`research/sources/tra-spec/
+* AT1-Chapter3-2025.2-full.txt`, version 2025.2 / August 2025 — ten months
+* OLDER than the Schedule 29 PDF above) states jacket line 129 as
+* `(029110 + 029112 X 029128) minus 029132` — multiplying ONLY line 112 by the
+* factor, not the sum of 110 and 112. That contradicts Schedule 29's own
+* printed caption, which the certified oracle (AuraTax) also renders as
+* "sum then multiply". This module follows the newer, doubly-corroborated
+* Schedule 29 form. Confirm with TRA before relying on this for an associated
+* corporation with taxable capital between $10M and $50M — the disagreement
+* changes the filed dollar figure.
+*
+* ── The formal Agreement (line 125) ──────────────────────────────────────────
+*
+* TRA's Test Case 3 (four associated corporations, `research/sources/
+* tra-test-cases/Alberta Test Case 3 - Fall 2025.txt`) is the associated path:
+* pass `associatedAllowedAmount` (line 325 of `computeIegAgreement`'s result)
+* and this function uses line 125's formula instead of line 112's. Day-of-year
+* proration of the $4M pool for a short or long taxation year (lines 104/108/
+* 206/208) is modelled in `computeIegAgreement`, not here — this function
+* takes the already-allocated `expenditureLimit` as an input.
 */
 const IEG_2024 = Object.freeze({
 	BASE_RATE: .08,
-	ENHANCED_RATE: .2,
+	ENHANCED_RATE: .12,
 	MAX_EXPENDITURE: 4e6,
 	TC_GRIND_LOWER: 1e7,
 	TC_GRIND_UPPER: 5e7,
 	PRIOR_YEARS: 2
 });
-/** The eligible-expenditure limit ($4M) reduced by the taxable-capital grind. */
-function computeIegExpenditureLimit(taxableCapital, sharedLimit = IEG_2024.MAX_EXPENDITURE) {
-	const { TC_GRIND_LOWER, TC_GRIND_UPPER } = IEG_2024;
-	const tcInBand = Math.max(0, Math.min(Math.max(0, taxableCapital), TC_GRIND_UPPER) - TC_GRIND_LOWER);
-	const reduction = Math.round(sharedLimit * tcInBand / (TC_GRIND_UPPER - TC_GRIND_LOWER));
-	return Math.max(0, sharedLimit - reduction);
+/**
+* The line-128 reduction factor: 1 at or below $10M taxable capital, straight-
+* line down to 0 at $50M. Multiplies the COMBINED base + enhanced credit at
+* line 130 — it does not touch the $4,000,000 expenditure limit.
+*/
+function computeIegReductionFactor(taxableCapital, lower = IEG_2024.TC_GRIND_LOWER, upper = IEG_2024.TC_GRIND_UPPER) {
+	const tc = Math.max(0, taxableCapital);
+	if (tc <= lower) return 1;
+	const band = upper - lower;
+	return Math.max(0, Math.min(1, (band - (tc - lower)) / band));
 }
 /**
 * Base level of spending = average of the prior years' eligible Alberta
@@ -813,16 +1148,26 @@ function computeIeg(input) {
 	const limit = input.expenditureLimit ?? IEG_2024.MAX_EXPENDITURE;
 	const cappedExpenditures = Math.max(0, Math.min(input.eligibleExpenditures, limit));
 	const incrementalExpenditures = Math.max(0, cappedExpenditures - input.baseAmount);
-	const baseRatePortion = cappedExpenditures - incrementalExpenditures;
-	const creditAtBaseRate = Math.round(IEG_2024.BASE_RATE * baseRatePortion);
-	const creditAtEnhancedRate = Math.round(IEG_2024.ENHANCED_RATE * incrementalExpenditures);
+	const creditAtBaseRate = Math.round(IEG_2024.BASE_RATE * cappedExpenditures);
+	const enhancedRateBasis = input.associatedAllowedAmount !== void 0 ? "associated" : "non-associated";
+	const creditAtEnhancedRate = enhancedRateBasis === "associated" ? Math.round(IEG_2024.ENHANCED_RATE * Math.min(limit, Math.max(0, input.associatedAllowedAmount ?? 0))) : Math.round(IEG_2024.ENHANCED_RATE * incrementalExpenditures);
+	const taxableCapital = Math.max(0, input.taxableCapital ?? 0);
+	const reductionFactor = computeIegReductionFactor(taxableCapital);
+	const grossIeg = Math.round((creditAtBaseRate + creditAtEnhancedRate) * reductionFactor);
+	const recapture = Math.max(0, Math.round(input.recapture ?? 0));
+	const ieg = Math.max(0, grossIeg - recapture);
 	return {
 		cappedExpenditures,
 		baseAmount: input.baseAmount,
 		incrementalExpenditures,
 		creditAtBaseRate,
 		creditAtEnhancedRate,
-		ieg: creditAtBaseRate + creditAtEnhancedRate
+		enhancedRateBasis,
+		taxableCapital,
+		reductionFactor,
+		grossIeg,
+		recapture,
+		ieg
 	};
 }
 //#endregion
@@ -831,20 +1176,27 @@ function computeIeg(input) {
 * AT1 Schedule 29 — the ASSOCIATED-GROUP layer for the Innovation Employment
 * Grant.
 *
-* `computeIeg` grants one corporation its IEG given three figures: its own
-* eligible Alberta expenditures, its base level of spending, and its allocated
-* expenditure limit. Two of those three are **group** figures, and this module
-* derives them.
+* `computeIeg` grants one corporation its IEG given its own eligible Alberta
+* expenditures, its base level of spending, its allocated expenditure limit, and
+* the group's taxable capital. The base level of spending is a **group** figure,
+* and this module derives it (along with the group's total taxable capital, for
+* the line-128 reduction factor `computeIeg` applies).
 *
 * ── Why a group layer is not optional ───────────────────────────────────────
 *
-* A single corporation with $10M of taxable capital sees no grind at all and gets
-* the whole $4,000,000 limit. The same corporation in a group whose members total
-* $20M sees the limit ground to $3,000,000. Computing a member in isolation
-* therefore **overstates the limit**, and a group that also has prior-year
-* spending elsewhere gets an **understated base**, which overstates the 20%
-* increment. Both errors run in the taxpayer's favour, which is the direction that
-* fails an audit.
+* A group that has prior-year spending elsewhere gets an **understated base**
+* when a member is computed alone, which overstates the 12% increment. And the
+* taxable-capital reduction factor (line 128, see `schedule29-ieg.ts`) is driven
+* by the WHOLE group's taxable capital, not one member's — a member with $10M of
+* its own taxable capital sees no grind in isolation, but the group's combined
+* capital may put it well into the $10M–$50M band. Both errors run in the
+* taxpayer's favour, which is the direction that fails an audit.
+*
+* The $4,000,000 expenditure limit itself is NOT reduced here — see
+* `schedule29-ieg.ts` for why the taxable-capital grind lives at line 128, not
+* the limit. `groupExpenditureLimit` below is the flat $4M shared pool, prorated
+* for a short or long taxation year by the caller if needed (day-of-year
+* proration is not modelled).
 *
 * ── Which year's figures ────────────────────────────────────────────────────
 *
@@ -871,6 +1223,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));
@@ -897,7 +1280,7 @@ function computeIegGroupFigures(members, priorYears = IEG_2024.PRIOR_YEARS) {
 	const totalPriorYearExpenditures = detail.reduce((s, m) => s + m.priorYearTotal, 0);
 	return {
 		groupTaxableCapital,
-		groupExpenditureLimit: computeIegExpenditureLimit(groupTaxableCapital),
+		groupExpenditureLimit: IEG_2024.MAX_EXPENDITURE,
 		totalPriorYearExpenditures,
 		groupBaseAmount: priorYears > 0 ? Math.round(totalPriorYearExpenditures / priorYears) : 0,
 		members: detail,
@@ -952,6 +1335,74 @@ function allocateIegEvenly(groupExpenditureLimit, names) {
 		allocated: i === 0 ? each + remainder : each
 	})));
 }
+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 = currentYearExpenditures - base;
+	const days = Math.max(0, Math.min(m.daysInTaxYear ?? 365, 366));
+	const dayProratedLimit = Math.round(4e6 * (days / 365));
+	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 } : {},
+		...m.albertaCan !== void 0 ? { albertaCan: m.albertaCan } : {},
+		...m.currentTaxationYearEnd !== void 0 ? { currentTaxationYearEnd: m.currentTaxationYearEnd } : {},
+		allocatedExpenditureLimit,
+		currentYearExpenditures,
+		priorYear1,
+		priorYear2,
+		taxableCapitalPriorYear: nn$23(m.taxableCapitalPriorYear),
+		hasAlbertaPermanentEstablishment,
+		individualMaximumAllowedAmount,
+		allocatedAllowedAmount
+	};
+}
+/**
+* The formal Agreement Among Associated Corporations. The FIRST entry in
+* `input.members` must be the claiming corporation — its own line 268 becomes
+* line 325, which is what actually reaches `computeIeg`.
+*/
+function computeIegAgreement(input) {
+	const issues = [];
+	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((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);
+	const totalPriorYear1 = sum((m) => m.priorYear1);
+	const totalPriorYear2 = sum((m) => m.priorYear2);
+	const totalTaxableCapitalPriorYear = sum((m) => m.taxableCapitalPriorYear);
+	const totalAllocatedAllowedAmount = sum((m) => m.allocatedAllowedAmount);
+	const groupAllowedAmount = Math.round(totalCurrentYearExpenditures - (totalPriorYear1 + totalPriorYear2) / 2);
+	if (totalAllocatedLimit > maximumExpenditureLimit) issues.push(`Alberta Schedule 29 Agreement: the group allocated ${totalAllocatedLimit} of a maximum expenditure limit of ${maximumExpenditureLimit} (line 270 exceeds line 208). The group must agree a valid split.`);
+	if (totalAllocatedAllowedAmount > groupAllowedAmount) issues.push(`Alberta Schedule 29 Agreement: the group's allocated allowed amounts total ${totalAllocatedAllowedAmount}, exceeding the group Allowed Amount of ${groupAllowedAmount} (line 320 exceeds line 310). The group must agree a valid split.`);
+	return {
+		longestYearCan: input.longestYearCan,
+		longestYearBegin: input.longestYearBegin,
+		longestYearEnd: input.longestYearEnd,
+		daysInLongestYear: days,
+		maximumExpenditureLimit,
+		members,
+		totalAllocatedLimit,
+		totalCurrentYearExpenditures,
+		totalPriorYear1,
+		totalPriorYear2,
+		totalTaxableCapitalPriorYear,
+		groupAllowedAmount,
+		totalAllocatedAllowedAmount,
+		claimantAllocatedAllowedAmount: members[0]?.allocatedAllowedAmount ?? 0,
+		issues
+	};
+}
 //#endregion
 //#region src/t2/at1/engine/alberta-return.ts
 /**
@@ -982,21 +1433,49 @@ function computeAlbertaReturn(input) {
 	}, rates);
 	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);
-		ieg = computeIeg({
-			eligibleExpenditures: input.ieg.eligibleExpenditures,
-			baseAmount: iegGroup.groupBaseAmount,
-			expenditureLimit: allocation.allocations[0]?.allocated ?? 0
-		});
+	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 } : {}
+			});
+		}
 	}
 	const schedulePayloads = [];
 	const sched = input.schedules;
@@ -1010,13 +1489,16 @@ function computeAlbertaReturn(input) {
 	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));
+	if (ieg) schedulePayloads.push(schedule29Values(ieg, iegAgreement, iegEligibleExpenditures, input.ieg?.primaryFieldCode));
+	if (at4970) schedulePayloads.push(schedule4970Values(at4970));
 	return {
 		allocationFactor,
 		albertaTax,
 		albertaTaxPayable: albertaTax.albertaTaxPayable,
 		schedulePayloads,
 		...iegGroup ? { iegGroup } : {},
+		...iegAgreement ? { iegAgreement } : {},
+		...iegEligibleExpenditures ? { iegEligibleExpenditures } : {},
 		...ieg ? { ieg } : {},
 		innovationEmploymentGrant: ieg?.ieg ?? 0,
 		issues
@@ -1166,6 +1648,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. */
@@ -1525,6 +2008,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
@@ -2016,8 +2509,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
@@ -2303,19 +2797,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);
@@ -6173,4 +6727,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, AB_GENERAL_RATE_BANDS as Ar, computeCcpcActiveBusinessTax as At, computeGrip as B, formatRsiText as Bn, AT1_DONATION_GAIN_RATE as Bt, computeQuebecTax as C, albertaCcaScheduleAdjustments as Cn, schedule1Values as Cr, blendProvinceRateTable as Ct, T2_LINE_META as D, albertaReserveDifference as Dn, schedule2Values as Dr, dividendsDeductibleS112 as Dt, resolveQuebecTaxRates as E, albertaRecaptureDifference as En, schedule29Values as Er, computeTaxableIncome as Et, normalizeSchedule88 as F, RSI_NEGATIVE_PREFIX as Fn, earliestRateYear 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, extendRateBook 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, hasExactRateYear as Lr, T2_CERTIFICATION_FIXTURES as Lt, computeFederalT2 as M, computeLossCarryback as Mn, AB_TAX_2024 as Mr, computeBusinessLimit as Mt, computeSchedule101 as N, RSI_COLUMN_GAP as Nn, AB_TAX_RATE_BOOK as Nr, computeSBD as Nt, foldT2Lines as O, albertaTerminalLossDifference as On, computeAlbertaTax as Or, netCapitalLossApplied as Ot, SCHEDULE_88_MAX_URLS as P, RSI_DELIMITER as Pn, resolveAlbertaTaxRates 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, latestRateYear as Rr, computeLossSchedule as Rt, computeQuebecAllocationFactor as S, albertaCcaDifference as Sn, schedule18Values as Sr, resolveProvinceRates as St, QC_TAX_RATE_BOOK as T, albertaDispositionAdjustments as Tn, schedule21Values 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, schedule12LossDeductions 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, schedule16Values as br, PROVINCE_RATE_BOOK as bt, EIFEL_FIRST_YEAR_START as c, CLASS_14_1_MINIMUM_DEDUCTION as cn, computeIeg as cr, assertSchedule1Fileable as ct, EIFEL_TRANSITIONAL_RATIO as d, MIN_LEASEHOLD_PERIODS as dn, SINGLE_JURISDICTION_ALBERTA_FACTOR as dr, deferredIncomeTaxProvisionAddBack as dt, CEC_INCLUSION_RATE as en, at1YesNo as er, computeSchedule5 as et, computeEifelLimitation as f, computeClass13 as fn, computeAllocationFactor as fr, findSchedule1LineDefects as ft, computeT2Settlement as g, CCA_DECLINING_BALANCE_RATES_2024 as gn, schedule10Values as gr, terminalLossDeduction as gt, computeAdjustedTaxableIncome as h, leaseholdPeriods as hn, at1LineItemId as hr, recaptureAddBack as ht, computeMpDeduction as i, UnsupportedCcaClassError as in, allocateIegEvenly as ir, computePart4Rdtoh as it, runConformanceSuite as j, LossCarrybackError as jn, computeDayWeightedGeneralTax as jr, computePartITax as jt, formatConformanceReport as k, computeSchedule12 as kn, computeAlbertaSbd as kr, nonCapitalLossApplied as kt, EIFEL_STANDARD_RATIO as l, CLASS_14_1_TRANSITIONAL_RATE as ln, computeIegBaseAmount as lr, ccaDeduction as lt, FOREIGN_TAX_CREDIT_GROSS_UP as m, computeClass141AdditionalAllowance as mn, AT1_SCHEDULES_WITH_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, computeIegGroupFigures as or, Schedule1NotFileableError as ot, ratioOfPermissibleExpenses as p, computeClass14 as pn, AT1_SCHEDULES_WITHOUT_BUILDERS 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, IEG_2024 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, computeIegExpenditureLimit as ur, computeSchedule1 as ut, t2Engine as v, isDecliningBalanceClass as vn, schedule12Values as vr, assessEifel as vt, QC_TAX_2024 as w, albertaCurrentYearLoss as wn, schedule20Values as wr, dayWeightedRate as wt, computeQuebecReturn as x, albertaCapitalGainDifference as xn, schedule17Values as xr, isSchedule5Province as xt, renderCo17DraftReturn as y, resolveCcaRates as yn, schedule13Values as yr, PROVINCE_RATES_2024 as yt, computeSchedule54 as z, formatRsiDate as zn, resolveRates as zr, computeLossContinuity as zt };
+export { computeProvincialAllocation as $, at1TaxPayableDeductions as $n, CEC_DEDUCTION_RATE as $t, runConformance as A, reconcileAlbertaNetIncome as An, schedule29Values as Ar, computeCcpcActiveBusinessTax as At, computeGrip as B, formatRsiText as Bn, earliestRateYear as Br, AT1_DONATION_GAIN_RATE as Bt, computeQuebecTax as C, albertaCcaScheduleAdjustments as Cn, schedule13Values as Cr, blendProvinceRateTable as Ct, T2_LINE_META as D, albertaReserveDifference as Dn, schedule1Values as Dr, dividendsDeductibleS112 as Dt, resolveQuebecTaxRates as E, albertaRecaptureDifference as En, schedule18Values as Er, computeTaxableIncome as Et, normalizeSchedule88 as F, RSI_NEGATIVE_PREFIX as Fn, AB_GENERAL_RATE_BANDS 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, hasExactRateYear as Hr, computeDonationMaximum as Ht, computeSchedule55 as I, RSI_WORD_GAP as In, computeDayWeightedGeneralTax 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, AB_TAX_2024 as Lr, T2_CERTIFICATION_FIXTURES as Lt, computeFederalT2 as M, computeLossCarryback as Mn, schedule4970Values as Mr, computeBusinessLimit as Mt, computeSchedule101 as N, RSI_COLUMN_GAP as Nn, computeAlbertaTax as Nr, computeSBD as Nt, foldT2Lines as O, albertaTerminalLossDifference as On, schedule20Values as Or, netCapitalLossApplied as Ot, SCHEDULE_88_MAX_URLS as P, RSI_DELIMITER as Pn, computeAlbertaSbd 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, AB_TAX_RATE_BOOK as Rr, computeLossSchedule as Rt, computeQuebecAllocationFactor as S, albertaCcaDifference as Sn, schedule12Values as Sr, resolveProvinceRates as St, QC_TAX_RATE_BOOK as T, albertaDispositionAdjustments as Tn, schedule17Values as Tr, charitableDonationsDeduction as Tt, computeTaxableCapital as U, renderRsiLineItem as Un, latestRateYear as Ur, computeSchedule20 as Ut, computeSchedule43 as V, renderAt1Rsi as Vn, extendRateBook as Vr, AT1_DONATION_INCOME_RATE as Vt, computeSchedule31 as W, renderAt1NetFile as Wn, resolveRates as Wr, 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, AT1_SCHEDULES_WITHOUT_BUILDERS 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, schedule10Values 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, computeIegEligibleExpenditures as fr, findSchedule1LineDefects as ft, computeT2Settlement as g, CCA_DECLINING_BALANCE_RATES_2024 as gn, computeAt4970 as gr, terminalLossDeduction as gt, computeAdjustedTaxableIncome as h, leaseholdPeriods as hn, computeAllocationFactor as hr, recaptureAddBack as ht, computeMpDeduction as i, UnsupportedCcaClassError as in, allocateIegEvenly as ir, computePart4Rdtoh as it, runConformanceSuite as j, LossCarrybackError as jn, schedule2Values as jr, computePartITax as jt, formatConformanceReport as k, computeSchedule12 as kn, schedule21Values 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, SINGLE_JURISDICTION_ALBERTA_FACTOR 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, iegT661SourceLine 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, AT1_SCHEDULES_WITH_BUILDERS as vr, assessEifel as vt, QC_TAX_2024 as w, albertaCurrentYearLoss as wn, schedule16Values as wr, dayWeightedRate as wt, computeQuebecReturn as x, albertaCapitalGainDifference as xn, schedule12LossDeductions as xr, isSchedule5Province as xt, renderCo17DraftReturn as y, resolveCcaRates as yn, at1LineItemId as yr, PROVINCE_RATES_2024 as yt, computeSchedule54 as z, formatRsiDate as zn, resolveAlbertaTaxRates as zr, computeLossContinuity as zt };