@incodetech/core 2.4.1-agentic → 2.4.1-agentic.2

package/dist/{FaceDetectionProvider-B83VmClw.esm.js → FaceDetectionProvider-D9PlON49.esm.js}

@@ -1,16 +1,15 @@
-import { l as wasmRuntime } from "./warmup-BkfxQZsC.esm.js";
-import { t as ensureWasmPipelines } from "./setup-CDAKwTr7.esm.js";
-import { r as BaseWasmProvider } from "./WasmUtilProvider-GTkoJyFY.esm.js";
-import { t as api, u as endpoints } from "./api-BO8JA7Pf.esm.js";
-import { l as trueSightHintTransition, r as noteTrueSightCaptureActivity } from "./trueSightService-BujtUIW6.esm.js";
-import "./sessionInitializer-CWFT4dfw.esm.js";
-import { t as addDeviceStats } from "./stats-BpMz-hTP.esm.js";
+import { l as wasmRuntime } from "./warmup-DtB0DJpl.esm.js";
+import { t as ensureWasmPipelines } from "./setup-D26WdmvA.esm.js";
+import { r as BaseWasmProvider } from "./WasmUtilProvider-Dp2V-Uct.esm.js";
+import { t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
+import { l as trueSightHintTransition, r as noteTrueSightCaptureActivity } from "./trueSightService-OZl8wQu7.esm.js";
+import "./sessionInitializer-CwJACl13.esm.js";
+import { t as addDeviceStats } from "./stats-CatA2dea.esm.js";
 import { t as IncodeCanvas } from "./canvas-BxFzWTt-.esm.js";
-import { o as StreamCanvasProcessingSession } from "./multipartRecordingService-DMBxHKS2.esm.js";
-import { n as hasBackCamera } from "./backCameraStream-C5_NNfUN.esm.js";
-import "./deepsightService-twg3bXqY.esm.js";
+import { t as StreamCanvasProcessingSession } from "./StreamCanvasProcessingSession-CBnbTnOr.esm.js";
+import { r as hasBackCamera } from "./backCameraStream-DS1oDiUq.esm.js";
 import { t as getDeviceClass } from "./getDeviceClass-DoIWuKI8.esm.js";
-import { n as saveProcessFaceMatch } from "./processFaceMatch-BWme3kVV.esm.js";
+import { n as saveProcessFaceMatch } from "./processFaceMatch-Bst83HaS.esm.js";
 //#region src/internal/faceCapture/onDeviceFaceResults.ts
 /**
 * On-device still-face capture is owned by the protected camera-cycle actor.
@@ -236,7 +235,7 @@ function startDetection(params) {
 	};
 }
 async function initializeDeepsightSession(options) {
-	const { loadDeepsightSession } = await import("./deepsightLoader-DMxtowCm.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-Crsj_u0c.esm.js");
 	return loadDeepsightSession({
 		ds: options.ds,
 		storage: options.storage

package/dist/MultipartRecordingProvider-D9mauUdS.esm.js

@@ -0,0 +1,146 @@
+import { n as getMultipartRecorderMimeType } from "./mediaRecorderOptions-B9-IEVtV.esm.js";
+//#region ../infra/src/providers/browser/MultipartRecordingProvider.ts
+/**
+* How often `MediaRecorder` hands us buffered data (incremental blobs).
+* 500 ms keeps each blob — and therefore each upload chunk — small: less
+* tail lost when a session is interrupted, and a smaller first blob (init
+* header + keyframe), which is the largest and most timeout-prone chunk.
+* Not lower: request rate doubles per halving, and browsers stop honoring
+* very small timeslices reliably.
+*/
+const TIMESLICE_MS = 500;
+/**
+* Encoder target for the full video-selfie session. Higher than the
+* short-clip liveness path (0.5–1 Mbps) so a multi-minute session keeps
+* usable quality. It's a ceiling — a still scene still encodes well below it.
+*/
+const VIDEO_BITS_PER_SECOND = 25e5;
+/**
+* Records a stream and emits every `MediaRecorder` timeslice blob as its own
+* part, in order. Each blob is a whole container fragment (WebM cluster /
+* fMP4 `moof`+`mdat`), which is the property the video-selfie-service's
+* gap-splicing depends on — parts must never cut a fragment at a byte
+* offset. The service stages sub-5 MiB chunks and combines them server-side,
+* so emitting the smallest whole-fragment unit (~0.5 s of video) maximizes
+* what an interrupted session can salvage.
+*
+* Page-lifecycle orchestration lives in Core: it pauses this recorder before a
+* backgrounded camera can stall, restores the camera/compositor, and only then
+* resumes this same media container.
+*/
+var MultipartRecordingProvider = class {
+	constructor() {
+		this.mediaRecorder = null;
+		this._isRecording = false;
+		this._hasError = false;
+		this._error = null;
+		this.mimeType = "";
+		this.partNumber = 0;
+		this.onPart = null;
+	}
+	get isRecording() {
+		return this._isRecording;
+	}
+	get hasError() {
+		return this._hasError;
+	}
+	get error() {
+		return this._error;
+	}
+	startRecording(stream, onPart) {
+		this.reset();
+		this.partNumber = 0;
+		this.onPart = onPart;
+		try {
+			this.mimeType = getMultipartRecorderMimeType();
+			const recorder = new MediaRecorder(stream.clone(), {
+				mimeType: this.mimeType,
+				videoBitsPerSecond: VIDEO_BITS_PER_SECOND
+			});
+			recorder.ondataavailable = (event) => {
+				if (event.data.size > 0 && this.onPart) {
+					this.partNumber += 1;
+					this.onPart({
+						chunk: event.data,
+						partNumber: this.partNumber
+					});
+				}
+			};
+			recorder.onerror = (event) => {
+				const detail = event instanceof ErrorEvent && event.error instanceof Error ? event.error.message : event.type;
+				this._error = `Recording error: ${detail}`;
+				this._isRecording = false;
+				this._hasError = true;
+			};
+			recorder.start(TIMESLICE_MS);
+			this.mediaRecorder = recorder;
+			this._isRecording = true;
+			this._error = null;
+			this._hasError = false;
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			this._error = `Failed to start recording: ${detail}`;
+			this._hasError = true;
+		}
+	}
+	pauseRecording() {
+		const recorder = this.mediaRecorder;
+		if (!recorder || !this._isRecording || this._hasError) return false;
+		if (recorder.state === "paused") return true;
+		if (recorder.state !== "recording") return false;
+		try {
+			recorder.pause();
+			return true;
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			this._error = `Failed to pause recording: ${detail}`;
+			this._hasError = true;
+			return false;
+		}
+	}
+	resumeRecording() {
+		const recorder = this.mediaRecorder;
+		if (!recorder || !this._isRecording || this._hasError) return false;
+		if (recorder.state === "recording") return true;
+		if (recorder.state !== "paused") return false;
+		try {
+			recorder.resume();
+			return true;
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			this._error = `Failed to resume recording: ${detail}`;
+			this._hasError = true;
+			return false;
+		}
+	}
+	stopRecording() {
+		const recorder = this.mediaRecorder;
+		return new Promise((resolve) => {
+			if (recorder && this._isRecording) {
+				recorder.onstop = () => {
+					resolve();
+				};
+				recorder.stop();
+				this._isRecording = false;
+			} else resolve();
+			recorder?.stream?.getTracks().forEach((track) => track.stop());
+		});
+	}
+	reset() {
+		const recorder = this.mediaRecorder;
+		if (recorder) {
+			recorder.ondataavailable = null;
+			recorder.onerror = null;
+			recorder.onstop = null;
+			if (recorder.state !== "inactive") recorder.stop();
+			recorder.stream.getTracks().forEach((track) => track.stop());
+			this.mediaRecorder = null;
+		}
+		this.onPart = null;
+		this._isRecording = false;
+		this._error = null;
+		this._hasError = false;
+	}
+};
+//#endregion
+export { MultipartRecordingProvider as t };

package/dist/StreamCanvasProcessingSession-CBnbTnOr.esm.js

@@ -0,0 +1,42 @@
+//#region ../infra/src/media/StreamCanvasProcessingSession.ts
+var StreamCanvasProcessingSession = class {
+	/**
+	* Creates a processing session that reacts to `StreamCanvasCapture` frame events
+	* and drives a provider's `processFrame()` method with backpressure.
+	*/
+	constructor(params) {
+		this.disposed = false;
+		this.isProcessing = false;
+		this.onFrameEvent = () => {
+			if (this.disposed || this.isProcessing) return;
+			const frame = this.capturer.getLatestFrame();
+			if (!frame) return;
+			this.onFrame?.(frame);
+			this.isProcessing = true;
+			this.provider.processFrame(frame).catch(() => {}).finally(() => {
+				this.isProcessing = false;
+			});
+		};
+		this.capturer = params.capturer;
+		this.provider = params.provider;
+		this.onFrame = params.onFrame;
+		this.capturer.addEventListener("frame", this.onFrameEvent);
+	}
+	/**
+	* Unsubscribes from frame events and resets the provider.
+	*/
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.capturer.removeEventListener("frame", this.onFrameEvent);
+		this.provider.reset();
+	}
+	/**
+	* Returns whether the session has been disposed.
+	*/
+	isDisposed() {
+		return this.disposed;
+	}
+};
+//#endregion
+export { StreamCanvasProcessingSession as t };

package/dist/{WasmUtilProvider-GTkoJyFY.esm.js → WasmUtilProvider-Dp2V-Uct.esm.js}

@@ -1,6 +1,6 @@
 import { n as __exportAll } from "./rolldown-runtime-B-1-B7_t.esm.js";
-import { c as wasmCallWrapper, d as noteUnlockedCallStart, s as ML_CALL_MAX_POLLS, u as noteUnlockedCallEnd } from "./wasmWebClient-DTj9auyA.esm.js";
-import { i as isWasmReady, l as wasmRuntime, o as waitForWasm, r as getWasmStatus, s as warmupWasm } from "./warmup-BkfxQZsC.esm.js";
+import { c as wasmCallWrapper, d as noteUnlockedCallStart, s as ML_CALL_MAX_POLLS, u as noteUnlockedCallEnd } from "./wasmWebClient-BDrax6Eu.esm.js";
+import { i as isWasmReady, l as wasmRuntime, o as waitForWasm, r as getWasmStatus, s as warmupWasm } from "./warmup-DtB0DJpl.esm.js";
 //#region ../infra/src/wasm/utilityWasmApi.ts
 /**
 * Utility / metadata domain facade over {@link WasmRuntime}.

package/dist/WorkerEncoderRecordingProvider-B1ODYtgN.esm.js

@@ -0,0 +1,80 @@
+import { n as __exportAll } from "./rolldown-runtime-B-1-B7_t.esm.js";
+import { t as MultipartRecordingProvider } from "./MultipartRecordingProvider-D9mauUdS.esm.js";
+//#region ../infra/src/providers/browser/WorkerEncoderRecordingProvider.ts
+var WorkerEncoderRecordingProvider_exports = /* @__PURE__ */ __exportAll({ WorkerEncoderRecordingProvider: () => WorkerEncoderRecordingProvider });
+/**
+* Multipart recorder for a `CameraCompositor` that encodes inside its worker
+* (ENG-55397): emits the worker's WebM clusters as parts, in order. When the
+* compositor could not start in-worker encoding (no insertable streams or
+* WebCodecs, strict CSP), it records the composite stream with
+* `MediaRecorder` instead, so callers wire it unconditionally.
+*
+* Why not always `MediaRecorder`: Chrome hands every recorded frame through
+* the page main thread and drops frames while it is blocked. On a Galaxy A01
+* Core the ID flow blocks it for 3–5 s (WASM + 1080p readbacks); a
+* `MediaRecorder` fed by the worker kept 74 of 149 frames under 1.5 s
+* freezes, the in-worker encoder 150 of 151.
+*/
+var WorkerEncoderRecordingProvider = class {
+	constructor(compositor) {
+		this.compositor = compositor;
+		this._isRecording = false;
+		this._error = null;
+		this.partNumber = 0;
+		this.fallback = null;
+	}
+	get isRecording() {
+		return this.fallback ? this.fallback.isRecording : this._isRecording;
+	}
+	get hasError() {
+		return this.error !== null;
+	}
+	get error() {
+		if (this.fallback) return this.fallback.error;
+		return this._error ?? this.compositor.workerRecordingErrorMessage;
+	}
+	startRecording(stream, onPart) {
+		this.reset();
+		if (!this.compositor.encodesInWorker) {
+			this.fallback = new MultipartRecordingProvider();
+			this.fallback.startRecording(stream, onPart);
+			return;
+		}
+		this.partNumber = 0;
+		const started = this.compositor.startWorkerRecording((chunk) => {
+			this.partNumber += 1;
+			onPart({
+				chunk,
+				partNumber: this.partNumber
+			});
+		});
+		this._isRecording = started;
+		this._error = started ? null : "Failed to start recording: no encoder";
+	}
+	pauseRecording() {
+		if (this.fallback) return this.fallback.pauseRecording();
+		return this._isRecording && this.compositor.pauseWorkerRecording();
+	}
+	resumeRecording() {
+		if (this.fallback) return this.fallback.resumeRecording();
+		return this._isRecording && this.compositor.resumeWorkerRecording();
+	}
+	async stopRecording() {
+		if (this.fallback) {
+			await this.fallback.stopRecording();
+			return;
+		}
+		if (!this._isRecording) return;
+		this._isRecording = false;
+		await this.compositor.stopWorkerRecording();
+	}
+	reset() {
+		this.fallback?.reset();
+		this.fallback = null;
+		this.compositor.cancelWorkerRecording();
+		this._isRecording = false;
+		this._error = null;
+	}
+};
+//#endregion
+export { WorkerEncoderRecordingProvider_exports as n, WorkerEncoderRecordingProvider as t };

package/dist/{addressSearch-41sMcnJk.esm.js → addressSearch-DzbE9Ogt.esm.js}

@@ -1,214 +1,6 @@
-import { t as api, u as endpoints } from "./api-BO8JA7Pf.esm.js";
+import { t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
 import { t as fromCallback } from "./xstate-actors.esm-8Gzepa_A.esm.js";
-//#region src/shared/usStates.ts
-const usStates = {
-	AL: {
-		code: "AL",
-		name: "Alabama"
-	},
-	AK: {
-		code: "AK",
-		name: "Alaska"
-	},
-	AZ: {
-		code: "AZ",
-		name: "Arizona"
-	},
-	AR: {
-		code: "AR",
-		name: "Arkansas"
-	},
-	CA: {
-		code: "CA",
-		name: "California"
-	},
-	CO: {
-		code: "CO",
-		name: "Colorado"
-	},
-	CT: {
-		code: "CT",
-		name: "Connecticut"
-	},
-	DE: {
-		code: "DE",
-		name: "Delaware"
-	},
-	FL: {
-		code: "FL",
-		name: "Florida"
-	},
-	GA: {
-		code: "GA",
-		name: "Georgia"
-	},
-	HI: {
-		code: "HI",
-		name: "Hawaii"
-	},
-	ID: {
-		code: "ID",
-		name: "Idaho"
-	},
-	IL: {
-		code: "IL",
-		name: "Illinois"
-	},
-	IN: {
-		code: "IN",
-		name: "Indiana"
-	},
-	IA: {
-		code: "IA",
-		name: "Iowa"
-	},
-	KS: {
-		code: "KS",
-		name: "Kansas"
-	},
-	KY: {
-		code: "KY",
-		name: "Kentucky"
-	},
-	LA: {
-		code: "LA",
-		name: "Louisiana"
-	},
-	ME: {
-		code: "ME",
-		name: "Maine"
-	},
-	MD: {
-		code: "MD",
-		name: "Maryland"
-	},
-	MA: {
-		code: "MA",
-		name: "Massachusetts"
-	},
-	MI: {
-		code: "MI",
-		name: "Michigan"
-	},
-	MN: {
-		code: "MN",
-		name: "Minnesota"
-	},
-	MS: {
-		code: "MS",
-		name: "Mississippi"
-	},
-	MO: {
-		code: "MO",
-		name: "Missouri"
-	},
-	MT: {
-		code: "MT",
-		name: "Montana"
-	},
-	NE: {
-		code: "NE",
-		name: "Nebraska"
-	},
-	NV: {
-		code: "NV",
-		name: "Nevada"
-	},
-	NH: {
-		code: "NH",
-		name: "New Hampshire"
-	},
-	NJ: {
-		code: "NJ",
-		name: "New Jersey"
-	},
-	NM: {
-		code: "NM",
-		name: "New Mexico"
-	},
-	NY: {
-		code: "NY",
-		name: "New York"
-	},
-	NC: {
-		code: "NC",
-		name: "North Carolina"
-	},
-	ND: {
-		code: "ND",
-		name: "North Dakota"
-	},
-	OH: {
-		code: "OH",
-		name: "Ohio"
-	},
-	OK: {
-		code: "OK",
-		name: "Oklahoma"
-	},
-	OR: {
-		code: "OR",
-		name: "Oregon"
-	},
-	PA: {
-		code: "PA",
-		name: "Pennsylvania"
-	},
-	RI: {
-		code: "RI",
-		name: "Rhode Island"
-	},
-	SC: {
-		code: "SC",
-		name: "South Carolina"
-	},
-	SD: {
-		code: "SD",
-		name: "South Dakota"
-	},
-	TN: {
-		code: "TN",
-		name: "Tennessee"
-	},
-	TX: {
-		code: "TX",
-		name: "Texas"
-	},
-	UT: {
-		code: "UT",
-		name: "Utah"
-	},
-	VT: {
-		code: "VT",
-		name: "Vermont"
-	},
-	VA: {
-		code: "VA",
-		name: "Virginia"
-	},
-	WA: {
-		code: "WA",
-		name: "Washington"
-	},
-	WV: {
-		code: "WV",
-		name: "West Virginia"
-	},
-	WI: {
-		code: "WI",
-		name: "Wisconsin"
-	},
-	WY: {
-		code: "WY",
-		name: "Wyoming"
-	}
-};
-const usStateOptions = Object.values(usStates).map((state) => ({
-	value: state.code,
-	label: state.name
-}));
-//#endregion
 //#region src/shared/addressSuggestion.ts
 /** Shown when an autocomplete suggestion has no street (city/region-level result). */
 const STREET_LEVEL_REQUIRED_ERROR = { key: "verification.errors.streetLevelRequired" };
@@ -263,9 +55,6 @@ function buildStreetValue(street, houseNumber, hasHouseNoField) {
 	if (houseNumber && street) return `${houseNumber} ${street}`;
 	return houseNumber ?? street ?? "";
 }
-//#endregion
-//#region src/shared/displayErrors.ts
-const DYNAMIC_REQUIRED_KEY = "verification.errors.fieldRequiredDynamic";
 const POSTAL_CODE_MAX_LENGTH_BY_COUNTRY = {
 	US: 10,
 	BR: 9,
@@ -383,98 +172,6 @@ function formatPostalCode(value, country) {
 	return value.slice(0, 8);
 }
 //#endregion
-//#region src/internal/forms/checkSupport.ts
-const GROUP_POLICIES = /* @__PURE__ */ new Set(["hide", "forceShow"]);
-/**
-* Compares `major.minor` vocabulary versions. The compiler's twin is
-* `compareVersions` in `packages/form-definitions/scripts/lib/checks.mjs`;
-* both are tested against that package's `fixtures/vocabularyVersions.json`.
-*/
-function compareVocabulary(a, b) {
-	const [aMajor = 0, aMinor = 0] = a.split(".").map(Number);
-	const [bMajor = 0, bMinor = 0] = b.split(".").map(Number);
-	return aMajor - bMajor || aMinor - bMinor;
-}
-/**
-* Whether this build can use a definition. Any id it doesn't implement makes
-* the definition unsupported, so the caller falls back to its bundled
-* definition or current form. Presentation hints (widget, keyboard, autofill)
-* never fail: an unknown hint falls back to the platform default.
-*/
-function checkSupport(definition, ids) {
-	const problems = [];
-	const need = (category, known, id, path) => {
-		if (!known.has(id)) problems.push({
-			category,
-			id,
-			path
-		});
-	};
-	if (!ids.schemaVersions.includes(definition.schemaVersion)) problems.push({
-		category: "schemaVersion",
-		id: String(definition.schemaVersion),
-		path: "schemaVersion"
-	});
-	if (compareVocabulary(definition.vocabulary, ids.vocabulary) > 0) problems.push({
-		category: "vocabulary",
-		id: definition.vocabulary,
-		path: "vocabulary"
-	});
-	const checkField = (field, path) => {
-		need("kind", ids.kinds, field.kind, `${path}.kind`);
-		need("group", ids.groups, field.group, `${path}.group`);
-		field.rules?.forEach((rule, i) => need("rule", ids.rules, rule.id, `${path}.rules[${i}]`));
-		field.input?.format?.forEach((t, i) => need("transform", ids.transforms, t.id, `${path}.input.format[${i}]`));
-		field.payload?.transforms?.forEach((t, i) => need("transform", ids.transforms, t.id, `${path}.payload.transforms[${i}]`));
-		if (field.optionsRef) need("optionList", ids.optionLists, field.optionsRef, `${path}.optionsRef`);
-		if (field.suggestionsRef) need("optionList", ids.optionLists, field.suggestionsRef, `${path}.suggestionsRef`);
-		field.requiredWhen?.forEach((condition, i) => {
-			const keys = Object.keys(condition);
-			if (keys.length !== 1) problems.push({
-				category: "condition",
-				id: keys.join("+") || "(empty)",
-				path: `${path}.requiredWhen[${i}]`
-			});
-			for (const key of keys) need("condition", ids.conditions, key, `${path}.requiredWhen[${i}]`);
-		});
-		field.prefill?.forEach((id, i) => need("prefillSource", ids.prefillSources, id, `${path}.prefill[${i}]`));
-		const lock = field.phone?.lockCountry;
-		if (typeof lock === "string" && lock !== "whenPhoneRisk") problems.push({
-			category: "phoneLock",
-			id: lock,
-			path: `${path}.phone`
-		});
-	};
-	definition.fields.forEach((field) => checkField(field, `fields.${field.name}`));
-	definition.groups?.forEach((policy) => {
-		need("group", ids.groups, policy.group, `groups.${policy.group}`);
-		if (!GROUP_POLICIES.has(policy.whenDisabled)) problems.push({
-			category: "groupPolicy",
-			id: policy.whenDisabled,
-			path: `groups.${policy.group}`
-		});
-	});
-	definition.groupRules?.forEach((rule, i) => {
-		need("groupRule", ids.groupRules, rule.id, `groupRules[${i}]`);
-		const cases = rule.id === "rulesByOption" ? rule.params?.cases : void 0;
-		if (cases && typeof cases === "object" && !Array.isArray(cases)) for (const [value, rules] of Object.entries(cases)) {
-			if (!Array.isArray(rules)) continue;
-			rules.forEach((ref, j) => {
-				const id = ref?.id;
-				need("rule", ids.rules, typeof id === "string" ? id : "(missing)", `groupRules[${i}].params.cases.${value}[${j}]`);
-			});
-		}
-	});
-	definition.collections?.forEach((collection) => {
-		need("group", ids.groups, collection.group, `collections.${collection.id}`);
-		collection.fields.forEach((field) => checkField(field, `collections.${collection.id}.fields.${field.name}`));
-	});
-	return problems.length === 0 ? { supported: true } : {
-		supported: false,
-		problems
-	};
-}
-//#endregion
 //#region src/internal/forms/definitionSource.ts
 const queryKey = ({ module, source, country }) => `${module}|${source ?? ""}|${country ?? ""}`;
 /**
@@ -486,53 +183,6 @@ function createBundledDefinitionSource(definitions) {
 	return { select: (query) => byQuery.get(queryKey(query)) };
 }
 //#endregion
-//#region src/internal/forms/resolveForm.ts
-const FORCE_SHOW = "forceShow";
-const WHEN_PHONE_RISK = "whenPhoneRisk";
-/**
-* Resolves a definition against module configuration: which fields show,
-* which are required, whether the phone is locked, and which group rules and
-* collections apply. Pure and synchronous, so it runs inside an assign action.
-*
-* Call `checkSupport` first for any definition that wasn't bundled with this
-* build; `resolveForm` ignores ids it doesn't know.
-*/
-function resolveForm(definition, context) {
-	const forcedGroups = new Set((definition.groups ?? []).filter((policy) => policy.whenDisabled === FORCE_SHOW).map((policy) => policy.group));
-	const isOn = (group) => context.groups[group] === true;
-	const isShown = (group) => isOn(group) || forcedGroups.has(group);
-	const riskAddons = new Set(context.riskAddons ?? []);
-	const shownFields = definition.fields.filter((field) => isShown(field.group));
-	const shownNames = new Set(shownFields.map((field) => field.name));
-	const fields = shownFields.map((field) => {
-		const conditions = field.requiredWhen ?? [];
-		const addonRequired = conditions.some((condition) => condition.riskAddon !== void 0 && riskAddons.has(condition.riskAddon));
-		const requiredIfFilled = conditions.map((condition) => condition.fieldFilled).filter((name) => name !== void 0 && shownNames.has(name));
-		const lock = field.phone?.lockCountry;
-		return {
-			field,
-			required: field.required === true || addonRequired,
-			requiredIfFilled,
-			forced: !isOn(field.group),
-			phoneLocked: field.kind === "phone" && (lock === true || lock === WHEN_PHONE_RISK && context.phoneRisk === true)
-		};
-	});
-	const order = shownFields.map((field) => field.name);
-	return {
-		definition,
-		fields,
-		groupRules: (definition.groupRules ?? []).map((rule) => ({
-			rule,
-			fields: order.filter((name) => rule.fields.includes(name))
-		})).filter((resolved) => resolved.fields.length > 0),
-		collections: (definition.collections ?? []).filter((collection) => isShown(collection.group)).map((collection) => ({
-			collection,
-			min: collection.min ?? 0,
-			max: collection.max
-		}))
-	};
-}
-//#endregion
 //#region src/internal/formDefinitionsRollout/formDefinitionsRollout.ts
 /**
 * The rollout switch for form definitions (ENG-59781): one all-or-nothing
@@ -601,4 +251,4 @@ const debounceSearchActor = fromCallback(({ input, sendBack }) => {
 	};
 });
 //#endregion
-export { usStates as _, createBundledDefinitionSource as a, formatPostalCode as c, validatePostalCode as d, DYNAMIC_REQUIRED_KEY as f, usStateOptions as g, getStreetLevelErrorForSuggestion as h, resolveForm as i, getPostalCodeErrorKey as l, fillFromSuggestion as m, searchAddress as n, checkSupport as o, STREET_LEVEL_REQUIRED_ERROR as p, isFormDefinitionsEnabled as r, FIXED_DIGIT_POSTAL_CODE_LENGTH as s, debounceSearchActor as t, getPostalCodeMaxLength as u };
+export { FIXED_DIGIT_POSTAL_CODE_LENGTH as a, getPostalCodeMaxLength as c, fillFromSuggestion as d, getStreetLevelErrorForSuggestion as f, createBundledDefinitionSource as i, validatePostalCode as l, searchAddress as n, formatPostalCode as o, isFormDefinitionsEnabled as r, getPostalCodeErrorKey as s, debounceSearchActor as t, STREET_LEVEL_REQUIRED_ERROR as u };