@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/cjs/component-runtime-chunk-BCXKlIzs.js

@@ -0,0 +1 @@
+"use strict";var contracts=require("./contracts-CtPI2qPw.js");function createKindStore(){return{renderer:new Map,editor:new Map,filter:new Map,floatingFilter:new Map}}function normalizeName(name,kind){if(typeof name!=="string"||name.trim().length===0){throw new contracts.GridComponentError(`${kind} component name must be a non-empty string.`,{code:"INVALID_NAME",phase:"lookup",componentKind:kind,retryable:false})}return name.trim()}function isRecord(value){return value!==null&&typeof value==="object"}function hasOwn$1(value,key){return Object.prototype.hasOwnProperty.call(value,key)}function isGridLazyComponentDefinition(value){if(!isRecord(value))return false;try{return value.type==="lazy"&&typeof value.load==="function"}catch{return false}}function assertDefinition(value,kind,name){let captured;try{captured=captureGridComponentDefinition(value)}catch(cause){throw new contracts.GridComponentError(`${kind} component "${name??"<direct>"}" has an invalid definition.`,{code:"LAZY_INVALID_DEFINITION",phase:"lookup",componentKind:kind,componentName:name,retryable:false,cause})}if(captured!==void 0)return captured;throw new contracts.GridComponentError(`${kind} component "${name??"<direct>"}" has an invalid definition.`,{code:"LAZY_INVALID_DEFINITION",phase:"lookup",componentKind:kind,componentName:name,retryable:false})}const CAPTURED_EAGER_DEFINITIONS=new WeakMap;function rememberCapturedEager(source,captured){CAPTURED_EAGER_DEFINITIONS.set(source,captured)}function getCapturedGridEagerDefinition(definition){return CAPTURED_EAGER_DEFINITIONS.get(definition)??definition}function captureGridComponentDefinition(value){if(!isRecord(value))return void 0;const type=value.type;if(type==="factory"){const create=value.create;if(typeof create!=="function")return void 0;return{type:"eager",definition:{type:"factory",create:context=>create.call(value,context)}}}if(type==="class"){const component=value.component;if(typeof component!=="function")return void 0;return{type:"eager",definition:{type:"class",component}}}if(type==="lazy"){const load=value.load;if(typeof load!=="function")return void 0;return{type:"lazy",load:context=>Promise.resolve(load.call(value,context))}}return void 0}function abortedError(kind,name,cause){return new contracts.GridComponentError(`${kind} component "${name??"<direct>"}" loading was aborted.`,{code:"ABORTED",phase:"lazy-load",componentKind:kind,componentName:name,retryable:true,cause})}async function waitForLazyResult(promise,signal,kind,name){if(!signal)return promise;if(signal.aborted)throw abortedError(kind,name,signal.reason);let onAbort;const abort=new Promise((_resolve,reject)=>{onAbort=()=>reject(abortedError(kind,name,signal.reason));signal.addEventListener("abort",onAbort,{once:true})});try{return await Promise.race([promise,abort])}finally{if(onAbort)signal.removeEventListener("abort",onAbort)}}async function resolveGridComponentDefinition(definition,options){let captured;try{captured=captureGridComponentDefinition(definition)}catch(cause){throw new contracts.GridComponentError(`${options.kind} component "${options.name??"<direct>"}" has an invalid definition.`,{code:"LAZY_INVALID_DEFINITION",phase:"lazy-load",componentKind:options.kind,componentName:options.name,retryable:false,cause})}if(captured?.type==="eager"){rememberCapturedEager(definition,captured.definition);return definition}if(captured?.type!=="lazy"){throw new contracts.GridComponentError(`${options.kind} component "${options.name??"<direct>"}" has an invalid definition.`,{code:"LAZY_INVALID_DEFINITION",phase:"lazy-load",componentKind:options.kind,componentName:options.name,retryable:false})}if(options.signal?.aborted){throw abortedError(options.kind,options.name,options.signal.reason)}const rawLoad=Promise.resolve().then(()=>options.signal?.aborted?Promise.reject(abortedError(options.kind,options.name,options.signal.reason)):captured.load({componentKind:options.kind,componentName:options.name,signal:options.signal??new AbortController().signal}));void rawLoad.catch(()=>void 0);let loaded;try{loaded=await waitForLazyResult(rawLoad,options.signal,options.kind,options.name)}catch(error){if(error instanceof contracts.GridComponentError)throw error;throw new contracts.GridComponentError(`${options.kind} component "${options.name??"<direct>"}" failed to load.`,{code:"LAZY_LOAD_FAILED",phase:"lazy-load",componentKind:options.kind,componentName:options.name,retryable:true,cause:error})}let loadedDefinition;try{loadedDefinition=captureGridComponentDefinition(loaded)}catch(cause){throw new contracts.GridComponentError(`${options.kind} component "${options.name??"<direct>"}" loader returned an invalid definition.`,{code:"LAZY_INVALID_DEFINITION",phase:"lazy-load",componentKind:options.kind,componentName:options.name,retryable:true,cause})}if(loadedDefinition?.type!=="eager"){throw new contracts.GridComponentError(`${options.kind} component "${options.name??"<direct>"}" loader returned an invalid definition.`,{code:"LAZY_INVALID_DEFINITION",phase:"lazy-load",componentKind:options.kind,componentName:options.name,retryable:true})}rememberCapturedEager(loaded,loadedDefinition.definition);return loaded}function localLookup(local,kind,name){const group=local?.[kind];if(!group||!hasOwn$1(group,name)){return{found:false,value:void 0}}return{found:true,value:group[name]}}function lazyContextKey(kind,name){return JSON.stringify([kind,name??null])}function createGridComponentRegistry(){const stores={local:createKindStore(),global:createKindStore()};let lazyContexts=new WeakMap;const activeLazyFlights=new Set;function removeEmptyLazyContext(definition,contexts,key,entry){if(entry.cached||entry.flight)return;if(contexts.get(key)!==entry)return;contexts.delete(key);if(contexts.size===0&&lazyContexts.get(definition)===contexts){lazyContexts.delete(definition)}}function abortLazyFlight(flight,reason){if(flight.settled||flight.invalidated)return;flight.invalidated=true;flight.controller.abort(reason)}function invalidateLazyContext(definition,kind,name,reason){const contexts=lazyContexts.get(definition);if(!contexts)return false;const key=lazyContextKey(kind,name);const entry=contexts.get(key);if(!entry)return false;const flight=entry.flight;const hadResolution=Boolean(entry.cached||flight);contexts.delete(key);if(contexts.size===0&&lazyContexts.get(definition)===contexts){lazyContexts.delete(definition)}if(flight)abortLazyFlight(flight,reason);return hadResolution}function createLazyFlight(definition,kind,name,contexts,key,entry){const controller=new AbortController;let flight;const promise=resolveGridComponentDefinition(definition,{kind,name,signal:controller.signal}).then(eager=>{flight.settled=true;activeLazyFlights.delete(flight);if(flight.invalidated||controller.signal.aborted||entry.flight!==flight){throw abortedError(kind,name,controller.signal.reason)}entry.flight=void 0;entry.cached=eager;return eager},error=>{flight.settled=true;activeLazyFlights.delete(flight);if(entry.flight===flight){entry.flight=void 0;removeEmptyLazyContext(definition,contexts,key,entry)}throw error});flight={controller,promise,waiters:new Set,settled:false,invalidated:false};activeLazyFlights.add(flight);void promise.catch(()=>void 0);return flight}async function resolveLazyDefinition(definition,kind,name,signal){if(signal?.aborted){throw abortedError(kind,name,signal.reason)}let contexts=lazyContexts.get(definition);if(!contexts){contexts=new Map;lazyContexts.set(definition,contexts)}const key=lazyContextKey(kind,name);let entry=contexts.get(key);if(!entry){entry={cached:void 0,flight:void 0};contexts.set(key,entry)}if(entry.cached)return entry.cached;const flight=entry.flight??createLazyFlight(definition,kind,name,contexts,key,entry);entry.flight=flight;const waiter=Symbol("grid-component-lazy-waiter");flight.waiters.add(waiter);try{return await waitForLazyResult(flight.promise,signal,kind,name)}finally{flight.waiters.delete(waiter);if(!flight.settled&&!flight.invalidated&&flight.waiters.size===0&&entry.flight===flight){entry.flight=void 0;removeEmptyLazyContext(definition,contexts,key,entry);abortLazyFlight(flight,signal?.reason??new Error(`${kind} component "${name??"<direct>"}" has no active waiters.`))}}}function register(scope,kind,rawName,definition){const name=normalizeName(rawName,kind);assertDefinition(definition,kind,name);const store=stores[scope][kind];if(store.has(name)){throw new contracts.GridComponentError(`${scope} ${kind} component "${name}" is already registered.`,{code:"DUPLICATE_COMPONENT",phase:"lookup",componentKind:kind,componentName:name,retryable:true})}store.set(name,definition)}function replace(scope,kind,rawName,definition){const name=normalizeName(rawName,kind);const store=stores[scope][kind];if(!store.has(name)){throw new contracts.GridComponentError(`${scope} ${kind} component "${name}" cannot be replaced because it is not registered.`,{code:"COMPONENT_NOT_FOUND",phase:"lookup",componentKind:kind,componentName:name,retryable:true})}assertDefinition(definition,kind,name);const previous=store.get(name);store.set(name,definition);if(isGridLazyComponentDefinition(previous)){invalidateLazyContext(previous,kind,name,new Error(`${scope} ${kind} component "${name}" was replaced.`))}}function unregister(scope,kind,rawName){const name=normalizeName(rawName,kind);const store=stores[scope][kind];const previous=store.get(name);const removed=store.delete(name);if(isGridLazyComponentDefinition(previous)){invalidateLazyContext(previous,kind,name,new Error(`${scope} ${kind} component "${name}" was unregistered.`))}return removed}async function resolve(request){const suppliedName=typeof request.name==="string"&&request.name.trim().length>0?request.name.trim():void 0;let candidate;let origin="direct";let name=suppliedName;let found=false;if(hasOwn$1(request,"definition")){candidate=request.definition;found=true}else{name=normalizeName(request.name,request.kind);const requestLocal=localLookup(request.local,request.kind,name);if(requestLocal.found){candidate=requestLocal.value;origin="local";found=true}else if(stores.local[request.kind].has(name)){candidate=stores.local[request.kind].get(name);origin="local";found=true}else if(stores.global[request.kind].has(name)){candidate=stores.global[request.kind].get(name);origin="global";found=true}}if(!found){throw new contracts.GridComponentError(`${request.kind} component "${name??"<direct>"}" was not found.`,{code:"COMPONENT_NOT_FOUND",phase:"lookup",componentKind:request.kind,componentName:name,retryable:true})}const captured=assertDefinition(candidate,request.kind,name);let eager;if(captured.type==="lazy"){eager=await resolveLazyDefinition(candidate,request.kind,name,request.signal)}else{rememberCapturedEager(candidate,captured.definition);eager=candidate}return{kind:request.kind,name,origin,definition:eager}}return{register,replace,unregister,has(scope,kind,rawName){const name=normalizeName(rawName,kind);return stores[scope][kind].has(name)},list(scope,kind){return[...stores[scope][kind].keys()]},resolve,invalidateLazy(scope,kind,rawName){const name=normalizeName(rawName,kind);const definition=stores[scope][kind].get(name);return isGridLazyComponentDefinition(definition)?invalidateLazyContext(definition,kind,name,new Error(`${scope} ${kind} component "${name}" lazy cache was invalidated.`)):false},clear(scope){if(!scope){const flights=[...activeLazyFlights];for(const selected of["local","global"]){for(const kind of["renderer","editor","filter","floatingFilter"]){stores[selected][kind].clear()}}lazyContexts=new WeakMap;for(const flight of flights){abortLazyFlight(flight,new Error("Grid component registry was cleared."))}return}const registrations=[];for(const kind of["renderer","editor","filter","floatingFilter"]){for(const[name,definition]of stores[scope][kind]){registrations.push([kind,name,definition])}stores[scope][kind].clear()}for(const[kind,name,definition]of registrations){if(isGridLazyComponentDefinition(definition)){invalidateLazyContext(definition,kind,name,new Error(`${scope} ${kind} component "${name}" was cleared.`))}}}}}const DEFAULT_COMPONENT_TIMEOUT_MS=5e3;const RUNTIME_DESTROYED_INSTANCES=new WeakSet;const RUNTIME_DESTROY_TASKS=new WeakMap;const RUNTIME_INSTANCE_OWNERS=new WeakMap;const RUNTIME_GUI_OWNERS=new WeakMap;function isRealmHTMLElement(value){return typeof HTMLElement!=="undefined"&&value instanceof HTMLElement}function isWeakKey(value){return value!==null&&(typeof value==="object"||typeof value==="function")}function lifecycleCode(phase){switch(phase){case"create":return"CREATE_FAILED";case"init":return"INIT_FAILED";case"gui":return"GUI_FAILED";case"refresh":return"REFRESH_FAILED";case"destroy":return"DESTROY_FAILED"}}function lifecycleError$1(phase,kind,key,generation,componentName,cause){if(cause instanceof contracts.GridComponentError)return cause;return new contracts.GridComponentError(`${kind} component "${componentName??key}" failed during ${phase}.`,{code:lifecycleCode(phase),phase,componentKind:kind,componentName,mountKey:key,generation,retryable:true,cause})}function timeoutError(phase,kind,key,generation,componentName,timeoutMs){return new contracts.GridComponentError(`${kind} component "${componentName??key}" timed out during ${phase} after ${timeoutMs}ms.`,{code:"TIMEOUT",phase,componentKind:kind,componentName,mountKey:key,generation,retryable:true})}function abortError(phase,kind,key,generation,componentName,cause){return new contracts.GridComponentError(`${kind} component "${componentName??key}" was aborted during ${phase}.`,{code:"ABORTED",phase,componentKind:kind,componentName,mountKey:key,generation,retryable:true,cause})}async function waitForStep(raw,options){return new Promise((resolve,reject)=>{let settled=false;let timeoutHandle;let onAbort;const cleanup=()=>{if(timeoutHandle)clearTimeout(timeoutHandle);if(options.signal&&onAbort){options.signal.removeEventListener("abort",onAbort)}};const resolveOnce=value=>{if(settled)return;settled=true;cleanup();resolve(value)};const rejectOnce=cause=>{if(settled)return;settled=true;cleanup();reject(cause)};void raw.then(resolveOnce,rejectOnce);if(options.signal?.aborted){rejectOnce(abortError(options.phase==="destroy"?"create":options.phase,options.kind,options.key,options.generation,options.componentName,options.signal.reason));return}if(options.signal){onAbort=()=>rejectOnce(abortError(options.phase==="destroy"?"create":options.phase,options.kind,options.key,options.generation,options.componentName,options.signal?.reason));options.signal.addEventListener("abort",onAbort,{once:true})}timeoutHandle=setTimeout(()=>{if(settled)return;settled=true;cleanup();reject(timeoutError(options.phase,options.kind,options.key,options.generation,options.componentName,options.timeoutMs));try{options.abortOnTimeout?.()}catch{}},options.timeoutMs)})}function createGridComponentRuntime(options){const timeoutMs=options.timeoutMs??DEFAULT_COMPONENT_TIMEOUT_MS;const isGuiElement=options.isGuiElement??isRealmHTMLElement;const activeGenerations=new Map;const attempts=new Map;const mounted=new Map;let generationSequence=0;let destroyedCount=0;let disposed=false;function report(error){try{options.onError?.(error)}catch{}}function reserveGeneration(key){const next=++generationSequence;activeGenerations.set(key,next);return next}function releaseGeneration(key,generation){if(activeGenerations.get(key)===generation){activeGenerations.delete(key)}}function currentAttempt(attempt){return attempts.get(attempt.key)===attempt&&activeGenerations.get(attempt.key)===attempt.generation&&!disposed}function makeParams(key,params,signal){return{...params,componentKind:options.kind,instanceId:key,signal}}function fallback(error,params){try{return options.fallback?.(error,params)}catch{return void 0}}function claimGui(gui,claim,context){if(!isGuiElement(gui))return void 0;const identity=gui;const owner=RUNTIME_GUI_OWNERS.get(identity);if(owner!==void 0&&owner!==claim){throw new contracts.GridComponentError(`${options.kind} component "${context.componentName??context.key}" returned an HTMLElement owned by another live component instance.`,{code:"INVALID_INSTANCE",phase:"gui",componentKind:options.kind,componentName:context.componentName,mountKey:context.key,generation:context.generation,retryable:true})}RUNTIME_GUI_OWNERS.set(identity,claim);return identity}function releaseGui(identity,claim){if(identity!==void 0&&claim!==void 0&&RUNTIME_GUI_OWNERS.get(identity)===claim){RUNTIME_GUI_OWNERS.delete(identity)}}async function destroyOnce(instance,context,claim,guiIdentity){if(!isWeakKey(instance)){releaseGui(guiIdentity,claim);return}const identity=instance;const owner=RUNTIME_INSTANCE_OWNERS.get(identity);if(owner!==void 0&&owner!==claim)return;const existingTask=RUNTIME_DESTROY_TASKS.get(identity);if(existingTask){await existingTask;return}if(RUNTIME_DESTROYED_INSTANCES.has(identity))return;RUNTIME_DESTROYED_INSTANCES.add(identity);if(owner===claim)RUNTIME_INSTANCE_OWNERS.delete(identity);destroyedCount+=1;const task=(async()=>{const raw=Promise.resolve().then(()=>{const destroy2=instance.destroy;if(typeof destroy2!=="function")return;return destroy2.call(instance)});void raw.then(()=>releaseGui(guiIdentity,claim),()=>releaseGui(guiIdentity,claim));try{await waitForStep(raw,{phase:"destroy",kind:options.kind,key:context.key,generation:context.generation,componentName:context.componentName,timeoutMs})}catch(cause){const error=cause instanceof contracts.GridComponentError?cause:lifecycleError$1("destroy",options.kind,context.key,context.generation,context.componentName,cause);report(error)}})();RUNTIME_DESTROY_TASKS.set(identity,task);await task}async function retireKey(key,preserveGeneration){const attempt=attempts.get(key);const record=mounted.get(key);if(attempt)attempts.delete(key);if(record)mounted.delete(key);if(preserveGeneration===void 0){activeGenerations.delete(key)}attempt?.removeParentAbort();record?.removeParentAbort();attempt?.controller.abort("component retired");record?.controller.abort("component retired");const pending=[];if(attempt?.instance){pending.push(destroyOnce(attempt.instance,{key,generation:attempt.generation,componentName:attempt.componentName},attempt.claim,attempt.guiIdentity))}if(record){pending.push(destroyOnce(record.instance,{key,generation:record.generation,componentName:record.componentName},record.claim,record.guiIdentity))}await Promise.all(pending);return Boolean(attempt||record)}function linkParentAbort(key,parentSignal,controller){if(!parentSignal)return()=>void 0;const onAbort=()=>{controller.abort(parentSignal.reason);void destroy(key)};parentSignal.addEventListener("abort",onAbort,{once:true});return()=>parentSignal.removeEventListener("abort",onAbort)}function failedResult(key,generation,error,params){report(error);const fallbackGui=fallback(error,params);return fallbackGui===void 0?{status:"failed",key,generation,error}:{status:"failed",key,generation,error,fallbackGui}}function captureCreatedInstance(value,attempt){if(attempt.candidateCaptured)return;attempt.candidateCaptured=true;attempt.instance=value;const invalid=cause=>new contracts.GridComponentError(`${options.kind} component "${attempt.componentName??attempt.key}" did not return a GUI lifecycle instance.`,{code:"INVALID_INSTANCE",phase:"create",componentKind:options.kind,componentName:attempt.componentName,mountKey:attempt.key,generation:attempt.generation,retryable:true,cause});if(!isWeakKey(value)){attempt.validationError=invalid();return}const instance=value;const identity=value;if(!RUNTIME_DESTROYED_INSTANCES.has(identity)&&!RUNTIME_INSTANCE_OWNERS.has(identity)){const claim={key:attempt.key,generation:attempt.generation,token:attempt.generation};RUNTIME_INSTANCE_OWNERS.set(identity,claim);attempt.claim=claim}try{const getGui=value.getGui;if(typeof getGui!=="function"){attempt.validationError=invalid()}else{attempt.getGuiMethod=getGui}}catch(cause){attempt.validationError=invalid(cause)}if(!currentAttempt(attempt)){void destroyOnce(instance,{key:attempt.key,generation:attempt.generation,componentName:attempt.componentName},attempt.claim,attempt.guiIdentity);return}if(attempt.validationError!==void 0)return;try{const init=value.init;if(init!==void 0&&typeof init!=="function"){attempt.initCaptureFailed=true;attempt.initCaptureError=new TypeError("Component init must be a function when provided.")}else{attempt.initMethod=init}}catch(cause){attempt.initCaptureFailed=true;attempt.initCaptureError=cause}if(!currentAttempt(attempt)){void destroyOnce(instance,{key:attempt.key,generation:attempt.generation,componentName:attempt.componentName},attempt.claim,attempt.guiIdentity)}}async function createFromEager(eager,params,attempt){const raw=Promise.resolve().then(()=>{if(!currentAttempt(attempt)||attempt.controller.signal.aborted){throw abortError("create",options.kind,attempt.key,attempt.generation,attempt.componentName,attempt.controller.signal.reason)}if(eager.type==="class")return new eager.component;return eager.create({params,signal:attempt.controller.signal})});void raw.then(instance=>captureCreatedInstance(instance,attempt),()=>void 0);return waitForStep(raw,{phase:"create",kind:options.kind,key:attempt.key,generation:attempt.generation,componentName:attempt.componentName,timeoutMs,signal:attempt.controller.signal,abortOnTimeout:()=>attempt.controller.abort("create timeout")})}async function mount(request){const generation=reserveGeneration(request.key);await retireKey(request.key,generation);const controller=new AbortController;const params=makeParams(request.key,request.params,controller.signal);if(disposed){releaseGeneration(request.key,generation);const error=abortError("create",options.kind,request.key,generation,request.componentName,"runtime disposed");return failedResult(request.key,generation,error,params)}if(activeGenerations.get(request.key)!==generation){return{status:"stale",key:request.key,generation}}const parentSignal=request.params.signal;if(parentSignal?.aborted){controller.abort(parentSignal.reason);releaseGeneration(request.key,generation);const error=abortError("create",options.kind,request.key,generation,request.componentName,parentSignal.reason);return failedResult(request.key,generation,error,params)}const removeParentAbort=linkParentAbort(request.key,parentSignal,controller);const attempt={key:request.key,generation,componentName:request.componentName,controller,removeParentAbort};attempts.set(request.key,attempt);let instance;try{const eagerRaw=resolveGridComponentDefinition(request.definition,{kind:options.kind,name:request.componentName,signal:controller.signal});const resolvedEager=await waitForStep(eagerRaw,{phase:"lazy-load",kind:options.kind,key:request.key,generation,componentName:request.componentName,timeoutMs,signal:controller.signal,abortOnTimeout:()=>controller.abort("lazy-load timeout")});if(!currentAttempt(attempt)){return{status:"stale",key:request.key,generation}}const eager=getCapturedGridEagerDefinition(resolvedEager);instance=await createFromEager(eager,params,attempt);captureCreatedInstance(instance,attempt);if(attempt.validationError!==void 0){throw attempt.validationError}if(!currentAttempt(attempt)){await destroyOnce(instance,{key:request.key,generation,componentName:request.componentName},attempt.claim,attempt.guiIdentity);return{status:"stale",key:request.key,generation}}const identity=instance;if(RUNTIME_DESTROYED_INSTANCES.has(identity)||!attempt.claim||RUNTIME_INSTANCE_OWNERS.get(identity)!==attempt.claim){throw new contracts.GridComponentError(`${options.kind} component "${request.componentName??request.key}" returned a reused lifecycle instance.`,{code:"INVALID_INSTANCE",phase:"create",componentKind:options.kind,componentName:request.componentName,mountKey:request.key,generation,retryable:true})}if(attempt.initCaptureFailed===true){throw lifecycleError$1("init",options.kind,request.key,generation,request.componentName,attempt.initCaptureError)}const initMethod=attempt.initMethod;if(typeof initMethod==="function"){const initRaw=Promise.resolve().then(()=>{if(!currentAttempt(attempt)||controller.signal.aborted){return}return initMethod.call(instance,params)});await waitForStep(initRaw,{phase:"init",kind:options.kind,key:request.key,generation,componentName:request.componentName,timeoutMs,signal:controller.signal,abortOnTimeout:()=>controller.abort("init timeout")})}if(!currentAttempt(attempt)){await destroyOnce(instance,{key:request.key,generation,componentName:request.componentName},attempt.claim,attempt.guiIdentity);return{status:"stale",key:request.key,generation}}let gui;try{const getGuiMethod=attempt.getGuiMethod;if(typeof getGuiMethod!=="function"){throw new TypeError("Component getGui must be a function.")}if(!currentAttempt(attempt)){await destroyOnce(instance,{key:request.key,generation,componentName:request.componentName},attempt.claim,attempt.guiIdentity);return{status:"stale",key:request.key,generation}}gui=getGuiMethod.call(instance);await Promise.resolve()}catch(cause){throw lifecycleError$1("gui",options.kind,request.key,generation,request.componentName,cause)}if(!currentAttempt(attempt)){await destroyOnce(instance,{key:request.key,generation,componentName:request.componentName},attempt.claim,attempt.guiIdentity);return{status:"stale",key:request.key,generation}}attempt.guiIdentity=claimGui(gui,attempt.claim,{key:request.key,generation,componentName:request.componentName});if(!currentAttempt(attempt)){releaseGui(attempt.guiIdentity,attempt.claim);attempt.guiIdentity=void 0;await destroyOnce(instance,{key:request.key,generation,componentName:request.componentName},attempt.claim,void 0);return{status:"stale",key:request.key,generation}}attempts.delete(request.key);mounted.set(request.key,{key:request.key,generation,componentName:request.componentName,definition:request.definition,controller,removeParentAbort,claim:attempt.claim,instance,getGuiMethod:attempt.getGuiMethod,params,gui,guiIdentity:attempt.guiIdentity,refreshTail:Promise.resolve()});return{status:"mounted",key:request.key,generation,instance,gui}}catch(cause){const stale=!currentAttempt(attempt);if(attempts.get(request.key)===attempt)attempts.delete(request.key);releaseGeneration(request.key,generation);removeParentAbort();controller.abort("component mount failed");if(isWeakKey(instance)){await destroyOnce(instance,{key:request.key,generation,componentName:request.componentName},attempt.claim,attempt.guiIdentity)}if(stale){return{status:"stale",key:request.key,generation}}const error=cause instanceof contracts.GridComponentError?cause:lifecycleError$1(instance?"init":"create",options.kind,request.key,generation,request.componentName,cause);return failedResult(request.key,generation,error,params)}}async function refreshRecord(key,input,record){if(mounted.get(key)!==record){return{status:"stale",key,generation:record.generation}}const params=makeParams(key,input,record.controller.signal);const failRefresh=async cause=>{if(mounted.get(key)!==record){return{status:"stale",key,generation:record.generation}}mounted.delete(key);releaseGeneration(key,record.generation);record.removeParentAbort();record.controller.abort("refresh failed");await destroyOnce(record.instance,{key,generation:record.generation,componentName:record.componentName},record.claim,record.guiIdentity);const error=cause instanceof contracts.GridComponentError?cause:lifecycleError$1("refresh",options.kind,key,record.generation,record.componentName,cause);report(error);const fallbackGui=fallback(error,params);return fallbackGui===void 0?{status:"failed",key,generation:record.generation,error}:{status:"failed",key,generation:record.generation,error,fallbackGui}};let refreshMethod;try{const candidate=record.instance.refresh;if(candidate!==void 0&&typeof candidate!=="function"){throw new TypeError("Component refresh must be a function when provided.")}refreshMethod=candidate}catch(cause){return failRefresh(cause)}if(mounted.get(key)!==record){return{status:"stale",key,generation:record.generation}}if(typeof refreshMethod!=="function"){const recreated=await mount({key,componentName:record.componentName,definition:record.definition,params:input});if(recreated.status==="mounted"){return{...recreated,status:"recreated"}}return recreated}let refreshed;try{const raw=Promise.resolve().then(()=>{if(mounted.get(key)!==record||record.controller.signal.aborted){return false}return refreshMethod.call(record.instance,params)});refreshed=await waitForStep(raw,{phase:"refresh",kind:options.kind,key,generation:record.generation,componentName:record.componentName,timeoutMs,signal:record.controller.signal,abortOnTimeout:()=>record.controller.abort("refresh timeout")});if(typeof refreshed!=="boolean"){throw new TypeError("Component refresh must return a boolean.")}}catch(cause){return failRefresh(cause)}if(mounted.get(key)!==record){return{status:"stale",key,generation:record.generation}}if(!refreshed){const recreated=await mount({key,componentName:record.componentName,definition:record.definition,params:input});if(recreated.status==="mounted"){return{...recreated,status:"recreated"}}return recreated}let gui;let guiIdentity;try{gui=record.getGuiMethod.call(record.instance);await Promise.resolve();if(mounted.get(key)!==record){return{status:"stale",key,generation:record.generation}}guiIdentity=claimGui(gui,record.claim,{key,generation:record.generation,componentName:record.componentName})}catch(cause){mounted.delete(key);releaseGeneration(key,record.generation);record.removeParentAbort();record.controller.abort("GUI refresh failed");await destroyOnce(record.instance,{key,generation:record.generation,componentName:record.componentName},record.claim,record.guiIdentity);const error=cause instanceof contracts.GridComponentError?cause:lifecycleError$1("gui",options.kind,key,record.generation,record.componentName,cause);report(error);const fallbackGui=fallback(error,params);return fallbackGui===void 0?{status:"failed",key,generation:record.generation,error}:{status:"failed",key,generation:record.generation,error,fallbackGui}}if(mounted.get(key)!==record){if(guiIdentity!==record.guiIdentity){releaseGui(guiIdentity,record.claim)}return{status:"stale",key,generation:record.generation}}if(record.guiIdentity!==guiIdentity){releaseGui(record.guiIdentity,record.claim)}record.params=params;record.gui=gui;record.guiIdentity=guiIdentity;return{status:"refreshed",key,generation:record.generation,instance:record.instance,gui}}async function refresh(key,input){const record=mounted.get(key);if(!record)return{status:"not-mounted",key};let releaseTurn;const turn=new Promise(resolve=>{releaseTurn=resolve});const previous=record.refreshTail;record.refreshTail=previous.then(()=>turn,()=>turn);await previous.catch(()=>void 0);try{return await refreshRecord(key,input,record)}finally{releaseTurn?.()}}function lookup(key){const record=mounted.get(key);return record?{status:"mounted",key,generation:record.generation,instance:record.instance,params:record.params,gui:record.gui}:{status:"unmounted",key}}async function destroy(key){return retireKey(key)}async function destroyAll(){const keys=new Set([...activeGenerations.keys(),...attempts.keys(),...mounted.keys()]);await Promise.all([...keys].map(key=>destroy(key)))}async function dispose(){if(disposed)return;disposed=true;await destroyAll()}return{mount,refresh,lookup,listMounted(){return[...mounted.keys()].map(key=>lookup(key)).filter(value=>value.status==="mounted")},destroy,destroyAll,dispose,stats(){return{mounted:mounted.size,inFlight:attempts.size,destroyed:destroyedCount,disposed}}}}const CLAIMED_RENDERER_INSTANCES=new WeakSet;const RENDERER_DESTROY_TASKS=new WeakMap;function isRendererWeakKey(value){return value!==null&&(typeof value==="object"||typeof value==="function")}function invalidRendererInstance(instanceId,cause){return new contracts.GridComponentError(`Renderer "${instanceId}" returned a malformed or reused lifecycle instance.`,{code:"INVALID_INSTANCE",phase:"create",componentKind:"renderer",mountKey:instanceId,retryable:true,cause})}function destroyUnderlyingRenderer(instance,capturedDestroy,destroyWasCaptured=false){const existing=RENDERER_DESTROY_TASKS.get(instance);if(existing!==void 0)return existing;const task=Promise.resolve().then(()=>{const destroy=destroyWasCaptured?capturedDestroy:instance.destroy;if(typeof destroy!=="function")return;return destroy.call(instance)}).then(()=>void 0);RENDERER_DESTROY_TASKS.set(instance,task);return task}function captureRendererMethods(instance,onDestroyRead){let destroy;try{destroy=instance.destroy}catch(cause){onDestroyRead(void 0);throw cause}onDestroyRead(typeof destroy==="function"?destroy:void 0);if(destroy!==void 0&&typeof destroy!=="function"){throw new TypeError("Renderer destroy must be a function when provided.")}const rendererDestroy=destroy;const getGui=instance.getGui;if(typeof getGui!=="function"){throw new TypeError("Renderer getGui must be a function.")}const init=instance.init;const refresh=instance.refresh;const focusIn=instance.focusIn;const focusOut=instance.focusOut;for(const[name,method]of[["init",init],["refresh",refresh],["focusIn",focusIn],["focusOut",focusOut]]){if(method!==void 0&&typeof method!=="function"){throw new TypeError(`Renderer ${name} must be a function when provided.`)}}return{getGui,...init===void 0?{}:{init},...refresh===void 0?{}:{refresh},...focusIn===void 0?{}:{focusIn},...focusOut===void 0?{}:{focusOut},...rendererDestroy===void 0?{}:{destroy:rendererDestroy}}}function scopeRendererParams(params,lease){const setTooltip=params.setTooltip;const handoffFocus=params.handoffFocus;return{...params,setTooltip(value){if(lease.active)setTooltip(value)},handoffFocus(target){if(lease.active)handoffFocus(target)}}}function createScopedRendererInstance(instance,lease,methods){return{...methods.init===void 0?{}:{init(params){return methods.init.call(instance,scopeRendererParams(params,lease))}},getGui(){return methods.getGui.call(instance)},...methods.refresh===void 0?{}:{refresh(params){return methods.refresh.call(instance,scopeRendererParams(params,lease))}},...methods.focusIn===void 0?{}:{focusIn(){methods.focusIn.call(instance)}},...methods.focusOut===void 0?{}:{focusOut(){methods.focusOut.call(instance)}},destroy(){lease.active=false;return destroyUnderlyingRenderer(instance,methods.destroy,true)}}}function scopeEagerRendererDefinition(definition,claimedInstances){return{type:"factory",async create(context){const lease={active:true};const scopedParams=scopeRendererParams(context.params,lease);try{const candidate=definition.type==="class"?new definition.component:await definition.create({params:scopedParams,signal:context.signal});if(!isRendererWeakKey(candidate)){return candidate}if(claimedInstances.has(candidate)){throw invalidRendererInstance(context.params.instanceId)}claimedInstances.add(candidate);const instance=candidate;let capturedDestroy;let destroyWasRead=false;let methods;try{methods=captureRendererMethods(instance,destroy=>{destroyWasRead=true;capturedDestroy=destroy})}catch(cause){lease.active=false;try{await destroyUnderlyingRenderer(candidate,capturedDestroy,destroyWasRead)}catch(destroyCause){throw invalidRendererInstance(context.params.instanceId,new AggregateError([cause,destroyCause],"Renderer validation and cleanup both failed."))}throw invalidRendererInstance(context.params.instanceId,cause)}return createScopedRendererInstance(instance,lease,methods)}catch(cause){lease.active=false;throw cause}}}}function scopeRendererDefinition(definition,claimedInstances){if(definition.type!=="lazy"){return scopeEagerRendererDefinition(definition,claimedInstances)}return{type:"lazy",async load(context){return scopeEagerRendererDefinition(await definition.load(context),claimedInstances)}}}function projectPureRendererInput(params){return{value:params.value,row:params.row,rowIndex:params.rowIndex,colIndex:params.colIndex,colId:params.colId,formatted:params.formatted,meta:params.meta}}class PureRendererLifecycle{output;destroyed=false;renderer;constructor(renderer){this.renderer=renderer}init(params){this.output=this.renderer(projectPureRendererInput(params))}getGui(){if(!this.output||this.destroyed){throw new Error("Pure renderer GUI requested outside its mounted lifecycle.")}return this.output}refresh(params){if(this.destroyed)return false;this.output=this.renderer(projectPureRendererInput(params));return true}destroy(){if(this.destroyed)return;this.destroyed=true;this.output=void 0}}function adaptPureCellRenderer(renderer){return{type:"factory",create:()=>new PureRendererLifecycle(renderer)}}function normalizeGridRendererSource(source){return typeof source==="function"?adaptPureCellRenderer(source):source}function createGridRendererAdapter(options={}){const runtime=createGridComponentRuntime({...options,kind:"renderer"});return{runtime,mount(request){return runtime.mount({key:request.key,componentName:request.componentName,definition:scopeRendererDefinition(normalizeGridRendererSource(request.source),CLAIMED_RENDERER_INSTANCES),params:request.params})},refresh(key,params){return runtime.refresh(key,params)}}}function createGridRendererCellKey(identity){return`cell:${JSON.stringify([identity.rowId,identity.colId])}`}const DEFAULT_MAX_RETAINED_OFFSCREEN_RECORDS=256;function resolveKey(identityOrKey){return typeof identityOrKey==="string"?identityOrKey:createGridRendererCellKey(identityOrKey)}function parseRendererCellKey(key){if(!key.startsWith("cell:"))return void 0;try{const parsed=JSON.parse(key.slice("cell:".length));if(!Array.isArray(parsed)||parsed.length!==2)return void 0;const[rowId,colId]=parsed;if(typeof rowId!=="string"&&typeof rowId!=="number"||typeof colId!=="string"){return void 0}return{rowId,colId}}catch{return void 0}}function defaultIsElement(value){if(value===null||typeof value!=="object")return false;if(typeof HTMLElement!=="undefined"&&value instanceof HTMLElement){return true}return value.nodeType===1}function defaultIsHostConnected(host){const candidate=host;return typeof candidate.isConnected==="boolean"?candidate.isConnected:true}function isCellRenderOutput(value){if(value===null||typeof value!=="object")return false;const candidate=value;if(candidate.kind==="text")return typeof candidate.text==="string";if(candidate.kind==="html")return typeof candidate.html==="string";return candidate.kind==="vnode"}function rendererControllerError(code,phase,key,generation,componentName,message,cause){return new contracts.GridComponentError(message,{code,phase,componentKind:"renderer",componentName,mountKey:key,generation,retryable:true,cause})}function createGridRendererController(options={}){const isElement=options.isElement??options.runtime?.isGuiElement??defaultIsElement;const adapter=createGridRendererAdapter({...options.runtime,isGuiElement:isElement});const checkHostConnected=options.isHostConnected??defaultIsHostConnected;const maxRetainedOffscreenRecords=typeof options.maxRetainedOffscreenRecords==="number"&&Number.isFinite(options.maxRetainedOffscreenRecords)?Math.max(0,Math.floor(options.maxRetainedOffscreenRecords)):DEFAULT_MAX_RETAINED_OFFSCREEN_RECORDS;const records=new Map;const offscreenRecords=new Map;const hostOwners=new WeakMap;const guiOwners=new WeakMap;let tokenSequence=0;let disposed=false;let disposeTask;function report(error){try{options.onError?.(error)}catch{}}function hostIsConnected(host){try{return checkHostConnected(host)}catch{return false}}function logicalCellExists(identity,key){if(!options.logicalExists)return void 0;try{return options.logicalExists(identity,key)}catch{return false}}function clearHostIfOwned(host,claim){if(!host||!claim||hostOwners.get(host)!==claim)return;hostOwners.delete(host);host.replaceChildren()}function releaseGui(record){if(record.guiClaim&&record.gui&&isElement(record.gui)&&guiOwners.get(record.gui)===record.guiClaim){guiOwners.delete(record.gui)}record.guiClaim=void 0;record.gui=void 0}function forgetOffscreenRecord(record){if(records.get(record.key)!==record||record.state!=="offscreen"||record.host!==void 0){return}offscreenRecords.delete(record.key);records.delete(record.key);releaseGui(record)}function rememberOffscreenRecord(record){if(disposed||records.get(record.key)!==record||record.state!=="offscreen"||record.host!==void 0){return}if(logicalCellExists(record.identity,record.key)===false){forgetOffscreenRecord(record);return}offscreenRecords.delete(record.key);offscreenRecords.set(record.key,record);while(offscreenRecords.size>maxRetainedOffscreenRecords){const oldest=offscreenRecords.entries().next().value;if(!oldest)break;offscreenRecords.delete(oldest[0]);forgetOffscreenRecord(oldest[1])}}function isCurrent(record,token,claim){return!disposed&&records.get(record.key)===record&&record.token===token&&record.hostClaim===claim&&record.host!==void 0&&hostOwners.get(record.host)===claim}async function destroyRuntimeGeneration(key,generation){const lookup2=adapter.runtime.lookup(key);if(lookup2.status!=="mounted"||generation!==void 0&&lookup2.generation!==generation){return false}return adapter.runtime.destroy(key)}async function retireRecord(record,clearHost){const retirementToken=++tokenSequence;record.token=retirementToken;record.state="offscreen";const generation=record.generation;const host=record.host;const hostClaim=record.hostClaim;record.host=void 0;record.hostClaim=void 0;if(clearHost)clearHostIfOwned(host,hostClaim);releaseGui(record);const destroyed=generation===void 0?await adapter.runtime.destroy(record.key):await destroyRuntimeGeneration(record.key,generation);if(records.get(record.key)===record&&record.token===retirementToken&&record.state==="offscreen"&&record.host===void 0){rememberOffscreenRecord(record)}return destroyed}function guiOwnerIsReserved(gui,claim){const owner=records.get(claim.key);return Boolean(owner&&owner.gui===gui&&owner.guiClaim===claim)}function paintGui(gui,record,generation,request){const host=request.host;if(isElement(gui)){const existing=guiOwners.get(gui);if(existing&&existing.key!==record.key&&guiOwnerIsReserved(gui,existing)){return rendererControllerError("INVALID_INSTANCE","gui",record.key,generation,request.componentName,`Renderer "${request.componentName??record.key}" reused an HTMLElement owned by another live component.`)}if(host.firstChild!==gui||host.childNodes?.length!==1){host.replaceChildren(gui)}releaseGui(record);const claim={key:record.key,generation};guiOwners.set(gui,claim);record.gui=gui;record.guiClaim=claim;return void 0}if(!isCellRenderOutput(gui)){return rendererControllerError("GUI_FAILED","gui",record.key,generation,request.componentName,`Renderer "${request.componentName??record.key}" returned a malformed GUI.`)}releaseGui(record);if(gui.kind==="text"){host.textContent=gui.text}else if(gui.kind==="html"){host.innerHTML=gui.html}else{if(!options.paintVNode){return rendererControllerError("FRAMEWORK_FAILED","framework",record.key,generation,request.componentName,`Renderer "${request.componentName??record.key}" returned a VNode without a painter.`)}try{host.replaceChildren();options.paintVNode(host,gui.vnode,{key:record.key,generation,request})}catch(cause){return rendererControllerError("FRAMEWORK_FAILED","framework",record.key,generation,request.componentName,`Renderer "${request.componentName??record.key}" VNode painter failed.`,cause)}}record.gui=gui;return void 0}async function failPaint(error,record,token,claim,generation,request){report(error);await destroyRuntimeGeneration(record.key,generation);releaseGui(record);if(!isCurrent(record,token,claim)){return{status:"stale",key:record.key,generation}}if(!hostIsConnected(request.host)){await retireRecord(record,true);return{status:"stale",key:record.key,generation}}record.state="offscreen";record.generation=generation;let fallbackPainted=false;let fallback;try{fallback=options.fallback?.(error,{key:record.key,generation,request})}catch{fallback=void 0}if(fallback!==void 0){if(!hostIsConnected(request.host)){await retireRecord(record,true);return{status:"stale",key:record.key,generation}}const fallbackError=paintGui(fallback,record,generation,request);if(!fallbackError){fallbackPainted=true;record.state="fallback"}else{report(fallbackError);clearHostIfOwned(record.host,record.hostClaim);record.host=void 0;record.hostClaim=void 0;releaseGui(record);rememberOffscreenRecord(record)}}else{clearHostIfOwned(record.host,record.hostClaim);record.host=void 0;record.hostClaim=void 0;rememberOffscreenRecord(record)}if(fallbackPainted&&isCurrent(record,token,claim)&&!hostIsConnected(request.host)){await retireRecord(record,true);return{status:"stale",key:record.key,generation}}return{status:"failed",key:record.key,generation,error,fallbackPainted}}async function render(request){const key=createGridRendererCellKey(request.identity);if(disposed){return{status:"stale",key}}if(!hostIsConnected(request.host)){const owner=hostOwners.get(request.host);const ownedRecord=owner?records.get(owner.key):void 0;const generation=ownedRecord?.host===request.host&&ownedRecord.hostClaim===owner?ownedRecord.generation:void 0;if(ownedRecord?.host===request.host&&ownedRecord.hostClaim===owner){await retireRecord(ownedRecord,true)}return{status:"stale",key,...generation===void 0?{}:{generation}}}let record=records.get(key);const sourceUnchanged=record?.source===request.source&&record.componentName===request.componentName;if(!record){record={key,identity:request.identity,token:0,state:"offscreen",source:request.source,componentName:request.componentName,host:void 0,hostClaim:void 0,generation:void 0,gui:void 0,guiClaim:void 0};records.set(key,record)}offscreenRecords.delete(key);const previousHost=record.host;const previousHostClaim=record.hostClaim;const previousOwner=hostOwners.get(request.host);const token=++tokenSequence;const claim={key,token};record.token=token;record.state="pending";record.source=request.source;record.componentName=request.componentName;record.host=request.host;record.hostClaim=claim;record.generation=void 0;hostOwners.set(request.host,claim);if(previousHost&&previousHost!==request.host){clearHostIfOwned(previousHost,previousHostClaim)}if(previousOwner&&previousOwner.key!==key){const previousRecord=records.get(previousOwner.key);if(previousRecord&&previousRecord.hostClaim===previousOwner){await retireRecord(previousRecord,false)}}if(!isCurrent(record,token,claim)){return{status:"stale",key,generation:record.generation}}if(!hostIsConnected(request.host)){await retireRecord(record,true);return{status:"stale",key,generation:record.generation}}const existing=adapter.runtime.lookup(key);let result;if(existing.status==="mounted"&&sourceUnchanged){result=await adapter.refresh(key,request.params);if(result.status==="not-mounted"&&isCurrent(record,token,claim)){result=await adapter.mount({key,componentName:request.componentName,source:request.source,params:request.params})}}else{result=await adapter.mount({key,componentName:request.componentName,source:request.source,params:request.params})}if(!isCurrent(record,token,claim)){return{status:"stale",key,generation:"generation"in result?result.generation:record.generation}}if(!hostIsConnected(request.host)){const generation="generation"in result?result.generation:record.generation;await retireRecord(record,true);return{status:"stale",key,...generation===void 0?{}:{generation}}}if(result.status==="stale"||result.status==="not-mounted"){const generation="generation"in result?result.generation:record.generation;await retireRecord(record,true);return{status:"stale",key,...generation===void 0?{}:{generation}}}if(result.status==="failed"){record.state="offscreen";record.generation=result.generation;releaseGui(record);let fallbackPainted=false;if(result.fallbackGui!==void 0){const fallbackError=paintGui(result.fallbackGui,record,result.generation,request);fallbackPainted=fallbackError===void 0;if(fallbackPainted)record.state="fallback";if(fallbackError)report(fallbackError)}if(!fallbackPainted){clearHostIfOwned(record.host,record.hostClaim);record.host=void 0;record.hostClaim=void 0;rememberOffscreenRecord(record)}else if(!hostIsConnected(request.host)){await retireRecord(record,true);return{status:"stale",key,generation:result.generation}}return{status:"failed",key,generation:result.generation,error:result.error,fallbackPainted}}const runtimeLookup=adapter.runtime.lookup(key);if(runtimeLookup.status!=="mounted"||runtimeLookup.generation!==result.generation){return{status:"stale",key,generation:result.generation}}if(!hostIsConnected(request.host)){await retireRecord(record,true);return{status:"stale",key,generation:result.generation}}const paintError=paintGui(result.gui,record,result.generation,request);if(paintError){return failPaint(paintError,record,token,claim,result.generation,request)}if(!isCurrent(record,token,claim)){return{status:"stale",key,generation:result.generation}}if(!hostIsConnected(request.host)){await retireRecord(record,true);return{status:"stale",key,generation:result.generation}}record.state="mounted";record.generation=result.generation;return{status:result.status,key,generation:result.generation,instance:result.instance,gui:result.gui}}function lookup(identityOrKey,expectedGeneration){const key=resolveKey(identityOrKey);if(disposed)return{status:"unavailable",key};const record=records.get(key);if(!record){const identity=typeof identityOrKey==="string"?parseRendererCellKey(identityOrKey):identityOrKey;if(!identity||logicalCellExists(identity,key)!==true){return{status:"unavailable",key}}if(expectedGeneration!==void 0){return{status:"stale",key,requestedGeneration:expectedGeneration}}return{status:"logical-offscreen",key,identity}}if(record.state==="offscreen"&&logicalCellExists(record.identity,key)===false){forgetOffscreenRecord(record);return{status:"unavailable",key}}if(expectedGeneration!==void 0&&record.generation!==expectedGeneration){return{status:"stale",key,requestedGeneration:expectedGeneration,currentGeneration:record.generation}}const runtimeLookup=adapter.runtime.lookup(key);if(record.state==="mounted"&&record.host&&record.hostClaim&&hostIsConnected(record.host)&&hostOwners.get(record.host)===record.hostClaim&&runtimeLookup.status==="mounted"&&runtimeLookup.generation===record.generation){return{status:"mounted",key,identity:record.identity,generation:runtimeLookup.generation,host:record.host,instance:runtimeLookup.instance,gui:runtimeLookup.gui,params:runtimeLookup.params}}if(record.state==="offscreen"){rememberOffscreenRecord(record)}return{status:"logical-offscreen",key,identity:record.identity,...record.generation===void 0?{}:{lastGeneration:record.generation}}}async function destroy(identityOrKey,expectedGeneration){const key=resolveKey(identityOrKey);const record=records.get(key);if(!record)return false;if(expectedGeneration!==void 0&&record.generation!==expectedGeneration){return false}return retireRecord(record,true)}function focus(identityOrKey,direction,expectedGeneration){const discovery=lookup(identityOrKey,expectedGeneration);if(discovery.status!=="mounted")return false;try{if(direction==="in")discovery.instance.focusIn?.();else discovery.instance.focusOut?.();return true}catch(cause){report(rendererControllerError("FOCUS_FAILED","focus",discovery.key,discovery.generation,void 0,`Renderer "${discovery.key}" focus ${direction} failed.`,cause));return false}}async function reconcileMounted(active){const activeKeys=new Set(active.map(resolveKey));const retiring=[...records.values()].filter(record=>record.state!=="offscreen"&&!activeKeys.has(record.key)).map(record=>retireRecord(record,true));await Promise.all(retiring)}async function dispose(){if(disposeTask)return disposeTask;disposed=true;disposeTask=(async()=>{for(const record of records.values()){record.token=++tokenSequence;record.state="offscreen";clearHostIfOwned(record.host,record.hostClaim);record.host=void 0;record.hostClaim=void 0;releaseGui(record)}offscreenRecords.clear();records.clear();await adapter.runtime.dispose()})();return disposeTask}return{adapter,render,lookup,reconcileMounted,destroy,focusIn(identityOrKey,expectedGeneration){return focus(identityOrKey,"in",expectedGeneration)},focusOut(identityOrKey,expectedGeneration){return focus(identityOrKey,"out",expectedGeneration)},dispose,stats(){return{logical:records.size,mounted:adapter.runtime.stats().mounted,disposed}}}}const DEFAULT_EDITOR_STEP_TIMEOUT_MS=5e3;function editorError(code,phase,key,generation,componentName,cause){if(cause instanceof contracts.GridComponentError)return cause;return new contracts.GridComponentError(`Editor "${componentName??key}" failed during ${phase}.`,{code,phase,componentKind:"editor",componentName,mountKey:key,generation,retryable:code!=="ABORTED",cause})}function safeReport$2(onError,error){try{onError?.(error)}catch{}}function runEditorStep(operation,options){return new Promise((resolve,reject)=>{let settled=false;const settle=callback=>{if(settled)return;settled=true;clearTimeout(timer);options.signal.removeEventListener("abort",onAbort);callback()};const onAbort=()=>settle(()=>reject(editorError("ABORTED",options.phase,options.key,options.generation,options.componentName,options.signal.reason)));const timer=setTimeout(()=>settle(()=>reject(editorError("TIMEOUT",options.phase,options.key,options.generation,options.componentName,new Error(`Timed out after ${options.timeoutMs}ms.`)))),options.timeoutMs);if(options.signal.aborted){onAbort();return}options.signal.addEventListener("abort",onAbort,{once:true});Promise.resolve().then(()=>{if(settled||options.signal.aborted){if(!settled)onAbort();return void 0}return operation()}).then(value=>settle(()=>resolve(value)),cause=>settle(()=>reject(editorError(options.failureCode,options.phase,options.key,options.generation,options.componentName,cause))))})}function normalizeValidationErrors(value){if(!Array.isArray(value))return[];const normalized=[];for(let index=0;index<value.length;index+=1){let candidate;try{candidate=value[index]}catch{continue}if(candidate===null||typeof candidate!=="object")continue;let message;try{message=candidate.message}catch{continue}if(typeof message!=="string"||message.trim().length===0){continue}let code;try{code=candidate.code}catch{code=void 0}normalized.push(typeof code==="string"?{message,code}:{message})}return normalized}function createGridEditorAdapter(options={}){const timeoutMs=options.timeoutMs??DEFAULT_EDITOR_STEP_TIMEOUT_MS;const runtime=createGridComponentRuntime({...options,kind:"editor"});const stopOperations=new Map;const destroyIfCurrent=(key,generation)=>{const current=runtime.lookup(key);if(current.status!=="mounted"||current.generation!==generation){return Promise.resolve(false)}return runtime.destroy(key)};const start=async request=>{const mounted=await runtime.mount({key:request.key,componentName:request.componentName,definition:request.definition,params:request.params});if(mounted.status!=="mounted")return mounted;const lookup=runtime.lookup(request.key);if(lookup.status!=="mounted"||lookup.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}const stepOptions={key:request.key,generation:mounted.generation,componentName:request.componentName,signal:lookup.params.signal,timeoutMs};try{let cancelBeforeHook;try{const candidate=lookup.instance.isCancelBeforeStart;if(candidate!==void 0&&typeof candidate!=="function"){throw new TypeError("Editor isCancelBeforeStart must be a function when provided.")}cancelBeforeHook=candidate}catch(cause){throw editorError("VALIDATION_FAILED","validate",request.key,mounted.generation,request.componentName,cause)}const ownerAfterCancelCapture=runtime.lookup(request.key);if(ownerAfterCancelCapture.status!=="mounted"||ownerAfterCancelCapture.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}const cancelBefore=cancelBeforeHook===void 0?false:await runEditorStep(()=>cancelBeforeHook.call(lookup.instance),{...stepOptions,phase:"validate",failureCode:"VALIDATION_FAILED"});if(cancelBefore){await destroyIfCurrent(request.key,mounted.generation);return{status:"cancelled-before-start",key:request.key,generation:mounted.generation}}const currentAfterCancel=runtime.lookup(request.key);if(currentAfterCancel.status!=="mounted"||currentAfterCancel.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}let popup=false;let popupPosition="over";try{const isPopup=mounted.instance.isPopup;if(isPopup!==void 0&&typeof isPopup!=="function"){throw new TypeError("Editor isPopup must be a function when provided.")}let ownerAfterPopupCapture=runtime.lookup(request.key);if(ownerAfterPopupCapture.status!=="mounted"||ownerAfterPopupCapture.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}popup=isPopup?.call(mounted.instance)===true;ownerAfterPopupCapture=runtime.lookup(request.key);if(ownerAfterPopupCapture.status!=="mounted"||ownerAfterPopupCapture.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}const getPopupPosition=mounted.instance.getPopupPosition;if(getPopupPosition!==void 0&&typeof getPopupPosition!=="function"){throw new TypeError("Editor getPopupPosition must be a function when provided.")}const ownerAfterPositionCapture=runtime.lookup(request.key);if(ownerAfterPositionCapture.status!=="mounted"||ownerAfterPositionCapture.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}const position=getPopupPosition?.call(mounted.instance);if(position!==void 0&&position!=="over"&&position!=="under"){throw new TypeError('Editor getPopupPosition must return "over" or "under".')}popupPosition=position??"over";const ownerAfterPopupRead=runtime.lookup(request.key);if(ownerAfterPopupRead.status!=="mounted"||ownerAfterPopupRead.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}await Promise.resolve();const ownerBeforeStartResult=runtime.lookup(request.key);if(ownerBeforeStartResult.status!=="mounted"||ownerBeforeStartResult.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}}catch(cause){throw editorError("POPUP_FAILED","popup",request.key,mounted.generation,request.componentName,cause)}return{status:"started",key:request.key,generation:mounted.generation,instance:mounted.instance,gui:mounted.gui,popup,popupPosition}}catch(cause){const error=cause instanceof contracts.GridComponentError?cause:editorError("AFTER_ATTACH_FAILED","after-attach",request.key,mounted.generation,request.componentName,cause);await destroyIfCurrent(request.key,mounted.generation);safeReport$2(options.onError,error);return{status:"failed",key:request.key,generation:mounted.generation,error}}};const afterAttach=async(key,generation)=>{const lookup=runtime.lookup(key);if(lookup.status!=="mounted"||lookup.generation!==generation){return{status:"stale",key,generation}}try{const afterGuiAttached=lookup.instance.afterGuiAttached;if(afterGuiAttached===void 0){return{status:"attached",key,generation}}if(typeof afterGuiAttached!=="function"){throw new TypeError("Editor afterGuiAttached must be a function when provided.")}const ownerAfterCapture=runtime.lookup(key);if(ownerAfterCapture.status!=="mounted"||ownerAfterCapture.generation!==generation){return{status:"stale",key,generation}}await runEditorStep(()=>afterGuiAttached.call(lookup.instance),{key,generation,componentName:void 0,signal:lookup.params.signal,timeoutMs,phase:"after-attach",failureCode:"AFTER_ATTACH_FAILED"});const current=runtime.lookup(key);return current.status==="mounted"&&current.generation===generation?{status:"attached",key,generation}:{status:"stale",key,generation}}catch(cause){const current=runtime.lookup(key);if(current.status!=="mounted"||current.generation!==generation){return{status:"stale",key,generation}}const error=cause instanceof contracts.GridComponentError?cause:editorError("AFTER_ATTACH_FAILED","after-attach",key,generation,void 0,cause);await destroyIfCurrent(key,generation);safeReport$2(options.onError,error);return{status:"failed",key,generation,error}}};const stop=(key,request)=>{const initial=runtime.lookup(key);if(initial.status!=="mounted"){return Promise.resolve({status:"not-mounted",key})}const operationKey=`${key}\0${initial.generation}`;const existing=stopOperations.get(operationKey);if(existing!==void 0)return existing;const operation=(async()=>{const lookup=initial;const{generation,instance,params}=lookup;const stepOptions={key,generation,componentName:void 0,signal:params.signal,timeoutMs};if(request.cancel===true){await destroyIfCurrent(key,generation);return{status:"cancelled",key,generation}}try{const originalValue=params.value;const getValue=instance.getValue;if(typeof getValue!=="function"){throw editorError("VALUE_FAILED","value",key,generation,void 0,new TypeError("Editor getValue must be a function."))}const ownerAfterValueCapture=runtime.lookup(key);if(ownerAfterValueCapture.status!=="mounted"||ownerAfterValueCapture.generation!==generation){return{status:"stale",key,generation}}let value=await runEditorStep(()=>getValue.call(instance),{...stepOptions,phase:"value",failureCode:"VALUE_FAILED"});const ownerAfterValueRead=runtime.lookup(key);if(ownerAfterValueRead.status!=="mounted"||ownerAfterValueRead.generation!==generation){return{status:"stale",key,generation}}let context={key,generation,reason:request.reason,originalValue,params,signal:params.signal};if(request.parseValue!==void 0){value=await runEditorStep(()=>request.parseValue(value,context),{...stepOptions,phase:"value",failureCode:"VALUE_FAILED"})}const validationErrors=[];const getValidationErrors=instance.getValidationErrors;if(getValidationErrors!==void 0&&typeof getValidationErrors!=="function"){throw editorError("VALIDATION_FAILED","validate",key,generation,void 0,new TypeError("Editor getValidationErrors must be a function when provided."))}const ownerAfterValidationCapture=runtime.lookup(key);if(ownerAfterValidationCapture.status!=="mounted"||ownerAfterValidationCapture.generation!==generation){return{status:"stale",key,generation}}if(getValidationErrors!==void 0){validationErrors.push(...normalizeValidationErrors(await runEditorStep(()=>getValidationErrors.call(instance,value),{...stepOptions,phase:"validate",failureCode:"VALIDATION_FAILED"})))}if(request.validate!==void 0){validationErrors.push(...normalizeValidationErrors(await runEditorStep(()=>request.validate(value,context),{...stepOptions,phase:"validate",failureCode:"VALIDATION_FAILED"})))}const ownerAfterValidation=runtime.lookup(key);if(ownerAfterValidation.status!=="mounted"||ownerAfterValidation.generation!==generation||ownerAfterValidation.params.signal.aborted){return{status:"stale",key,generation}}const invalidMode=request.invalidMode??"revert";if(validationErrors.length>0&&invalidMode!=="allow"){if(invalidMode==="revert"){await destroyIfCurrent(key,generation)}return{status:"invalid",key,generation,value,mode:invalidMode,errors:validationErrors}}const cancelAfterHook=instance.isCancelAfterEnd;if(cancelAfterHook!==void 0&&typeof cancelAfterHook!=="function"){throw editorError("VALIDATION_FAILED","validate",key,generation,void 0,new TypeError("Editor isCancelAfterEnd must be a function when provided."))}const ownerAfterCancelCapture=runtime.lookup(key);if(ownerAfterCancelCapture.status!=="mounted"||ownerAfterCancelCapture.generation!==generation){return{status:"stale",key,generation}}const cancelAfter=cancelAfterHook===void 0?false:await runEditorStep(()=>cancelAfterHook.call(instance),{...stepOptions,phase:"validate",failureCode:"VALIDATION_FAILED"});if(cancelAfter){await destroyIfCurrent(key,generation);return{status:"cancelled",key,generation}}context={...context,signal:params.signal};if(request.canCommit!==void 0&&!await runEditorStep(()=>request.canCommit(value,context),{...stepOptions,phase:"validate",failureCode:"VALIDATION_FAILED"})){await destroyIfCurrent(key,generation);return{status:"rejected",key,generation,reason:"policy"}}const current=runtime.lookup(key);if(current.status!=="mounted"||current.generation!==generation){return{status:"stale",key,generation}}if(request.prepareCommit!==void 0){await runEditorStep(()=>request.prepareCommit(value,context),{...stepOptions,phase:"commit",failureCode:"COMMIT_FAILED"})}const beforeCommit=runtime.lookup(key);if(beforeCommit.status!=="mounted"||beforeCommit.generation!==generation||beforeCommit.params.signal.aborted){return{status:"stale",key,generation}}try{request.commit(value,context)}catch(cause){throw editorError("COMMIT_FAILED","commit",key,generation,void 0,cause)}await destroyIfCurrent(key,generation);return{status:"committed",key,generation,value,validationErrors}}catch(cause){const current=runtime.lookup(key);if(current.status!=="mounted"||current.generation!==generation){return{status:"stale",key,generation}}const error=cause instanceof contracts.GridComponentError?cause:editorError("COMMIT_FAILED","commit",key,generation,void 0,cause);safeReport$2(options.onError,error);return{status:"failed",key,generation,error}}})().finally(()=>{if(stopOperations.get(operationKey)===operation){stopOperations.delete(operationKey)}});stopOperations.set(operationKey,operation);return operation};const focus=(key,direction)=>{const lookup=runtime.lookup(key);if(lookup.status!=="mounted")return false;try{const hook=direction==="in"?lookup.instance.focusIn:lookup.instance.focusOut;if(hook!==void 0&&typeof hook!=="function"){throw new TypeError(`Editor focus${direction==="in"?"In":"Out"} must be a function when provided.`)}let owner=runtime.lookup(key);if(owner.status!=="mounted"||owner.generation!==lookup.generation){return false}hook?.call(lookup.instance);owner=runtime.lookup(key);return owner.status==="mounted"&&owner.generation===lookup.generation}catch(cause){safeReport$2(options.onError,editorError("FOCUS_FAILED","focus",key,lookup.generation,void 0,cause));return false}};return{runtime,start,afterAttach,stop,cancel(key,generation){if(generation!==void 0)return destroyIfCurrent(key,generation);return runtime.destroy(key)},focusIn(key,generation){const lookup=runtime.lookup(key);if(generation!==void 0&&(lookup.status!=="mounted"||lookup.generation!==generation)){return false}return focus(key,"in")},focusOut(key,generation){const lookup=runtime.lookup(key);if(generation!==void 0&&(lookup.status!=="mounted"||lookup.generation!==generation)){return false}return focus(key,"out")}}}function linkAbort(controller,parent){if(parent===void 0)return()=>void 0;const onAbort=()=>controller.abort(parent.reason);if(parent.aborted){onAbort();return()=>void 0}parent.addEventListener("abort",onAbort,{once:true});return()=>parent.removeEventListener("abort",onAbort)}function createGridAsyncValueSource(loader){let state={phase:"idle",generation:0,query:"",values:[]};let active;let generationCounter=0;let destroyed=false;const listeners=new Set;const publish=next=>{state=next;for(const listener of[...listeners]){try{listener(next)}catch{}}};const load=(rawQuery="",options={})=>{const query=String(rawQuery);if(destroyed){return Promise.resolve({status:"aborted",generation:state.generation})}if(active!==void 0&&active.query===query&&active.parentSignal===options.signal){return active.promise}active?.controller.abort(new DOMException("Superseded by a newer value load.","AbortError"));active?.removeParentAbort();const generation=++generationCounter;const controller=new AbortController;const removeParentAbort=linkAbort(controller,options.signal);const promise=Promise.resolve().then(()=>loader({query,signal:controller.signal})).then(rawValues=>{if(destroyed||active?.generation!==generation||controller.signal.aborted){return{status:controller.signal.aborted?"aborted":"stale",generation}}const values=Array.isArray(rawValues)?[...rawValues]:[];publish({phase:"ready",generation,query,values});return{status:"ready",generation,values}},error=>{if(destroyed||active?.generation!==generation||controller.signal.aborted){return{status:controller.signal.aborted?"aborted":"stale",generation}}publish({phase:"error",generation,query,values:state.values,error});return{status:"failed",generation,error}}).finally(()=>{if(active?.generation!==generation)return;active.removeParentAbort();active=void 0});active={generation,query,parentSignal:options.signal,controller,removeParentAbort,promise};publish({phase:"loading",generation,query,values:state.values});return promise};return{load,refresh(options){return load(state.query,options)},snapshot(){return state},subscribe(listener){if(destroyed)return()=>void 0;listeners.add(listener);return()=>listeners.delete(listener)},destroy(){if(destroyed)return;destroyed=true;active?.controller.abort(new DOMException("Value source destroyed.","AbortError"));active?.removeParentAbort();active=void 0;listeners.clear();publish({phase:"destroyed",generation:state.generation,query:state.query,values:[]})}}}const DEFAULT_FILTER_STEP_TIMEOUT_MS=5e3;function filterError(code,phase,key,generation,componentName,cause,componentKind="filter"){if(cause instanceof contracts.GridComponentError)return cause;return new contracts.GridComponentError(`Filter "${componentName??key}" failed during ${phase}.`,{code,phase,componentKind,componentName,mountKey:key,generation,retryable:code!=="ABORTED",cause})}function runFilterStep(operation,options){return new Promise((resolve,reject)=>{let settled=false;let timer;let onAbort;const cleanup=()=>{if(timer!==void 0)clearTimeout(timer);if(onAbort!==void 0){options.signal.removeEventListener("abort",onAbort)}};const resolveOnce=value=>{if(settled)return;settled=true;cleanup();resolve(value)};const rejectOnce=cause=>{if(settled)return;settled=true;cleanup();reject(cause)};if(options.signal.aborted){rejectOnce(filterError("ABORTED",options.phase,options.key,options.generation,options.componentName,options.signal.reason,options.componentKind));return}onAbort=()=>rejectOnce(filterError("ABORTED",options.phase,options.key,options.generation,options.componentName,options.signal.reason,options.componentKind));options.signal.addEventListener("abort",onAbort,{once:true});timer=setTimeout(()=>{rejectOnce(filterError("TIMEOUT",options.phase,options.key,options.generation,options.componentName,new Error(`Timed out after ${options.timeoutMs}ms.`),options.componentKind))},options.timeoutMs);const raw=Promise.resolve().then(()=>settled?void 0:operation());void raw.then(resolveOnce,cause=>rejectOnce(filterError(options.failureCode,options.phase,options.key,options.generation,options.componentName,cause,options.componentKind)))})}function safeReport$1(onError,error){try{onError?.(error)}catch{}}function enqueueFilterOperation(state,operation){const result=state.tail.then(operation,operation);state.tail=result.then(()=>void 0,()=>void 0);return result}function createGridFilterAdapter(options={}){const timeoutMs=options.timeoutMs??DEFAULT_FILTER_STEP_TIMEOUT_MS;const compareModels=options.modelsEqual??Object.is;const runtime=createGridComponentRuntime({...options,kind:"filter"});const states=new Map;const valueSources=new Set;let disconnected=false;let disconnectPromise;const report=error=>safeReport$1(options.onError,error);const modelsEqual=(state,left,right)=>{try{return compareModels(left,right)}catch(cause){report(filterError("MODEL_FAILED","model",state.request.key,state.generation,state.request.componentName,cause));return Object.is(left,right)}};const currentLookup=(key,state)=>{const lookup=runtime.lookup(key);return lookup.status==="mounted"&&states.get(key)===state&&lookup.generation===state.generation?lookup:void 0};const predicateFailure=(state,method,cause)=>{const existing=state.predicateFailures.get(method);if(existing!==void 0)return existing;const error=filterError("MODEL_FAILED","model",state.request.key,state.generation,state.request.componentName,cause);state.predicateFailures.set(method,error);report(error);return error};const readActive=(key,state)=>{const latched=state.predicateFailures.get("isActive");if(latched!==void 0){return{status:"failed",key,generation:state.generation,error:latched}}const lookup=currentLookup(key,state);if(lookup===void 0)return stale(key,state.generation);try{const isActive=lookup.instance.isActive;if(typeof isActive!=="function"){throw new TypeError("Filter isActive must be a function.")}if(currentLookup(key,state)===void 0){return stale(key,state.generation)}const value=isActive.call(lookup.instance);if(currentLookup(key,state)===void 0){return stale(key,state.generation)}if(typeof value!=="boolean"){throw new TypeError("Filter isActive() must return a boolean.")}return{status:"ok",key,generation:state.generation,value}}catch(cause){return{status:"failed",key,generation:state.generation,error:predicateFailure(state,"isActive",cause)}}};const stale=(key,generation)=>({status:"stale",key,generation});const destroyGeneration=async(key,state)=>{if(states.get(key)!==state)return;const lookup=runtime.lookup(key);if(lookup.status!=="mounted"||lookup.generation!==state.generation){return}states.delete(key);await runtime.destroy(key)};const mount=async request=>{states.delete(request.key);const mounted=await runtime.mount({key:request.key,componentName:request.componentName,definition:request.definition,params:request.params});if(mounted.status!=="mounted")return mounted;const lookup=runtime.lookup(request.key);if(lookup.status!=="mounted"||lookup.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}let model=null;try{const getModel2=lookup.instance.getModel;if(typeof getModel2!=="function"){throw new TypeError("Filter getModel must be a function.")}const ownerAfterCapture=runtime.lookup(request.key);if(ownerAfterCapture.status!=="mounted"||ownerAfterCapture.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}model=getModel2.call(lookup.instance);await Promise.resolve();const ownerAfterRead=runtime.lookup(request.key);if(ownerAfterRead.status!=="mounted"||ownerAfterRead.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}}catch(cause){const ownerAfterFailure=runtime.lookup(request.key);if(ownerAfterFailure.status!=="mounted"||ownerAfterFailure.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}report(filterError("MODEL_FAILED","model",request.key,mounted.generation,request.componentName,cause))}states.set(request.key,{generation:mounted.generation,request,tail:Promise.resolve(),attached:false,scheduledAttached:false,afterAttachPromise:void 0,afterDetachPromise:void 0,latestModelSequence:0,pendingSet:void 0,model,predicateFailures:new Map});return mounted};const afterAttach=(key,generation)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}if(state.generation!==generation){return Promise.resolve({status:"stale",key,generation})}if(state.scheduledAttached){if(state.afterAttachPromise!==void 0){return state.afterAttachPromise}return Promise.resolve({status:"ok",key,generation,value:void 0})}state.scheduledAttached=true;const operation=enqueueFilterOperation(state,async()=>{const lookup=currentLookup(key,state);if(lookup===void 0||state.generation!==generation){return stale(key,generation)}try{const afterGuiAttached=lookup.instance.afterGuiAttached;if(afterGuiAttached!==void 0){if(typeof afterGuiAttached!=="function"){throw new TypeError("Filter afterGuiAttached must be a function when provided.")}if(currentLookup(key,state)===void 0||state.generation!==generation){return stale(key,generation)}await runFilterStep(()=>afterGuiAttached.call(lookup.instance),{phase:"after-attach",failureCode:"AFTER_ATTACH_FAILED",key,generation,componentName:state.request.componentName,signal:lookup.params.signal,timeoutMs})}}catch(cause){if(currentLookup(key,state)===void 0||state.generation!==generation){return stale(key,generation)}const error=cause instanceof contracts.GridComponentError?cause:filterError("AFTER_ATTACH_FAILED","after-attach",key,generation,state.request.componentName,cause);report(error);await destroyGeneration(key,state);return{status:"failed",key,generation,error}}if(currentLookup(key,state)===void 0||state.generation!==generation){return stale(key,generation)}state.attached=true;return{status:"ok",key,generation,value:void 0}}).finally(()=>{if(state.afterAttachPromise===operation){state.afterAttachPromise=void 0}});state.afterAttachPromise=operation;return operation};const afterDetach=(key,generation)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}if(state.generation!==generation){return Promise.resolve({status:"stale",key,generation})}if(!state.scheduledAttached){if(state.afterDetachPromise!==void 0){return state.afterDetachPromise}return Promise.resolve({status:"ok",key,generation,value:void 0})}state.scheduledAttached=false;const operation=enqueueFilterOperation(state,async()=>{const lookup=currentLookup(key,state);if(lookup===void 0||state.generation!==generation){return stale(key,generation)}if(!state.attached){return{status:"ok",key,generation,value:void 0}}try{const afterGuiDetached=lookup.instance.afterGuiDetached;if(afterGuiDetached!==void 0){if(typeof afterGuiDetached!=="function"){throw new TypeError("Filter afterGuiDetached must be a function when provided.")}if(currentLookup(key,state)===void 0||state.generation!==generation){return stale(key,generation)}await runFilterStep(()=>afterGuiDetached.call(lookup.instance),{phase:"after-detach",failureCode:"AFTER_DETACH_FAILED",key,generation,componentName:state.request.componentName,signal:lookup.params.signal,timeoutMs})}}catch(cause){if(currentLookup(key,state)===void 0||state.generation!==generation){return stale(key,generation)}const error=cause instanceof contracts.GridComponentError?cause:filterError("AFTER_DETACH_FAILED","after-detach",key,generation,state.request.componentName,cause);report(error);state.attached=false;return{status:"failed",key,generation,error}}if(currentLookup(key,state)===void 0||state.generation!==generation){return stale(key,generation)}state.attached=false;return{status:"ok",key,generation,value:void 0}}).finally(()=>{if(state.afterDetachPromise===operation){state.afterDetachPromise=void 0}});state.afterDetachPromise=operation;return operation};const setModel=(key,model)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}if(state.pendingSet!==void 0&&modelsEqual(state,state.pendingSet.model,model)){return state.pendingSet.promise}const sequence=++state.latestModelSequence;const operation=enqueueFilterOperation(state,async()=>{const lookup=currentLookup(key,state);if(lookup===void 0||sequence!==state.latestModelSequence){return stale(key,state.generation)}try{const setModelMethod=lookup.instance.setModel;if(typeof setModelMethod!=="function"){throw new TypeError("Filter setModel must be a function.")}if(currentLookup(key,state)===void 0||sequence!==state.latestModelSequence){return stale(key,state.generation)}await runFilterStep(()=>setModelMethod.call(lookup.instance,model),{phase:"model",failureCode:"MODEL_FAILED",key,generation:state.generation,componentName:state.request.componentName,signal:lookup.params.signal,timeoutMs})}catch(cause){const error=cause instanceof contracts.GridComponentError?cause:filterError("MODEL_FAILED","model",key,state.generation,state.request.componentName,cause);if(currentLookup(key,state)===void 0||sequence!==state.latestModelSequence){if(error.code==="TIMEOUT"&&currentLookup(key,state)!==void 0){report(error);await destroyGeneration(key,state)}return stale(key,state.generation)}report(error);if(error.code==="TIMEOUT"){await destroyGeneration(key,state)}return{status:"failed",key,generation:state.generation,error}}const current=currentLookup(key,state);if(current===void 0||sequence!==state.latestModelSequence){return stale(key,state.generation)}state.model=model;state.predicateFailures.clear();return{status:"ok",key,generation:state.generation,value:void 0}}).finally(()=>{if(state.pendingSet?.promise===operation){state.pendingSet=void 0}});state.pendingSet={model,promise:operation};return operation};const getModel=key=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}return enqueueFilterOperation(state,async()=>{const lookup=currentLookup(key,state);if(lookup===void 0)return stale(key,state.generation);try{const getModel2=lookup.instance.getModel;if(typeof getModel2!=="function"){throw new TypeError("Filter getModel must be a function.")}if(currentLookup(key,state)===void 0){return stale(key,state.generation)}const value=getModel2.call(lookup.instance);await Promise.resolve();if(currentLookup(key,state)===void 0){return stale(key,state.generation)}state.model=value;return{status:"ok",key,generation:state.generation,value}}catch(cause){const error=filterError("MODEL_FAILED","model",key,state.generation,state.request.componentName,cause);report(error);return{status:"failed",key,generation:state.generation,error}}})};const modelAsString=(key,suppliedModel)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}return enqueueFilterOperation(state,async()=>{const lookup=currentLookup(key,state);if(lookup===void 0)return stale(key,state.generation);try{let model=suppliedModel;if(model===void 0){const getModel2=lookup.instance.getModel;if(typeof getModel2!=="function"){throw new TypeError("Filter getModel must be a function.")}if(currentLookup(key,state)===void 0){return stale(key,state.generation)}model=getModel2.call(lookup.instance);if(currentLookup(key,state)===void 0){return stale(key,state.generation)}}const getModelAsString=lookup.instance.getModelAsString;if(getModelAsString!==void 0&&typeof getModelAsString!=="function"){throw new TypeError("Filter getModelAsString must be a function when provided.")}if(currentLookup(key,state)===void 0){return stale(key,state.generation)}const value=getModelAsString?.call(lookup.instance,model);await Promise.resolve();if(currentLookup(key,state)===void 0){return stale(key,state.generation)}return{status:"ok",key,generation:state.generation,value}}catch(cause){const error=filterError("MODEL_FAILED","model",key,state.generation,state.request.componentName,cause);report(error);return{status:"failed",key,generation:state.generation,error}}})};const notify=(key,method)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}return enqueueFilterOperation(state,async()=>{const lookup=currentLookup(key,state);if(lookup===void 0)return stale(key,state.generation);try{const hook=lookup.instance[method];if(hook!==void 0){if(typeof hook!=="function"){throw new TypeError(`Filter ${method} must be a function when provided.`)}if(currentLookup(key,state)===void 0){return stale(key,state.generation)}await runFilterStep(()=>hook.call(lookup.instance),{phase:"model",failureCode:"MODEL_FAILED",key,generation:state.generation,componentName:state.request.componentName,signal:lookup.params.signal,timeoutMs})}if(currentLookup(key,state)===void 0){return stale(key,state.generation)}return{status:"ok",key,generation:state.generation,value:void 0}}catch(cause){if(currentLookup(key,state)===void 0){return stale(key,state.generation)}const error=cause instanceof contracts.GridComponentError?cause:filterError("MODEL_FAILED","model",key,state.generation,state.request.componentName,cause);report(error);return{status:"failed",key,generation:state.generation,error}}})};const refresh=(key,params)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}return enqueueFilterOperation(state,async()=>{if(currentLookup(key,state)===void 0){return{status:"stale",key,generation:state.generation}}const result=await runtime.refresh(key,params);if(result.status==="failed"||result.status==="not-mounted"){if(states.get(key)===state)states.delete(key);return result}if(result.status==="stale")return result;state.generation=result.generation;state.request={...state.request,params};state.predicateFailures.clear();if(result.status==="recreated"){state.attached=false;state.scheduledAttached=false;state.afterAttachPromise=void 0;state.afterDetachPromise=void 0}return result})};return{runtime,mount,afterAttach,afterDetach,refresh,getActive(key){const state=states.get(key);return state===void 0?{status:"not-mounted",key}:readActive(key,state)},isActive(key){const state=states.get(key);if(state===void 0)return false;const result=readActive(key,state);return result.status==="ok"?result.value:result.status==="failed"},doesPass(key,data){const state=states.get(key);if(state===void 0)return true;if(state.predicateFailures.has("doesPass"))return false;const lookup=currentLookup(key,state);if(lookup===void 0)return true;try{const doesFilterPass=lookup.instance.doesFilterPass;if(typeof doesFilterPass!=="function"){throw new TypeError("Filter doesFilterPass must be a function.")}if(currentLookup(key,state)===void 0){return false}const value=doesFilterPass.call(lookup.instance,data);if(currentLookup(key,state)===void 0){return false}if(typeof value!=="boolean"){throw new TypeError("Filter doesFilterPass() must return a boolean.")}return value}catch(cause){predicateFailure(state,"doesPass",cause);return false}},getModel,setModel,modelAsString,onNewRowsLoaded(key){return notify(key,"onNewRowsLoaded")},onAnyFilterChanged(key){return notify(key,"onAnyFilterChanged")},destroy(key){states.delete(key);return runtime.destroy(key)},async recreate(key,replacement,recreateOptions){const previous=states.get(key);if(previous===void 0&&replacement===void 0){return{status:"not-mounted",key}}const preserveModel=recreateOptions?.preserveModel??true;let preservedModel=null;if(previous!==void 0&&preserveModel){const captured=await getModel(key);if(captured.status!=="ok"){if(captured.status==="failed"){return{status:"failed",key,generation:captured.generation,error:captured.error}}return{status:"stale",key,generation:previous.generation}}preservedModel=captured.value;if(states.get(key)!==previous){return{status:"stale",key,generation:previous.generation}}}const request=replacement?{key,...replacement}:{...previous.request,key};if(previous!==void 0&&previous.scheduledAttached&&states.get(key)===previous){const detached=await afterDetach(key,previous.generation);if(detached.status==="failed"){return{status:"failed",key,generation:detached.generation,error:detached.error}}if(detached.status!=="ok"){return{status:"stale",key,generation:previous.generation}}}if(previous!==void 0&&states.get(key)!==previous){return{status:"stale",key,generation:previous.generation}}states.delete(key);await runtime.destroy(key);const mounted=await mount(request);if(mounted.status!=="mounted"||!preserveModel||previous===void 0){return mounted}const restored=await setModel(key,preservedModel);if(restored.status==="ok")return mounted;if(restored.status==="failed"){const replacementState=states.get(key);if(replacementState!==void 0&&replacementState.generation===mounted.generation){states.delete(key);await runtime.destroy(key)}return{status:"failed",key,generation:mounted.generation,error:restored.error}}return{status:"stale",key,generation:mounted.generation}},async destroyAll(){states.clear();await runtime.destroyAll()},createValueSource(loader){const source=createGridAsyncValueSource(loader);let released=false;const tracked={load(query,loadOptions){return source.load(query,loadOptions)},refresh(refreshOptions){return source.refresh(refreshOptions)},snapshot(){return source.snapshot()},subscribe(listener){return source.subscribe(listener)},destroy(){if(released)return;released=true;valueSources.delete(tracked);source.destroy()}};if(disconnected){tracked.destroy()}else{valueSources.add(tracked)}return tracked},disconnect(){disconnectPromise??=(async()=>{disconnected=true;states.clear();for(const source of valueSources)source.destroy();valueSources.clear();await runtime.dispose()})();return disconnectPromise}}}function createGridFloatingFilterAdapter(options={}){const timeoutMs=options.timeoutMs??DEFAULT_FILTER_STEP_TIMEOUT_MS;const compareModels=options.modelsEqual??Object.is;const runtime=createGridComponentRuntime({...options,kind:"floatingFilter"});const states=new Map;let disconnectPromise;const report=error=>safeReport$1(options.onError,error);const modelsEqual=(state,left,right)=>{try{return compareModels(left,right)}catch(cause){report(filterError("MODEL_FAILED","model",state.key,state.generation,state.componentName,cause,"floatingFilter"));return Object.is(left,right)}};const currentLookup=state=>{const lookup=runtime.lookup(state.key);return states.get(state.key)===state&&lookup.status==="mounted"&&lookup.generation===state.generation?lookup:void 0};const destroyGeneration=async state=>{if(states.get(state.key)!==state)return;const lookup=runtime.lookup(state.key);if(lookup.status!=="mounted"||lookup.generation!==state.generation){return}states.delete(state.key);await runtime.destroy(state.key)};const emitChildModel=(state,model)=>{if(currentLookup(state)===void 0){return}if(state.applyingParent>0&&modelsEqual(state,state.applyingParentModel,model)){return}if(modelsEqual(state,state.model,model))return;if(state.applyingParent>0){state.latestParentSequence+=1;state.pendingParent=void 0}state.model=model;try{state.hostOnModelChange(model)}catch(cause){report(filterError("MODEL_FAILED","model",state.key,state.generation,state.componentName,cause,"floatingFilter"))}};const mount=async request=>{states.delete(request.key);let state;let hasBufferedChild=false;let bufferedChild=null;const onModelChange=model=>{if(state===void 0){hasBufferedChild=true;bufferedChild=model;return}emitChildModel(state,model)};const mounted=await runtime.mount({key:request.key,componentName:request.componentName,definition:request.definition,params:{...request.params,onModelChange}});if(mounted.status!=="mounted")return mounted;const lookup=runtime.lookup(request.key);if(lookup.status!=="mounted"||lookup.generation!==mounted.generation){return{status:"stale",key:request.key,generation:mounted.generation}}state={key:request.key,componentName:request.componentName,hostOnModelChange:request.params.onModelChange,generation:mounted.generation,model:request.params.parentModel,attached:false,scheduledAttached:false,afterAttachPromise:void 0,afterDetachPromise:void 0,applyingParent:0,applyingParentModel:request.params.parentModel,latestParentSequence:0,tail:Promise.resolve(),pendingParent:void 0};states.set(request.key,state);if(hasBufferedChild)emitChildModel(state,bufferedChild);return mounted};const afterAttach=(key,generation)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}if(state.generation!==generation){return Promise.resolve({status:"stale",key,generation})}if(state.scheduledAttached){if(state.afterAttachPromise!==void 0){return state.afterAttachPromise}return Promise.resolve({status:"ok",key,generation,value:void 0})}state.scheduledAttached=true;const operation=enqueueFilterOperation(state,async()=>{const lookup=currentLookup(state);if(lookup===void 0||state.generation!==generation){return{status:"stale",key,generation}}try{const afterGuiAttached=lookup.instance.afterGuiAttached;if(afterGuiAttached!==void 0){if(typeof afterGuiAttached!=="function"){throw new TypeError("Floating filter afterGuiAttached must be a function when provided.")}if(currentLookup(state)===void 0||state.generation!==generation){return{status:"stale",key,generation}}await runFilterStep(()=>afterGuiAttached.call(lookup.instance),{phase:"after-attach",failureCode:"AFTER_ATTACH_FAILED",key,generation,componentName:state.componentName,signal:lookup.params.signal,timeoutMs,componentKind:"floatingFilter"})}}catch(cause){if(currentLookup(state)===void 0||state.generation!==generation){return{status:"stale",key,generation}}const error=cause instanceof contracts.GridComponentError?cause:filterError("AFTER_ATTACH_FAILED","after-attach",key,generation,state.componentName,cause,"floatingFilter");report(error);await destroyGeneration(state);return{status:"failed",key,generation,error}}if(currentLookup(state)===void 0||state.generation!==generation){return{status:"stale",key,generation}}state.attached=true;return{status:"ok",key,generation,value:void 0}}).finally(()=>{if(state.afterAttachPromise===operation){state.afterAttachPromise=void 0}});state.afterAttachPromise=operation;return operation};const afterDetach=(key,generation)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}if(state.generation!==generation){return Promise.resolve({status:"stale",key,generation})}if(!state.scheduledAttached){if(state.afterDetachPromise!==void 0){return state.afterDetachPromise}return Promise.resolve({status:"ok",key,generation,value:void 0})}state.scheduledAttached=false;const operation=enqueueFilterOperation(state,async()=>{const lookup=currentLookup(state);if(lookup===void 0||state.generation!==generation){return{status:"stale",key,generation}}if(!state.attached){return{status:"ok",key,generation,value:void 0}}try{const afterGuiDetached=lookup.instance.afterGuiDetached;if(afterGuiDetached!==void 0){if(typeof afterGuiDetached!=="function"){throw new TypeError("Floating filter afterGuiDetached must be a function when provided.")}if(currentLookup(state)===void 0||state.generation!==generation){return{status:"stale",key,generation}}await runFilterStep(()=>afterGuiDetached.call(lookup.instance),{phase:"after-detach",failureCode:"AFTER_DETACH_FAILED",key,generation,componentName:state.componentName,signal:lookup.params.signal,timeoutMs,componentKind:"floatingFilter"})}}catch(cause){if(currentLookup(state)===void 0||state.generation!==generation){return{status:"stale",key,generation}}const error=cause instanceof contracts.GridComponentError?cause:filterError("AFTER_DETACH_FAILED","after-detach",key,generation,state.componentName,cause,"floatingFilter");report(error);state.attached=false;return{status:"failed",key,generation,error}}if(currentLookup(state)===void 0||state.generation!==generation){return{status:"stale",key,generation}}state.attached=false;return{status:"ok",key,generation,value:void 0}}).finally(()=>{if(state.afterDetachPromise===operation){state.afterDetachPromise=void 0}});state.afterDetachPromise=operation;return operation};const parentModelChanged=(key,model,source,force=false)=>{const state=states.get(key);if(state===void 0){return Promise.resolve({status:"not-mounted",key})}if(!force&&state.pendingParent&&modelsEqual(state,state.pendingParent.model,model)){return state.pendingParent.promise}if(!force&&modelsEqual(state,state.model,model)){return Promise.resolve({status:"ok",key,generation:state.generation,value:void 0})}const sequence=++state.latestParentSequence;const operation=enqueueFilterOperation(state,async()=>{const lookup=currentLookup(state);if(lookup===void 0||sequence!==state.latestParentSequence){return{status:"stale",key,generation:state.generation}}state.applyingParent+=1;state.applyingParentModel=model;try{const onParentModelChanged=lookup.instance.onParentModelChanged;if(typeof onParentModelChanged!=="function"){throw new TypeError("Floating filter onParentModelChanged must be a function.")}if(currentLookup(state)===void 0||sequence!==state.latestParentSequence){return{status:"stale",key,generation:state.generation}}await runFilterStep(()=>onParentModelChanged.call(lookup.instance,model,source),{phase:"model",failureCode:"MODEL_FAILED",key,generation:state.generation,componentName:state.componentName,signal:lookup.params.signal,timeoutMs,componentKind:"floatingFilter"})}catch(cause){const error=cause instanceof contracts.GridComponentError?cause:filterError("MODEL_FAILED","model",key,state.generation,state.componentName,cause,"floatingFilter");if(currentLookup(state)===void 0||sequence!==state.latestParentSequence){if(error.code==="TIMEOUT"&&currentLookup(state)!==void 0){report(error);await destroyGeneration(state)}return{status:"stale",key,generation:state.generation}}report(error);if(error.code==="TIMEOUT"){await destroyGeneration(state)}return{status:"failed",key,generation:state.generation,error}}finally{state.applyingParent-=1}if(currentLookup(state)===void 0||sequence!==state.latestParentSequence){return{status:"stale",key,generation:state.generation}}state.model=model;return{status:"ok",key,generation:state.generation,value:void 0}}).finally(()=>{if(state.pendingParent?.promise===operation){state.pendingParent=void 0}});state.pendingParent={model,promise:operation};return operation};return{runtime,mount,afterAttach,afterDetach,parentModelChanged,destroy(key){states.delete(key);return runtime.destroy(key)},async destroyAll(){states.clear();await runtime.destroyAll()},disconnect(){disconnectPromise??=(async()=>{states.clear();await runtime.dispose()})();return disconnectPromise}}}const EXTERNAL_FILTER_OWNERS=new WeakMap;const EXTERNAL_FILTER_DESTROYED=new WeakSet;const EXTERNAL_FILTER_INVALID=new WeakSet;const EXTERNAL_FILTER_DESTROY_TASKS=new WeakMap;const EXTERNAL_FILTER_RELEASE_WAITERS=new WeakMap;function externalFilterReuseError(key,source){return new contracts.GridComponentError(`External filter "${key}" reused a lifecycle source that is already owned or destroyed.`,{code:"INVALID_INSTANCE",phase:"create",componentKind:"filter",mountKey:key,retryable:true,cause:source})}function subscribeGridExternalFilterAvailability(source,callback){const sourceObject=source;if(EXTERNAL_FILTER_DESTROYED.has(sourceObject)||EXTERNAL_FILTER_INVALID.has(sourceObject)){return()=>void 0}let active=true;const notify=()=>{if(!active)return;active=false;callback()};if(!EXTERNAL_FILTER_OWNERS.has(sourceObject)){queueMicrotask(notify);return()=>{active=false}}const waiters=EXTERNAL_FILTER_RELEASE_WAITERS.get(sourceObject)??new Set;waiters.add(notify);EXTERNAL_FILTER_RELEASE_WAITERS.set(sourceObject,waiters);return()=>{active=false;waiters.delete(notify);if(waiters.size===0){EXTERNAL_FILTER_RELEASE_WAITERS.delete(sourceObject)}}}function linkExternalAbort(controller,parent){if(parent===void 0)return()=>void 0;const onAbort=()=>controller.abort(parent.reason);if(parent.aborted){onAbort();return()=>void 0}parent.addEventListener("abort",onAbort,{once:true});return()=>parent.removeEventListener("abort",onAbort)}function createGridExternalFilterController(source,options={}){const key=options.key??"external-filter";const timeoutMs=options.timeoutMs??DEFAULT_FILTER_STEP_TIMEOUT_MS;const instance=source;const sourceObject=source;if(source===null||typeof source!=="object"&&typeof source!=="function"){throw new contracts.GridComponentError(`External filter "${key}" must be a lifecycle or callback object.`,{code:"INVALID_INSTANCE",phase:"create",componentKind:"filter",mountKey:key,retryable:true,cause:source})}if(EXTERNAL_FILTER_INVALID.has(sourceObject)){throw externalFilterReuseError(key,sourceObject)}let presenceMethod;let predicateMethod;let refreshMethod;let destroyMethod;let accessorFailure;let accessorFailed=false;const capture=read=>{try{return read()}catch(cause){accessorFailed=true;accessorFailure??=cause;return void 0}};presenceMethod=capture(()=>source.isExternalFilterPresent);predicateMethod=capture(()=>source.doesExternalFilterPass);refreshMethod=capture(()=>instance.refresh);destroyMethod=capture(()=>instance.destroy);const malformed=accessorFailed||typeof presenceMethod!=="function"||typeof predicateMethod!=="function"||refreshMethod!==void 0&&typeof refreshMethod!=="function"||destroyMethod!==void 0&&typeof destroyMethod!=="function";if(malformed){EXTERNAL_FILTER_INVALID.add(sourceObject);if(typeof destroyMethod==="function"){EXTERNAL_FILTER_DESTROYED.add(sourceObject);const rawDestroy=Promise.resolve().then(()=>destroyMethod.call(source)).then(()=>void 0,cause=>{safeReport$1(options.onError,filterError("DESTROY_FAILED","destroy",key,0,void 0,cause))});EXTERNAL_FILTER_DESTROY_TASKS.set(sourceObject,rawDestroy)}throw new contracts.GridComponentError(`External filter "${key}" returned a malformed callback or lifecycle object.`,{code:"INVALID_INSTANCE",phase:"create",componentKind:"filter",mountKey:key,retryable:true,cause:accessorFailure})}const isPresentCallback=presenceMethod;const doesPassCallback=predicateMethod;const refreshCallback=refreshMethod;const destroyCallback=destroyMethod;const ownsLifecycle=refreshCallback!==void 0||destroyCallback!==void 0;const destroysLifecycle=destroyCallback!==void 0;const ownerToken={};if(ownsLifecycle&&(EXTERNAL_FILTER_OWNERS.has(sourceObject)||destroysLifecycle&&EXTERNAL_FILTER_DESTROYED.has(sourceObject))){throw externalFilterReuseError(key,sourceObject)}if(ownsLifecycle){EXTERNAL_FILTER_OWNERS.set(sourceObject,ownerToken)}let generation=0;let destroyed=false;let active;let destroyPromise;const pendingRawRefreshes=new Set;let releaseScheduled=false;const reportedPredicateFailures=new Set;let lastPredicateError=null;let cachedPresence;const report=error=>safeReport$1(options.onError,error);const releaseOwnership=()=>{if(EXTERNAL_FILTER_OWNERS.get(sourceObject)===ownerToken){EXTERNAL_FILTER_OWNERS.delete(sourceObject);if(!EXTERNAL_FILTER_DESTROYED.has(sourceObject)){const waiters=EXTERNAL_FILTER_RELEASE_WAITERS.get(sourceObject);EXTERNAL_FILTER_RELEASE_WAITERS.delete(sourceObject);for(const notify of waiters??[]){queueMicrotask(notify)}}}};const releaseRefreshOnlyOwnershipWhenSettled=()=>{if(!ownsLifecycle||destroysLifecycle||!destroyed)return;if(pendingRawRefreshes.size===0){releaseOwnership();return}if(releaseScheduled)return;releaseScheduled=true;const pending=[...pendingRawRefreshes];void Promise.all(pending).then(()=>{releaseScheduled=false;releaseRefreshOnlyOwnershipWhenSettled()})};const runRefresh=(context,controller,currentGeneration)=>{let started=false;let settleRaw;const rawSettlement=new Promise(resolve=>{settleRaw=resolve});pendingRawRefreshes.add(rawSettlement);void rawSettlement.then(()=>{pendingRawRefreshes.delete(rawSettlement);releaseRefreshOnlyOwnershipWhenSettled()});return runFilterStep(()=>{started=true;let raw;try{raw=Promise.resolve(refreshCallback.call(source,context,controller.signal))}catch(cause){raw=Promise.reject(cause)}void raw.then(settleRaw,settleRaw);return raw},{phase:"refresh",failureCode:"REFRESH_FAILED",key,generation:currentGeneration,signal:controller.signal,timeoutMs}).finally(()=>{if(!started)settleRaw()})};const predicateError=cause=>filterError("MODEL_FAILED","model",key,generation,void 0,cause);const recordPredicateFailure=(method,cause)=>{const error=predicateError(cause);lastPredicateError=error;if(!reportedPredicateFailures.has(method)){reportedPredicateFailures.add(method);report(error)}return error};return{getPredicateError(){return lastPredicateError},isPresent(){if(destroyed)return false;if(lastPredicateError!==null)return true;if(cachedPresence!==void 0)return cachedPresence;try{const value=isPresentCallback.call(source);if(typeof value!=="boolean"){throw new TypeError("External isExternalFilterPresent() must return a boolean.")}cachedPresence=value;return value}catch(cause){recordPredicateFailure("isPresent",cause);return true}},doesPass(data){if(destroyed)return true;if(lastPredicateError!==null)return false;try{const value=doesPassCallback.call(source,data);if(typeof value!=="boolean"){throw new TypeError("External doesExternalFilterPass() must return a boolean.")}return value}catch(cause){recordPredicateFailure("doesPass",cause);return false}},async refresh(context,refreshOptions={}){const currentGeneration=++generation;if(destroyed){return{status:"stale",generation:currentGeneration}}active?.controller.abort("external filter refresh superseded");active?.removeParentAbort();const controller=new AbortController;const removeParentAbort=linkExternalAbort(controller,refreshOptions.signal);active={generation:currentGeneration,controller,removeParentAbort};try{if(refreshCallback!==void 0){await runRefresh(context,controller,currentGeneration)}if(destroyed||active?.generation!==currentGeneration||controller.signal.aborted){return{status:"stale",generation:currentGeneration}}reportedPredicateFailures.clear();lastPredicateError=null;cachedPresence=void 0;return{status:"refreshed",generation:currentGeneration}}catch(cause){if(destroyed||active?.generation!==currentGeneration){return{status:"stale",generation:currentGeneration}}const error=cause instanceof contracts.GridComponentError?cause:filterError("REFRESH_FAILED","refresh",key,currentGeneration,void 0,cause);if(error.code==="TIMEOUT")controller.abort("refresh timeout");report(error);return{status:"failed",generation:currentGeneration,error}}finally{if(active?.generation===currentGeneration){active.removeParentAbort();active=void 0}}},destroy(){destroyPromise??=(async()=>{destroyed=true;active?.controller.abort("external filter destroyed");active?.removeParentAbort();active=void 0;if(destroyCallback===void 0){releaseRefreshOnlyOwnershipWhenSettled();return}EXTERNAL_FILTER_DESTROYED.add(sourceObject);const existingDestroy=EXTERNAL_FILTER_DESTROY_TASKS.get(sourceObject);if(existingDestroy!==void 0){await existingDestroy;releaseOwnership();return}const controller=new AbortController;const task=(async()=>{try{await runFilterStep(()=>destroyCallback.call(source),{phase:"destroy",failureCode:"DESTROY_FAILED",key,generation,signal:controller.signal,timeoutMs})}catch(cause){const error=cause instanceof contracts.GridComponentError?cause:filterError("DESTROY_FAILED","destroy",key,generation,void 0,cause);report(error)}finally{releaseOwnership()}})();EXTERNAL_FILTER_DESTROY_TASKS.set(sourceObject,task);await task})();return destroyPromise}}}function safeLabel(value){try{return value===null||value===void 0?"":String(value)}catch{return""}}function syncLoader(values){return({query})=>{const normalized=query.trim().toLocaleLowerCase();return values.filter(option=>normalized===""?true:safeLabel(option.label).toLocaleLowerCase().includes(normalized))}}class GridRichSelectEditor{params;root;input;listbox;status;source;unsubscribe;options=[];highlighted=-1;selected;destroyed=false;config;constructor(config){this.config=config}init(params){const documentRef=globalThis.document;if(documentRef===void 0){throw new Error("Rich select editor requires a browser document.")}this.params=params;this.selected=params.value;const root=documentRef.createElement("div");root.className="sy-grid__rich-editor";root.setAttribute("role","presentation");const input=documentRef.createElement("input");input.className="sy-grid__rich-editor-input";input.type="text";input.autocomplete="off";input.placeholder=this.config.placeholder??"";input.setAttribute("role","combobox");input.setAttribute("aria-autocomplete","list");input.setAttribute("aria-expanded","true");const listboxId=`${params.instanceId}-options`;input.setAttribute("aria-controls",listboxId);const listbox=documentRef.createElement("div");listbox.className="sy-grid__rich-editor-options";listbox.id=listboxId;listbox.setAttribute("role","listbox");const status=documentRef.createElement("div");status.className="sy-grid__rich-editor-status";status.setAttribute("role","status");status.setAttribute("aria-live","polite");root.append(input,listbox,status);this.root=root;this.input=input;this.listbox=listbox;this.status=status;input.addEventListener("input",this.onInput);input.addEventListener("keydown",this.onKeyDown);listbox.addEventListener("mousedown",this.onOptionMouseDown);listbox.addEventListener("click",this.onOptionClick);status.addEventListener("click",this.onRetryClick);const loader=typeof this.config.values==="function"?this.config.values:syncLoader(this.config.values);const source=createGridAsyncValueSource(loader);this.source=source;this.unsubscribe=source.subscribe(state=>this.renderState(state));void source.load("",{signal:params.signal})}getGui(){if(this.root===void 0||this.destroyed){throw new Error("Rich select GUI requested outside its lifecycle.")}return this.root}getValue(){return this.selected}isPopup(){return true}getPopupPosition(){return"under"}getValidationErrors(){const state=this.source?.snapshot();if(state?.phase==="error"){return[{code:"async-options",message:this.config.errorText??"Options could not be loaded."}]}if(state?.phase==="loading"&&this.config.allowCommitWhileLoading!==true){return[{code:"options-loading",message:this.config.loadingText??"Options are loading."}]}return null}refresh(params){if(this.destroyed||this.params?.colId!==params.colId)return false;this.params=params;return true}afterGuiAttached(){this.input?.focus();this.input?.select()}focusIn(){this.input?.focus()}focusOut(){this.input?.blur()}destroy(){if(this.destroyed)return;this.destroyed=true;this.input?.removeEventListener("input",this.onInput);this.input?.removeEventListener("keydown",this.onKeyDown);this.listbox?.removeEventListener("mousedown",this.onOptionMouseDown);this.listbox?.removeEventListener("click",this.onOptionClick);this.status?.removeEventListener("click",this.onRetryClick);this.unsubscribe?.();this.source?.destroy();this.root?.remove();this.params=void 0;this.root=void 0;this.input=void 0;this.listbox=void 0;this.status=void 0;this.source=void 0;this.unsubscribe=void 0;this.options=[]}onInput=()=>{const query=this.input?.value??"";const params=this.params;if(this.destroyed||params?.signal.aborted!==false)return;this.highlighted=-1;void this.source?.load(query,{signal:params.signal})};onKeyDown=event=>{if(this.destroyed||event.isComposing)return;if(event.key==="ArrowDown"||event.key==="ArrowUp"){event.preventDefault();this.moveHighlight(event.key==="ArrowDown"?1:-1);return}if(event.key==="Enter"){if(this.pickHighlighted()){event.preventDefault();this.params?.stopEditing(false)}return}if(event.key==="Escape"){event.preventDefault();this.params?.stopEditing(true);return}if(event.key==="Tab"&&this.highlighted>=0){this.pickHighlighted()}};onOptionClick=event=>{const element=event.target;if(element===null||typeof element.closest!=="function")return;const optionElement=element.closest("[data-option-index]");const rawIndex=optionElement?.dataset.optionIndex;if(rawIndex===void 0)return;const index=Number(rawIndex);if(!Number.isInteger(index)||!this.pick(index))return;this.params?.stopEditing(false)};onOptionMouseDown=event=>{const target=event.target;if(this.destroyed||event.button!==0||target===null||typeof target.closest!=="function"||target.closest("[data-option-index]")===null){return}event.preventDefault()};onRetryClick=event=>{const target=event.target;if(this.destroyed||target===null||typeof target.closest!=="function"||target.closest("[data-rich-select-retry]")===null){return}const params=this.params;if(params?.signal.aborted!==false)return;void this.source?.refresh({signal:params.signal})};renderState(state){const listbox=this.listbox;const status=this.status;if(this.destroyed||listbox===void 0||status===void 0)return;if(state.phase==="loading"){status.textContent=this.config.loadingText??"Loading options…";listbox.setAttribute("aria-busy","true");this.options=[];this.highlighted=-1;listbox.replaceChildren();this.input?.removeAttribute("aria-activedescendant");return}listbox.removeAttribute("aria-busy");if(state.phase==="error"){status.textContent=this.config.errorText??"Unable to load options.";const documentRef=globalThis.document;if(documentRef!==void 0){const retry=documentRef.createElement("button");retry.type="button";retry.dataset.richSelectRetry="true";retry.className="sy-grid__rich-editor-retry";retry.textContent="Retry";status.append(retry)}this.options=[];this.highlighted=-1;listbox.replaceChildren();return}if(state.phase!=="ready")return;this.options=state.values;const selectedIndex=this.selectedEnabledIndex();this.highlighted=selectedIndex>=0?selectedIndex:this.firstEnabledIndex();if(selectedIndex>=0&&state.query===""&&this.input!==void 0){this.input.value=safeLabel(this.options[selectedIndex]?.label)}status.textContent=state.values.length===0?this.config.emptyText??"No options.":`${state.values.length} options.`;this.renderOptions()}firstEnabledIndex(){for(let index=0;index<this.options.length;index++){if(this.options[index]?.disabled!==true)return index}return-1}selectedEnabledIndex(){return this.options.findIndex(option=>option.disabled!==true&&Object.is(option.value,this.selected))}moveHighlight(direction){const enabled=this.options.map((option,index)=>option.disabled===true?-1:index).filter(index=>index>=0);if(enabled.length===0)return;const current=enabled.indexOf(this.highlighted);const base=current<0?direction>0?-1:0:current;this.highlighted=enabled[(base+direction+enabled.length)%enabled.length];this.renderOptions()}pickHighlighted(){return this.pick(this.highlighted)}pick(index){const option=this.options[index];if(option===void 0||option.disabled===true)return false;this.selected=option.value;if(this.input!==void 0)this.input.value=safeLabel(option.label);return true}renderOptions(){const documentRef=globalThis.document;const listbox=this.listbox;const input=this.input;if(documentRef===void 0||listbox===void 0||input===void 0){return}const fragment=documentRef.createDocumentFragment();let activeId;for(let index=0;index<this.options.length;index++){const option=this.options[index];const element=documentRef.createElement("div");element.id=`${listbox.id}-${index}`;element.dataset.optionIndex=String(index);element.className="sy-grid__rich-editor-option";element.setAttribute("role","option");element.setAttribute("aria-selected",Object.is(option.value,this.selected)?"true":"false");if(option.disabled===true){element.setAttribute("aria-disabled","true")}if(index===this.highlighted){element.dataset.highlighted="true";activeId=element.id}element.textContent=safeLabel(option.label);fragment.append(element)}listbox.replaceChildren(fragment);if(activeId===void 0)input.removeAttribute("aria-activedescendant");else input.setAttribute("aria-activedescendant",activeId)}}function createGridRichSelectEditorDefinition(options){return{type:"factory",create:()=>new GridRichSelectEditor(options)}}let filterFacadeSequence=0;function filterKey(ownerId,colId){return`${ownerId}:filter:${encodeURIComponent(colId)}`}function floatingKey(ownerId,colId){return`${ownerId}:floating-filter:${encodeURIComponent(colId)}`}function declarationName(value){return typeof value==="string"?value.trim()||void 0:void 0}function defaultHostConnected(host){const connected=host.isConnected;return connected===void 0||connected}function removeOwnedGui(attachment){if(attachment===void 0)return;const[host,gui]=attachment;if(gui.parentNode===host&&typeof host.removeChild==="function"){host.removeChild(gui)}}function isPlainRecord(value){const prototype=Object.getPrototypeOf(value);return prototype===Object.prototype||prototype===null}function canonicalizeSerializable(value,seen,path,depth){if(value===null)return null;if(typeof value==="string"||typeof value==="boolean"){return value}if(typeof value==="number"){if(!Number.isFinite(value)){throw new TypeError(`${path} contains a non-finite number.`)}return Object.is(value,-0)?0:value}if(typeof value!=="object"){throw new TypeError(`${path} is not JSON-serializable.`)}if(depth>100){throw new TypeError(`${path} exceeds the maximum model depth.`)}if(seen.has(value)){throw new TypeError(`${path} contains a circular reference.`)}seen.add(value);try{if(Array.isArray(value)){return Object.freeze(value.map((entry,index)=>canonicalizeSerializable(entry,seen,`${path}[${index}]`,depth+1)))}if(!isPlainRecord(value)){throw new TypeError(`${path} must contain only plain objects.`)}for(const key of Object.getOwnPropertySymbols(value)){if(Object.prototype.propertyIsEnumerable.call(value,key)){throw new TypeError(`${path} contains an enumerable symbol key.`)}}const output=Object.create(null);for(const key of Object.keys(value).sort()){output[key]=canonicalizeSerializable(value[key],seen,`${path}.${key}`,depth+1)}return Object.freeze(output)}finally{seen.delete(value)}}function createGridFilterFacadeController(options){const manager=options.manager;const ownerId=options.ownerId?.trim()||`filter-facade-${filterFacadeSequence+=1}`;const states=new Map;const lifecycleController=new AbortController;let executionMode=typeof options.executionMode==="function"?"server":options.executionMode??"client";let reconcileRequestRevision=0;let appliedReconcileRevision=0;let modelRevision=0;let disconnected=false;let operationTail=Promise.resolve();let disconnectTask;let latestReconcileIntent;function enqueue(operation){const result=operationTail.then(operation,operation);operationTail=result.then(()=>void 0,()=>void 0);return result}function context(){return options.getContext?.()??options.context}function captureContext(){try{return{status:"ok",value:context()}}catch(cause){return{status:"failed",cause}}}function captureReconcileIntent(revision,columns,capturedContext){const desired=new Map;const seen=new Set;const ambiguous=new Set;for(const column of columns){const colId=column.colId.trim();if(!colId)continue;if(seen.has(colId)){ambiguous.add(colId);continue}seen.add(colId);if(column.filter!=null){desired.set(colId,{...column,colId})}}return{revision,desired,ambiguous,context:capturedContext}}function latestIntentRetains(column,nextContext,revisionOrFloating){const intent=latestReconcileIntent;if(intent===void 0||intent.revision!==reconcileRequestRevision||typeof revisionOrFloating==="number"&&intent.revision<=revisionOrFloating||intent.context.status!=="ok"||!Object.is(intent.context.value,nextContext)||intent.ambiguous.has(column.colId)){return false}const latest=intent.desired.get(column.colId);return latest!==void 0&&Object.is(latest.local,column.local)&&Object.is(latest.version,column.version)&&Object.is(latest.resolutionVersion,column.resolutionVersion)&&(typeof revisionOrFloating==="number"?Object.is(latest.filter,column.filter)&&Object.is(latest.floatingFilter,column.floatingFilter)&&Object.is(latest.getValue,column.getValue):revisionOrFloating?Object.is(latest.floatingFilter,column.floatingFilter):Object.is(latest.filter,column.filter)&&Object.is(latest.getValue,column.getValue))}function reconcileColumnSnapshot(state){return{colId:state.id,filter:state.filterSrc??null,floatingFilter:state.floatingSrc,getValue:state.valueOf,local:state.defs,version:state.version,resolutionVersion:state.resolveVersion}}function operationIntentOwned(column,operationContext,requestRevision){return requestRevision===reconcileRequestRevision||latestIntentRetains(column,operationContext,requestRevision)}function filterOperationOwned(state,epoch,generation,column,operationContext,requestRevision){return ownsExactFilterGeneration(state,epoch,generation)&&operationIntentOwned(column,operationContext,requestRevision)}function floatingCallbackOwned(state,owner){const floating=currentFloatingLookup(state);return state.floatingOwner===owner&&state.life[3]===owner[3]&&floating?.generation===owner[2]&&ownsExactFilterGeneration(state,owner[0],owner[1])&&latestIntentRetains(owner[4],owner[5],true)}function rebindFloatingCallback(state,epoch,filterGeneration){const owner=state.floatingOwner;if(owner===void 0||state.life[3]!==owner[3]||state.life[5]!==owner[2]||!latestIntentRetains(owner[4],owner[5],true)){return}owner[0]=epoch;owner[1]=filterGeneration}function mode(){try{if(typeof options.executionMode==="function"){executionMode=options.executionMode()}if(executionMode!=="client"&&executionMode!=="server"&&executionMode!=="infinite"){throw new TypeError(`Unknown filter execution mode "${String(executionMode)}".`)}}catch(cause){report(facadeError("MODEL_FAILED","model","filter","Filter execution mode could not be resolved.",void 0,cause));return"server"}return executionMode}function report(error){try{options.onError?.(error)}catch{}}function facadeError(code,phase,componentKind,message,state,cause){if(cause instanceof contracts.GridComponentError)return cause;return new contracts.GridComponentError(message,{code,phase,componentKind,componentName:componentKind==="filter"?state?.fName:state?.ffName,mountKey:componentKind==="filter"?state?.fKey:state?.ffKey,generation:componentKind==="filter"?state?.life[4]:state?.life[5],retryable:code!=="INVALID_NAME",cause})}function modelsEqual(left,right,state){try{return options.modelsEqual?.(left,right)??Object.is(left,right)}catch(cause){const error=facadeError("MODEL_FAILED","model","filter",`Filter "${state?.id??"<unknown>"}" model comparison failed.`,state,cause);report(error);return Object.is(left,right)}}function fingerprintModel(model){try{return JSON.stringify(canonicalizeSerializable(model,new Set,"filterModel",0))}catch{return void 0}}function comparePublishedModel(state,next){const fingerprint=fingerprintModel(next);if(state.fingerprint!==void 0&&fingerprint!==void 0){return{changed:state.fingerprint!==fingerprint,fingerprint}}return{changed:!modelsEqual(state.published,next,state),fingerprint}}function hostConnection(host,state,componentKind){try{return{connected:(options.isHostConnected??defaultHostConnected)(host)}}catch(cause){return{connected:false,error:facadeError("GUI_FAILED","gui",componentKind,`${componentKind} "${state.id}" host connectivity check failed.`,state,cause)}}}function current(state,epoch){return!disconnected&&states.get(state.id)===state&&(epoch===void 0||state.life[1]===epoch)}function currentFilterCallback(state,callbackEpoch){return current(state)&&state.life[2]===callbackEpoch}function currentFloatingCallback(state,callbackEpoch){return current(state)&&state.life[3]===callbackEpoch}function currentFilterLookup(state){const lookup=manager.filter.runtime.lookup(state.fKey);return lookup.status==="mounted"&&lookup.generation===state.life[4]?lookup:void 0}function currentFloatingLookup(state){const lookup=manager.floatingFilter.runtime.lookup(state.ffKey);return lookup.status==="mounted"&&lookup.generation===state.life[5]?lookup:void 0}function invalidateActive(state){state.active=void 0;state.activeFailure=void 0}function markModelRestorePending(state){state.life[7]=true;state.active=true;state.activeFailure??=facadeError("MODEL_FAILED","model","filter",`Filter "${state.id}" is restoring its preserved model.`,state);return state.activeFailure}function clearExactModelRestoreLatch(state,epoch,generation,expectedError){if(!state.life[7]||state.activeFailure!==expectedError||!ownsExactFilterGeneration(state,epoch,generation)){return false}state.life[7]=false;invalidateActive(state);return true}function ownsExactFilterGeneration(state,epoch,generation){return current(state,epoch)&&currentFilterLookup(state)?.generation===generation}function readActive(state){if(state.active!==void 0){return state.activeFailure===void 0?{active:state.active}:{active:state.active,error:state.activeFailure}}const result=manager.filter.getActive(state.fKey);if(result.status==="ok"){state.active=result.value;state.activeFailure=void 0;return{active:result.value}}if(result.status==="failed"){state.active=true;state.activeFailure=result.error;return{active:true,error:result.error}}state.active=false;state.activeFailure=void 0;return{active:false}}function captureModelSync(state,errors){const lookup=currentFilterLookup(state);if(lookup===void 0)return state.model;try{const value=lookup.instance.getModel();state.model=value;state.life[8]=false;return value}catch(cause){const error=facadeError("MODEL_FAILED","model","filter",`Filter "${state.id}" failed to expose its model.`,state,cause);if(!state.life[8]){state.life[8]=true;report(error)}errors?.push(error);return state.model}}function notifyHostChanged(state,source){state.published=state.model;state.fingerprint=fingerprintModel(state.model);modelRevision+=1;try{options.onFilterChanged?.({colId:state.id,source,model:state.model,revision:modelRevision})}catch(cause){report(facadeError("MODEL_FAILED","model","filter",`Filter "${state.id}" change callback failed.`,state,cause))}}function propagateParentModel(state,source,force=false){if(currentFloatingLookup(state)===void 0){return Promise.resolve()}return manager.floatingFilter.parentModelChanged(state.ffKey,state.model,source,force).then(()=>void 0).catch(()=>void 0)}function notifyPeers(changed){return Promise.all([...states.values()].filter(state=>state!==changed&&currentFilterLookup(state)!==void 0).map(state=>manager.filter.onAnyFilterChanged(state.fKey).catch(()=>void 0))).then(()=>void 0)}function onFilterUiChanged(state,callbackEpoch,stillOwned){if(!currentFilterCallback(state,callbackEpoch)||!stillOwned()||state.life[6]>0){return}invalidateActive(state);captureModelSync(state);void propagateParentModel(state,"ui");void notifyPeers(state);notifyHostChanged(state,"ui")}function onFilterModified(state,callbackEpoch,stillOwned){if(!currentFilterCallback(state,callbackEpoch)||!stillOwned()||state.life[6]>0){return}try{options.onFilterModified?.(state.id)}catch(cause){report(facadeError("MODEL_FAILED","model","filter",`Filter "${state.id}" modified callback failed.`,state,cause))}}function filterParams(state,callbackEpoch,stillOwned){return{colId:state.id,context:state.ctx,getValue:state.valueOf,filterChangedCallback:()=>onFilterUiChanged(state,callbackEpoch,stillOwned),filterModifiedCallback:()=>onFilterModified(state,callbackEpoch,stillOwned),signal:lifecycleController.signal}}function floatingParams(state,owner,stillOwned=()=>true){return{colId:state.id,context:state.ctx,parentModel:state.model,onModelChange:next=>{if(!currentFloatingCallback(state,owner[3])||!stillOwned()||!latestIntentRetains(owner[4],owner[5],true)){return}void enqueue(()=>setFilterModelInternal(state,next,"ui",0,void 0,owner))},signal:lifecycleController.signal}}async function resolveFilter(state,source,epoch,local){const name=declarationName(source);const resolved=typeof source==="string"?await manager.resolve({kind:"filter",name,local,signal:state.life[0].signal}):await manager.resolve({kind:"filter",definition:source,local,signal:state.life[0].signal});if(!current(state,epoch))return void 0;state.fName=resolved.name;return resolved.definition}async function resolveFloating(state,source,epoch,stillOwned){if(!stillOwned())return void 0;const name=declarationName(source);const resolved=typeof source==="string"?await manager.resolve({kind:"floatingFilter",name,local:state.defs,signal:state.life[0].signal}):await manager.resolve({kind:"floatingFilter",definition:source,local:state.defs,signal:state.life[0].signal});if(!current(state,epoch)||!stillOwned())return void 0;state.ffName=resolved.name;return resolved.definition}async function detachInternal(state,floating=false){const attachmentProperty=floating?"floatingAttach":"filterAttach";const attachment=state[attachmentProperty];if(attachment===void 0){return{status:"already-detached",colId:state.id}}state[attachmentProperty]=void 0;const component=floating?manager.floatingFilter:manager.filter;const result=await component.afterDetach(floating?state.ffKey:state.fKey,attachment[2]);removeOwnedGui(attachment);if(!current(state)){return{status:"stale",colId:state.id}}if(result.status==="failed"){return{status:"failed",colId:state.id,error:result.error}}if(result.status==="stale"){return{status:"stale",colId:state.id}}return{status:"detached",colId:state.id}}async function attachInternal(state,host,floating=false,stillOwned=()=>true){if(!current(state)||!stillOwned()){return{status:"stale",colId:state.id}}const lookup=floating?currentFloatingLookup(state):currentFilterLookup(state);if(lookup===void 0){return{status:"not-mounted",colId:state.id}}const componentKind=floating?"floatingFilter":"filter";const component=floating?manager.floatingFilter:manager.filter;const componentKey=floating?state.ffKey:state.fKey;const attachmentProperty=floating?"floatingAttach":"filterAttach";const initialConnection=hostConnection(host,state,componentKind);if(!initialConnection.connected){if(initialConnection.error!==void 0){report(initialConnection.error);return{status:"failed",colId:state.id,error:initialConnection.error}}return{status:"detached-host",colId:state.id}}const existing=state[attachmentProperty];if(existing?.[0]===host&&existing[1]===lookup.gui&&existing[2]===lookup.generation){return{status:"already-attached",colId:state.id,generation:lookup.generation,gui:lookup.gui}}if(existing!==void 0){await detachInternal(state,floating);if(!current(state)||!stillOwned()){return{status:"stale",colId:state.id}}}try{if(typeof host.replaceChildren!=="function"){throw new TypeError("A custom-filter GUI host must implement replaceChildren().")}host.replaceChildren(lookup.gui)}catch(cause){const error=facadeError("GUI_FAILED","gui",componentKind,`${floating?"Floating filter":"Filter"} "${state.id}" GUI could not be inserted.`,state,cause);report(error);return{status:"failed",colId:state.id,error}}const attachment=[host,lookup.gui,lookup.generation];if(!stillOwned()){removeOwnedGui(attachment);return{status:"stale",colId:state.id}}state[attachmentProperty]=attachment;const attached=await component.afterAttach(componentKey,lookup.generation);const operationOwned=current(state)&&stillOwned();const settledConnection=!floating||operationOwned?hostConnection(host,state,componentKind):{connected:true,error:void 0};if(!operationOwned||state[attachmentProperty]!==attachment||!settledConnection.connected){if(state[attachmentProperty]===attachment){state[attachmentProperty]=void 0}await component.afterDetach(componentKey,lookup.generation);removeOwnedGui(attachment);if(settledConnection.error!==void 0){report(settledConnection.error);return{status:"failed",colId:state.id,error:settledConnection.error}}return{status:!settledConnection.connected&&(!floating||operationOwned)?"detached-host":"stale",colId:state.id}}if(attached.status!=="ok"){state[attachmentProperty]=void 0;removeOwnedGui(attachment);return attached.status==="failed"?{status:"failed",colId:state.id,error:attached.error}:{status:"stale",colId:state.id}}return{status:"attached",colId:state.id,generation:lookup.generation,gui:lookup.gui}}async function destroyFloatingInternal(state,stillOwned,generation=state.life[5]){const owned=()=>stillOwned?.()!==false;if(!owned())return false;state.life[3]+=1;const attachment=state.floatingAttach?.[2]===generation?state.floatingAttach:void 0;if(attachment!==void 0){state.floatingAttach=void 0;await manager.floatingFilter.afterDetach(state.ffKey,generation);removeOwnedGui(attachment);if(!owned())return false}const lookup=manager.floatingFilter.runtime.lookup(state.ffKey);if(lookup.status==="mounted"&&lookup.generation===generation){await manager.floatingFilter.destroy(state.ffKey)}if(state.life[5]===generation){state.floatingDef=void 0;state.life[5]=0;state.floatingAttach=void 0;state.ffName=void 0;state.floatingOwner=void 0}return owned()}async function latchModelRestoreFailure(state,error,preservedModel,failedGeneration,epoch){if(!current(state,epoch))return;state.model=preservedModel;state.life[7]=true;state.active=true;state.activeFailure=error;state.life[2]+=1;if(state.filterAttach!==void 0){await detachInternal(state)}if(!current(state,epoch))return;const failedLookup=manager.filter.runtime.lookup(state.fKey);if(failedLookup.status==="mounted"&&failedLookup.generation===failedGeneration){await manager.filter.destroy(state.fKey)}if(!current(state,epoch))return;const settledLookup=manager.filter.runtime.lookup(state.fKey);if(settledLookup.status==="unmounted"){state.filterDef=void 0;state.life[4]=0;state.filterAttach=void 0}await destroyFloatingInternal(state)}async function destroyStateInternal(state){if(states.get(state.id)!==state)return false;states.delete(state.id);state.life[1]+=1;state.life[0].abort(new Error(`Filter "${state.id}" was destroyed.`));const filterAttachment=state.filterAttach;const floatingAttachment=state.floatingAttach;state.filterAttach=void 0;state.floatingAttach=void 0;if(filterAttachment!==void 0){await manager.filter.afterDetach(state.fKey,filterAttachment[2]);removeOwnedGui(filterAttachment)}if(floatingAttachment!==void 0){await manager.floatingFilter.afterDetach(state.ffKey,floatingAttachment[2]);removeOwnedGui(floatingAttachment)}await Promise.all([manager.filter.destroy(state.fKey),manager.floatingFilter.destroy(state.ffKey)]);return true}async function reconcileFloating(state,desired,paramsChanged,epoch,errors,stillOwned,forceResolve=false){if(!stillOwned())return;const retainedHost=state.floatingAttach?.[0]??state.pendingFloating;if(desired==null){state.pendingFloating=retainedHost;if(state.floatingDef!==void 0||currentFloatingLookup(state)!==void 0){if(!await destroyFloatingInternal(state,stillOwned))return}if(!stillOwned())return;state.floatingSrc=desired;state.pendingFloating=void 0;return}const sourceChanged=!Object.is(state.floatingSrc,desired)||forceResolve||state.floatingDef===void 0||currentFloatingLookup(state)===void 0;if(!sourceChanged&&!paramsChanged){rebindFloatingCallback(state,epoch,state.life[4]);return}let definition;try{definition=sourceChanged?await resolveFloating(state,desired,epoch,stillOwned):state.floatingDef}catch(cause){if(!stillOwned()||state.life[0].signal.aborted){return}const error=facadeError("COMPONENT_NOT_FOUND","lookup","floatingFilter",`Floating filter "${state.id}" could not be resolved.`,state,cause);report(error);errors.push(error);if((paramsChanged||forceResolve)&&stillOwned()){state.pendingFloating=retainedHost;await destroyFloatingInternal(state,stillOwned)}return}if(definition===void 0||!stillOwned()){return}state.pendingFloating=retainedHost;if(!await destroyFloatingInternal(state,stillOwned))return;const callbackEpoch=state.life[3];const callbackOwner=[epoch,state.life[4],0,callbackEpoch,{...reconcileColumnSnapshot(state),floatingFilter:desired},state.ctx];let callbackOwnershipReleased=false;const callbackOwned=()=>callbackOwnershipReleased||stillOwned();const mounted=await manager.floatingFilter.mount({key:state.ffKey,componentName:state.ffName,definition,params:floatingParams(state,callbackOwner,callbackOwned)});if(!stillOwned()){if(mounted.status==="mounted"){await destroyFloatingInternal(state,void 0,mounted.generation)}return}if(mounted.status!=="mounted"){if(mounted.status==="failed")errors.push(mounted.error);return}state.floatingDef=definition;state.floatingSrc=desired;state.life[5]=mounted.generation;callbackOwner[2]=mounted.generation;state.floatingOwner=callbackOwner;if(retainedHost!==void 0){const attached=await attachInternal(state,retainedHost,true,stillOwned);if(!stillOwned()){await destroyFloatingInternal(state,void 0,mounted.generation);return}if(attached.status==="attached"||attached.status==="already-attached"){state.pendingFloating=void 0}}else{state.pendingFloating=void 0}callbackOwnershipReleased=true}async function applyColumn(state,column,nextContext,reconcileRevision,errors){const desired=column.filter;if(desired==null)return"unchanged";const resolutionChanged=!Object.is(state.resolveVersion,column.resolutionVersion)||!Object.is(state.defs,column.local);const paramsChanged=!Object.is(state.valueOf,column.getValue)||!Object.is(state.defs,column.local)||!Object.is(state.version,column.version)||!Object.is(state.ctx,nextContext);const sourceChanged=!Object.is(state.filterSrc,desired)||resolutionChanged||state.filterDef===void 0||currentFilterLookup(state)===void 0;if(!sourceChanged&&!paramsChanged){if(reconcileRevision!==reconcileRequestRevision){return"stale"}const floatingEpoch=state.life[1];const floatingFilterGeneration=state.life[4];const floatingOwned=()=>filterOperationOwned(state,floatingEpoch,floatingFilterGeneration,column,nextContext,reconcileRevision);if(state.life[0].signal.aborted){state.life[0]=new AbortController}await reconcileFloating(state,column.floatingFilter,false,state.life[1],errors,floatingOwned,false);return reconcileRevision===reconcileRequestRevision?"unchanged":"stale"}state.life[0].abort(new Error(`Filter "${state.id}" reconciliation was superseded.`));state.life[0]=new AbortController;const lookupEpoch=state.life[1];let definition;try{definition=sourceChanged?await resolveFilter(state,desired,lookupEpoch,column.local):state.filterDef}catch(cause){if(!current(state,lookupEpoch)||reconcileRevision!==reconcileRequestRevision||state.life[0].signal.aborted){return"stale"}const error=facadeError("COMPONENT_NOT_FOUND","lookup","filter",`Filter "${state.id}" could not be resolved.`,state,cause);report(error);errors.push(error);if(resolutionChanged&&current(state,lookupEpoch)){await detachInternal(state);await manager.filter.destroy(state.fKey);state.filterDef=void 0;state.life[4]=0;await destroyFloatingInternal(state)}return"stale"}if(definition===void 0||!current(state,lookupEpoch)||reconcileRevision!==reconcileRequestRevision){return"stale"}state.life[1]+=1;const epoch=state.life[1];state.life[2]+=1;const filterCallbackEpoch=state.life[2];state.valueOf=column.getValue;state.defs=column.local;state.version=column.version;state.resolveVersion=column.resolutionVersion;state.ctx=nextContext;const previousLookup=currentFilterLookup(state);const retainedHost=state.filterAttach?.[0]??state.pendingFilter;state.pendingFilter=retainedHost;const preservedModel=captureModelSync(state);const restoreModelOnMount=state.life[7];if(state.filterAttach!==void 0){await detachInternal(state)}if(!current(state,epoch))return"stale";let callbackGeneration=state.life[4];const callbackOwned=()=>ownsExactFilterGeneration(state,epoch,callbackGeneration)&&latestIntentRetains(column,nextContext,false);const params=filterParams(state,filterCallbackEpoch,callbackOwned);let restoreLatchError=state.life[7]?state.activeFailure:void 0;if(previousLookup!==void 0&&sourceChanged){restoreLatchError=markModelRestorePending(state)}state.life[6]+=1;const result=await(async()=>{try{return previousLookup===void 0?await manager.filter.mount({key:state.fKey,componentName:state.fName,definition,params}):sourceChanged?await manager.filter.recreate(state.fKey,{componentName:state.fName,definition,params},{preserveModel:true}):await manager.filter.refresh(state.fKey,params)}finally{state.life[6]-=1}})();if(!current(state,epoch))return"stale";if(result.status==="failed"&&result.error.code==="MODEL_FAILED"){errors.push(result.error);await latchModelRestoreFailure(state,result.error,preservedModel,result.generation,epoch);return"stale"}if(reconcileRevision!==reconcileRequestRevision)return"stale";if(result.status==="failed"||result.status==="not-mounted"||result.status==="stale"){if(result.status==="failed")errors.push(result.error);state.filterDef=void 0;state.life[4]=0;await destroyFloatingInternal(state);return"stale"}callbackGeneration=result.generation;state.filterDef=definition;state.filterSrc=desired;state.life[4]=result.generation;if(result.status==="recreated"||previousLookup===void 0&&restoreModelOnMount){restoreLatchError=markModelRestorePending(state);state.life[6]+=1;try{const restored=await manager.filter.setModel(state.fKey,preservedModel);if(restored.status!=="ok"||restored.generation!==result.generation){const error=restored.status==="failed"?restored.error:facadeError("MODEL_FAILED","model","filter",`Filter "${state.id}" replacement could not restore its model.`,state,new Error(`Filter model restoration settled as "${restored.status}".`));if(restored.status!=="failed")report(error);errors.push(error);await latchModelRestoreFailure(state,error,preservedModel,result.generation,epoch);return"stale"}}finally{state.life[6]-=1}}if(!current(state,epoch))return"stale";const hadRestoreLatch=state.life[7];const finalizationOwned=()=>reconcileRevision===reconcileRequestRevision||hadRestoreLatch&&latestIntentRetains(column,nextContext,reconcileRevision);if(!finalizationOwned())return"stale";if(hadRestoreLatch&&(restoreLatchError===void 0||!clearExactModelRestoreLatch(state,epoch,result.generation,restoreLatchError))){return"stale"}if(!hadRestoreLatch)invalidateActive(state);const acceptedModel=captureModelSync(state,errors);const transition=comparePublishedModel(state,acceptedModel);const activity=readActive(state);if(activity.error!==void 0)errors.push(activity.error);if(retainedHost!==void 0&&finalizationOwned()){await attachInternal(state,retainedHost);if(finalizationOwned()){state.pendingFilter=void 0}}if(!finalizationOwned())return"stale";await reconcileFloating(state,column.floatingFilter,paramsChanged,epoch,errors,()=>filterOperationOwned(state,epoch,result.generation,column,nextContext,reconcileRevision),resolutionChanged);if(!finalizationOwned())return"stale";if((previousLookup!==void 0||hadRestoreLatch)&&transition.changed&&ownsExactFilterGeneration(state,epoch,result.generation)&&state.activeFailure===void 0&&finalizationOwned()){await Promise.all([propagateParentModel(state,"api",hadRestoreLatch),notifyPeers(state)]);if(ownsExactFilterGeneration(state,epoch,result.generation)&&state.activeFailure===void 0&&finalizationOwned()){notifyHostChanged(state,"api")}}if(reconcileRevision!==reconcileRequestRevision)return"stale";return previousLookup===void 0?"mounted":sourceChanged||result.status==="recreated"?"mounted":"refreshed"}function createState(column,nextContext){return{id:column.colId.trim(),fKey:filterKey(ownerId,column.colId.trim()),ffKey:floatingKey(ownerId,column.colId.trim()),life:[new AbortController,0,0,0,0,0,0,false,false],valueOf:column.getValue,defs:column.local,version:column.version,resolveVersion:column.resolutionVersion,ctx:nextContext,model:null,published:null,fingerprint:fingerprintModel(null)}}async function setFilterModelInternal(state,model,source,requestRevision,batchChangedStates,floatingOwner){if(!current(state)){return{status:"not-mounted",key:state.fKey}}const operationEpoch=floatingOwner?.[0]??state.life[1];const operationGeneration=floatingOwner?.[1]??state.life[4];const operationContext=floatingOwner?.[5]??state.ctx;const operationColumn=floatingOwner?.[4]??reconcileColumnSnapshot(state);const operationOwned=()=>floatingOwner===void 0?filterOperationOwned(state,operationEpoch,operationGeneration,operationColumn,operationContext,requestRevision):floatingCallbackOwned(state,floatingOwner);const staleResult=()=>({status:"stale",key:state.fKey,generation:operationGeneration});if(!operationOwned())return staleResult();state.life[6]+=1;let result;try{result=await manager.filter.setModel(state.fKey,model)}finally{state.life[6]-=1}if(result.status!=="ok"||!current(state))return result;if(!operationOwned())return staleResult();const accepted=await manager.filter.getModel(state.fKey);if(accepted.status!=="ok")return accepted;if(!operationOwned())return staleResult();state.life[8]=false;invalidateActive(state);readActive(state);const comparison=comparePublishedModel(state,accepted.value);state.model=accepted.value;if(comparison.changed||source==="ui"){if(batchChangedStates===void 0){await Promise.all([propagateParentModel(state,source),notifyPeers(state)])}else{await propagateParentModel(state,source);if(!operationOwned())return staleResult();batchChangedStates.add(state)}if(!operationOwned())return staleResult();notifyHostChanged(state,source)}return result}const controller={reconcileColumns(columns){const revision=++reconcileRequestRevision;const snapshot=columns.map(column=>({...column}));const requestContext=captureContext();latestReconcileIntent=captureReconcileIntent(revision,snapshot,requestContext);for(const state of states.values()){state.life[0].abort(new Error(`Filter reconciliation ${revision-1} was superseded by ${revision}.`))}return enqueue(async()=>{const mounted=[];const refreshed=[];const unchanged=[];const destroyed=[];const errors=[];if(disconnected){return{status:"disconnected",revision,mounted,refreshed,unchanged,destroyed,errors}}if(revision!==reconcileRequestRevision){return{status:"stale",revision,mounted,refreshed,unchanged,destroyed,errors}}const desired=new Map;for(const column of snapshot){const colId=column.colId.trim();if(!colId){const error=facadeError("INVALID_NAME","lookup","filter","Custom-filter colId must be a non-empty string.",void 0);report(error);errors.push(error);continue}if(desired.has(colId)){const error=facadeError("INVALID_NAME","lookup","filter",`Custom-filter colId "${colId}" is duplicated.`,states.get(colId));report(error);errors.push(error);continue}if(column.filter!=null){desired.set(colId,{...column,colId})}}if(requestContext.status==="failed"){const error=facadeError("INIT_FAILED","init","filter","Custom-filter context could not be resolved.",void 0,requestContext.cause);report(error);errors.push(error);return{status:"applied",revision,mounted,refreshed,unchanged,destroyed,errors}}const nextContext=requestContext.value;for(const[colId,state]of[...states]){if(!desired.has(colId)){if(await destroyStateInternal(state))destroyed.push(colId)}}for(const[colId,column]of desired){if(disconnected||revision!==reconcileRequestRevision){return{status:disconnected?"disconnected":"stale",revision,mounted,refreshed,unchanged,destroyed,errors}}let state=states.get(colId);if(state===void 0){state=createState(column,nextContext);states.set(colId,state)}const result=await applyColumn(state,column,nextContext,revision,errors);if(result==="mounted")mounted.push(colId);if(result==="refreshed")refreshed.push(colId);if(result==="unchanged")unchanged.push(colId)}if(disconnected||revision!==reconcileRequestRevision){return{status:disconnected?"disconnected":"stale",revision,mounted,refreshed,unchanged,destroyed,errors}}appliedReconcileRevision=revision;return{status:"applied",revision,mounted,refreshed,unchanged,destroyed,errors}})},attachFilterGui(colId,host){return enqueue(async()=>{if(disconnected){return{status:"disconnected",colId}}const state=states.get(colId);if(state===void 0){return{status:"not-mounted",colId}}const attached=await attachInternal(state,host);state.pendingFilter=void 0;return attached})},detachFilterGui(colId){return enqueue(async()=>{if(disconnected){return{status:"disconnected",colId}}const state=states.get(colId);if(state===void 0){return{status:"already-detached",colId}}state.pendingFilter=void 0;return detachInternal(state)})},attachFloatingFilterGui(colId,host){return enqueue(async()=>{if(disconnected){return{status:"disconnected",colId}}const state=states.get(colId);if(state===void 0){return{status:"not-mounted",colId}}const attached=await attachInternal(state,host,true);if(attached.status==="attached"||attached.status==="already-attached"){state.pendingFloating=void 0}return attached})},detachFloatingFilterGui(colId){return enqueue(async()=>{if(disconnected){return{status:"disconnected",colId}}const state=states.get(colId);if(state===void 0){return{status:"already-detached",colId}}state.pendingFloating=void 0;return detachInternal(state,true)})},doesPass(data,suppliedMode){if(disconnected||(suppliedMode??mode())!=="client"){return true}for(const state of states.values()){const activeResult=readActive(state);if(activeResult.error!==void 0)return false;if(activeResult.active&&!manager.filter.doesPass(state.fKey,data)){return false}}const external=manager.getExternalFilter();if(external===null)return true;if(external.getPredicateError()!==null)return false;const present=external.isPresent();if(external.getPredicateError()!==null)return false;if(!present)return true;const passes=external.doesPass(data);return external.getPredicateError()===null&&passes},isFilterActive(colId){const state=states.get(colId);if(state===void 0)return false;return readActive(state).active},onAnyFilterChanged(exceptColId){return enqueue(async()=>Promise.all([...states.values()].filter(state=>state.id!==exceptColId&&currentFilterLookup(state)!==void 0).map(state=>manager.filter.onAnyFilterChanged(state.fKey))))},synchronizeFilterModels(source="api"){const requestRevision=reconcileRequestRevision;return enqueue(async()=>{const results=[];const changedStates=[];for(const state of states.values()){const operationEpoch=state.life[1];const operationGeneration=state.life[4];const operationContext=state.ctx;const operationColumn=reconcileColumnSnapshot(state);const owned=()=>filterOperationOwned(state,operationEpoch,operationGeneration,operationColumn,operationContext,requestRevision);const staleResult=()=>({status:"stale",key:state.fKey,generation:operationGeneration});if(!owned()){results.push(staleResult());continue}const result=await manager.filter.getModel(state.fKey);if(result.status!=="ok"){results.push(result);continue}if(!owned()){results.push(staleResult());continue}const comparison=comparePublishedModel(state,result.value);state.model=result.value;if(!comparison.changed){results.push(result);continue}state.life[8]=false;invalidateActive(state);readActive(state);await propagateParentModel(state,source,true);if(!owned()){results.push(staleResult());continue}notifyHostChanged(state,source);changedStates.push({state,owned});results.push(result)}if(changedStates.some(({owned})=>owned())){await Promise.all([...states.values()].filter(state=>currentFilterLookup(state)!==void 0&&operationIntentOwned(reconcileColumnSnapshot(state),state.ctx,requestRevision)).map(state=>manager.filter.onAnyFilterChanged(state.fKey)))}return results})},getSerializableModels(){const models=Object.create(null);const errors=[];for(const colId of[...states.keys()].sort()){const state=states.get(colId);const activeResult=readActive(state);if(activeResult.error!==void 0){errors.push(activeResult.error);continue}if(!activeResult.active)continue;const value=captureModelSync(state,errors);try{models[colId]=canonicalizeSerializable(value,new Set,`filterModel.${colId}`,0)}catch(cause){const error=facadeError("MODEL_FAILED","model","filter",`Filter "${colId}" returned a non-serializable model.`,state,cause);report(error);errors.push(error)}}return{revision:modelRevision,models:Object.freeze(models),errors:Object.freeze(errors)}},getFilterModels(){return enqueue(async()=>{const models=Object.create(null);const errors=[];for(const colId of[...states.keys()].sort()){const state=states.get(colId);const result=await manager.filter.getModel(state.fKey);if(result.status==="ok"){state.model=result.value;models[colId]=result.value}else if(result.status==="failed"){errors.push(result.error)}}return{revision:modelRevision,models:Object.freeze(models),errors:Object.freeze(errors)}})},getFilterModel(colId){return enqueue(async()=>{const state=states.get(colId);if(state===void 0){return{status:"not-mounted",key:filterKey(ownerId,colId)}}const result=await manager.filter.getModel(state.fKey);if(result.status==="ok")state.model=result.value;return result})},setFilterModel(colId,modelValue,source="api"){const requestRevision=reconcileRequestRevision;return enqueue(async()=>{const state=states.get(colId);return state===void 0?{status:"not-mounted",key:filterKey(ownerId,colId)}:setFilterModelInternal(state,modelValue,source,requestRevision)})},setFilterModels(models,setOptions){const requestRevision=reconcileRequestRevision;return enqueue(async()=>{const results=[];const changedStates=new Set;const source=setOptions?.source??"api";const clearUnspecified=setOptions?.clearUnspecified??true;for(const state of states.values()){const hasModel=Object.prototype.hasOwnProperty.call(models,state.id);if(!hasModel&&!clearUnspecified)continue;results.push(await setFilterModelInternal(state,hasModel?models[state.id]:null,source,requestRevision,changedStates))}if(changedStates.size>0){await Promise.all([...states.values()].filter(state=>currentFilterLookup(state)!==void 0&&(changedStates.size>1||!changedStates.has(state))).map(state=>manager.filter.onAnyFilterChanged(state.fKey).catch(()=>void 0)))}return results})},destroyFilter(colId){return enqueue(async()=>{const state=states.get(colId);return state===void 0?false:destroyStateInternal(state)})},recreateFilter(colId,recreateOptions){const requestRevision=reconcileRequestRevision;return enqueue(async()=>{if(disconnected){return{status:"disconnected",colId}}const state=states.get(colId);if(state===void 0||state.filterDef===void 0){return{status:"not-mounted",colId}}const operationEpoch=state.life[1];const operationContext=state.ctx;const operationColumn=reconcileColumnSnapshot(state);const intentOwned=()=>current(state,operationEpoch)&&operationIntentOwned(operationColumn,operationContext,requestRevision);const staleResult=()=>({status:"stale",colId});if(!intentOwned())return staleResult();const previousModel=captureModelSync(state);const retainedHost=state.filterAttach?.[0]??state.pendingFilter;state.pendingFilter=retainedHost;state.life[2]+=1;const callbackEpoch=state.life[2];let callbackGeneration=state.life[4];const callbackOwned=()=>ownsExactFilterGeneration(state,operationEpoch,callbackGeneration)&&latestIntentRetains(operationColumn,operationContext,false);await detachInternal(state);if(!intentOwned())return staleResult();let restoreLatchError;if(recreateOptions?.preserveModel??true){restoreLatchError=markModelRestorePending(state)}state.life[6]+=1;const result=await(async()=>{try{return await manager.filter.recreate(state.fKey,{componentName:state.fName,definition:state.filterDef,params:filterParams(state,callbackEpoch,callbackOwned)},recreateOptions)}finally{state.life[6]-=1}})();if(!intentOwned())return staleResult();if(result.status!=="mounted"){const error=result.status==="failed"?result.error:facadeError("MODEL_FAILED","model","filter",`Filter "${state.id}" recreation could not preserve its model.`,state,new Error(`Filter recreation settled as "${result.status}".`));if(result.status!=="failed")report(error);await latchModelRestoreFailure(state,error,previousModel,result.status==="not-mounted"?state.life[4]:result.generation,state.life[1]);return result.status==="failed"?{status:"failed",colId,error:result.error}:{status:"stale",colId}}callbackGeneration=result.generation;state.life[4]=result.generation;const finalizationOwned=()=>intentOwned()&&ownsExactFilterGeneration(state,operationEpoch,result.generation);if(!finalizationOwned())return staleResult();rebindFloatingCallback(state,operationEpoch,result.generation);if(restoreLatchError===void 0){invalidateActive(state)}else if(!clearExactModelRestoreLatch(state,state.life[1],result.generation,restoreLatchError)){return{status:"stale",colId}}const acceptedModel=captureModelSync(state);const transition=comparePublishedModel(state,acceptedModel);readActive(state);if(!finalizationOwned())return staleResult();if(transition.changed){await Promise.all([propagateParentModel(state,"api"),notifyPeers(state)]);if(finalizationOwned()){notifyHostChanged(state,"api")}else{return staleResult()}}if(!finalizationOwned())return staleResult();if(retainedHost!==void 0){const attached=await attachInternal(state,retainedHost);if(!finalizationOwned()){await detachInternal(state);return staleResult()}state.pendingFilter=void 0;return attached}return{status:"mounted",colId,generation:result.generation,gui:result.gui}})},lookupFilterInstance(colId){const state=states.get(colId);return state===void 0?{status:"unmounted",key:filterKey(ownerId,colId)}:manager.filter.runtime.lookup(state.fKey)},lookupFloatingFilterInstance(colId){const state=states.get(colId);return state===void 0?{status:"unmounted",key:floatingKey(ownerId,colId)}:manager.floatingFilter.runtime.lookup(state.ffKey)},setExternalFilter(source){return enqueue(async()=>disconnected?null:manager.setExternalFilter(source))},refreshExternalFilter(suppliedContext){return enqueue(async()=>{if(disconnected)return null;const external=manager.getExternalFilter();return external?.refresh(suppliedContext??context(),{signal:lifecycleController.signal})??null})},getExternalFilter(){return manager.getExternalFilter()},onNewRowsLoaded(){return enqueue(async()=>{const results=[];for(const state of states.values()){results.push(await manager.filter.onNewRowsLoaded(state.fKey))}return results})},stats(){let mountedFilters=0;let mountedFloatingFilters=0;let attachedFilterGuis=0;let attachedFloatingFilterGuis=0;for(const state of states.values()){if(currentFilterLookup(state)!==void 0)mountedFilters+=1;if(currentFloatingLookup(state)!==void 0){mountedFloatingFilters+=1}if(state.filterAttach!==void 0){attachedFilterGuis+=1}if(state.floatingAttach!==void 0){attachedFloatingFilterGuis+=1}}return{columns:states.size,mountedFilters,mountedFloatingFilters,attachedFilterGuis,attachedFloatingFilterGuis,modelRevision,reconcileRevision:appliedReconcileRevision,disconnected}},disconnect(){if(disconnectTask!==void 0)return disconnectTask;disconnected=true;reconcileRequestRevision+=1;lifecycleController.abort(new Error("Grid filter facade disconnected."));for(const state of states.values()){state.life[0].abort(new Error("Grid filter facade disconnected."))}disconnectTask=enqueue(async()=>{const retained=[...states.values()];for(const state of retained){await destroyStateInternal(state)}await manager.setExternalFilter(null)});return disconnectTask}};return controller}function linkController(parent){const controller=new AbortController;if(parent===void 0){return{controller,release:()=>void 0}}const onAbort=()=>controller.abort(parent.reason);if(parent.aborted)onAbort();else parent.addEventListener("abort",onAbort,{once:true});return{controller,release(){parent.removeEventListener("abort",onAbort)}}}function isRichSelectDeclaration(value){return typeof value==="object"&&value!==null&&value.type==="rich-select"}function sameRef(left,right){return left.key===right.key&&left.generation===right.generation}function lifecycleError(code,phase,ref,cause){if(cause instanceof contracts.GridComponentError)return cause;return new contracts.GridComponentError(`Editor "${ref.key}" facade failed during ${phase}.`,{code,phase,componentKind:"editor",mountKey:ref.key,generation:ref.generation,retryable:true,cause})}function lookupError(key,cause){if(cause instanceof contracts.GridComponentError)return cause;return new contracts.GridComponentError(`Editor "${key}" could not be resolved.`,{code:"COMPONENT_NOT_FOUND",phase:"lookup",componentKind:"editor",mountKey:key,retryable:true,cause})}function isTerminalStop(result){return!(result.status==="failed"||result.status==="invalid"&&result.mode==="block")}function transactionOutcome(result){if(result.status==="committed")return"committed";if(result.status==="failed"||result.status==="not-active"||result.status==="invalid"&&result.mode==="block"){return"retained"}return"cancelled"}function safeReport(callback,error){try{callback?.(error)}catch{}}function stopNotificationError(key,ref,cause){if(cause instanceof contracts.GridComponentError)return cause;return new contracts.GridComponentError(`Editor "${key}" host stop-result listener failed.`,{code:"FRAMEWORK_FAILED",phase:"framework",componentKind:"editor",mountKey:key,...ref===void 0?{}:{generation:ref.generation},retryable:false,cause})}function createGridEditorFacadeController(options){const{manager}=options;let active;let pending;let revision=0;let disposed=false;const notifyStopResult=(key,ref,listener,reason,origin,result)=>{if(listener===void 0)return;const outcome=transactionOutcome(result);try{listener({key,ref,reason,origin,result,transactionOutcome:outcome,terminal:outcome!=="retained"})}catch(cause){safeReport(options.onError,stopNotificationError(key,ref,cause))}};const notifyPendingStop=(operation,reason,origin)=>{const result={status:"cancelled-before-start",key:operation.key};if(!operation.stopNotified){operation.stopNotified=true;notifyStopResult(operation.key,void 0,operation.onStopResult,reason,origin,result)}return result};const retirePending=(operation,reason,origin)=>{if(pending===operation)pending=void 0;operation.removeOwnerAbortWatch?.();operation.removeOwnerAbortWatch=void 0;if(!operation.linked.controller.signal.aborted){operation.linked.controller.abort(new Error(`Pending editor stopped by ${reason}.`))}operation.linked.release();return notifyPendingStop(operation,reason,origin)};const currentSession=session=>{if(active!==session)return false;const lookup=manager.editor.runtime.lookup(session.ref.key);return lookup.status==="mounted"&&lookup.generation===session.ref.generation};const focusInSession=session=>{const focused=manager.editor.focusIn(session.ref.key,session.ref.generation);if(focused){session.focusOutCalled=false;session.focusOutResult=false}return focused};const focusOutSession=session=>{if(session.focusOutCalled)return session.focusOutResult;session.focusOutCalled=true;session.focusOutResult=manager.editor.focusOut(session.ref.key,session.ref.generation);return session.focusOutResult};const releaseSessionSignal=session=>{session.removeAbortWatch?.();session.removeAbortWatch=void 0;session.linked.release();if(!session.linked.controller.signal.aborted){session.linked.controller.abort(new Error(`Editor "${session.ref.key}" session ended.`))}};const detachOrphan=async(host,attachment,session,reason)=>{if(host.detach===void 0)return;try{await host.detach(attachment,{ref:session.ref,gui:session.gui,reason,params:session.params})}catch(cause){safeReport(options.onError,lifecycleError("DESTROY_FAILED","destroy",session.ref,cause))}};const detachSession=(session,reason)=>{if(session.detachTask!==void 0)return session.detachTask;if(!session.attached||session.host===void 0){return Promise.resolve()}const host=session.host;const attachment=session.attachment;session.attached=false;session.detachTask=detachOrphan(host,attachment,session,reason);return session.detachTask};const clearTerminalSession=async(session,reason)=>{if(active===session)active=void 0;releaseSessionSignal(session);await detachSession(session,reason)};const stopSession=(session,reason,cancel,origin="controller",restoreFocusOnRetain=true)=>{const shouldCancel=cancel??(reason==="escape"||reason==="disconnect");if(session.stopTask!==void 0){if(shouldCancel&&!session.stopCancelRequested&&active===session){session.stopCancelRequested=true;session.stopOverride={reason,origin,cancelTask:manager.editor.cancel(session.ref.key,session.ref.generation)}}return session.stopTask}session.stopCancelRequested=shouldCancel;let resolveTask;let rejectTask;const task=new Promise((resolve,reject)=>{resolveTask=resolve;rejectTask=reject});session.stopTask=task;const operation=(async()=>{focusOutSession(session);const request=session.commitOptions;let result=await manager.editor.stop(session.ref.key,{reason,cancel:shouldCancel,invalidMode:request.invalidMode,parseValue:request.parseValue,validate:request.validate,canCommit:request.canCommit,prepareCommit:request.prepareCommit,commit:(value,context)=>{if(request.commitPrepared(value,context)===false){throw new contracts.GridComponentError(`Editor "${session.ref.key}" host rejected the prepared commit.`,{code:"COMMIT_FAILED",phase:"commit",componentKind:"editor",mountKey:session.ref.key,generation:session.ref.generation,retryable:true,cause:new Error("The host commit choke point returned false.")})}}});let terminalReason=reason;let terminalOrigin=origin;const override=session.stopOverride;if(override!==void 0){await override.cancelTask;if(result.status!=="committed"){result={status:"cancelled",key:session.ref.key,generation:session.ref.generation};terminalReason=override.reason;terminalOrigin=override.origin}}if(restoreFocusOnRetain&&!isTerminalStop(result)&&active===session){focusInSession(session)}const cleanup=isTerminalStop(result)?clearTerminalSession(session,terminalReason):void 0;notifyStopResult(session.ref.key,session.ref,session.onStopResult,terminalReason,terminalOrigin,result);if(isTerminalStop(result)){await cleanup}return result})();void operation.then(result=>{if(session.stopTask===task)session.stopTask=void 0;resolveTask(result)},cause=>{if(session.stopTask===task)session.stopTask=void 0;rejectTask(cause)});return task};const forceCancelSession=async(session,reason,origin)=>{if(active!==session)return;focusOutSession(session);await manager.editor.cancel(session.ref.key,session.ref.generation);const result={status:"cancelled",key:session.ref.key,generation:session.ref.generation};const cleanup=clearTerminalSession(session,reason);notifyStopResult(session.ref.key,session.ref,session.onStopResult,reason,origin,result);await cleanup};const abortInFlightStop=(session,reason)=>{if(session.stopTask===void 0||session.linked.controller.signal.aborted){return}session.removeAbortWatch?.();session.removeAbortWatch=void 0;session.linked.controller.abort(new Error(`Editor "${session.ref.key}" forced to stop by ${reason}.`))};const cancelAbortedSession=async session=>{if(active!==session)return;const result=await stopSession(session,"disconnect",true,"owner-abort",false);if(!isTerminalStop(result)){await forceCancelSession(session,"disconnect","owner-abort")}};const resolveDeclaration=async(request,signal)=>{const declaration=request.declaration;if(typeof declaration==="string"){const resolved2=await manager.resolve({kind:"editor",name:declaration,local:request.local,signal});return{name:resolved2.name,definition:resolved2.definition}}if(isRichSelectDeclaration(declaration)){const richDefinition=manager.createRichSelectEditor(declaration);const resolved2=await manager.resolve({kind:"editor",name:"rich-select",definition:richDefinition,signal});return{name:resolved2.name,definition:resolved2.definition}}const resolved=await manager.resolve({kind:"editor",definition:declaration,signal});return{name:resolved.name,definition:resolved.definition}};const controller={async begin(request){if(disposed){notifyStopResult(request.key,void 0,request.onStopResult,"disconnect","disconnect",{status:"cancelled-before-start",key:request.key});return{status:"failed",key:request.key,error:lookupError(request.key,new Error("Editor facade is disconnected."))}}if(request.key.trim().length===0){notifyStopResult(request.key,void 0,request.onStopResult,"api","lifecycle",{status:"cancelled-before-start",key:request.key});return{status:"failed",key:request.key,error:lookupError(request.key,new Error("Editor key must be non-empty."))}}const beginRevision=++revision;if(pending!==void 0){retirePending(pending,"replacement","replacement")}const previous=active;if(previous!==void 0){const stopResult=await stopSession(previous,"replacement",void 0,"replacement");if(beginRevision!==revision||disposed){return{status:"stale",key:request.key}}if(active===previous){return{status:"blocked-by-active",active:previous.ref,stopResult}}}const linked=linkController(request.params.signal);const operation={revision:beginRevision,key:request.key,linked,onStopResult:request.onStopResult,stopNotified:false,removeOwnerAbortWatch:void 0,requestedStop:void 0};pending=operation;const ownerSignal=request.params.signal;if(ownerSignal!==void 0){const onOwnerAbort=()=>{if(pending===operation){retirePending(operation,"disconnect","owner-abort")}};if(ownerSignal.aborted)onOwnerAbort();else{ownerSignal.addEventListener("abort",onOwnerAbort,{once:true});operation.removeOwnerAbortWatch=()=>ownerSignal.removeEventListener("abort",onOwnerAbort)}}let sessionForStop;const stopEditing=(cancel=false)=>{operation.requestedStop={reason:cancel?"escape":"api",cancel,origin:"component"};if(sessionForStop!==void 0&&active===sessionForStop){void stopSession(sessionForStop,operation.requestedStop.reason,operation.requestedStop.cancel,operation.requestedStop.origin)}};try{const resolved=await resolveDeclaration(request,linked.controller.signal);if(disposed||beginRevision!==revision||pending!==operation||linked.controller.signal.aborted){linked.release();notifyPendingStop(operation,disposed?"disconnect":"api",disposed?"disconnect":"lifecycle");return{status:"stale",key:request.key}}const started=await manager.editor.start({key:request.key,componentName:resolved.name,definition:resolved.definition,params:{...request.params,signal:linked.controller.signal,stopEditing}});if(disposed||beginRevision!==revision||pending!==operation||linked.controller.signal.aborted){if(started.status==="started"){await manager.editor.cancel(started.key,started.generation)}linked.release();notifyPendingStop(operation,disposed?"disconnect":"api",disposed?"disconnect":"lifecycle");return{status:"stale",key:request.key}}pending=void 0;operation.removeOwnerAbortWatch?.();operation.removeOwnerAbortWatch=void 0;if(started.status!=="started"&&operation.requestedStop!==void 0){notifyPendingStop(operation,operation.requestedStop.reason,operation.requestedStop.origin)}if(started.status!=="started"){notifyPendingStop(operation,"api","lifecycle")}if(started.status==="cancelled-before-start"){linked.release();return{status:"cancelled-before-start",ref:{key:started.key,generation:started.generation}}}if(started.status==="failed"){linked.release();return{status:"failed",key:request.key,error:started.error}}if(started.status==="stale"){linked.release();return{status:"stale",key:request.key}}const session={ref:{key:started.key,generation:started.generation},gui:started.gui,popup:started.popup,popupPosition:started.popupPosition,params:request.params,commitOptions:request,onStopResult:request.onStopResult,linked,host:void 0,attachment:void 0,attached:false,attachTask:void 0,detachTask:void 0,stopTask:void 0,stopCancelRequested:false,stopOverride:void 0,removeAbortWatch:void 0,focusOutCalled:false,focusOutResult:false};active=session;sessionForStop=session;const onAbort=()=>{void cancelAbortedSession(session)};linked.controller.signal.addEventListener("abort",onAbort,{once:true});session.removeAbortWatch=()=>linked.controller.signal.removeEventListener("abort",onAbort);if(operation.requestedStop!==void 0){const stopResult=await stopSession(session,operation.requestedStop.reason,operation.requestedStop.cancel,operation.requestedStop.origin);return{status:"stopped-before-attach",ref:session.ref,stopResult}}return{status:"started",ref:session.ref,gui:session.gui,popup:session.popup,popupPosition:session.popupPosition,instance:started.instance}}catch(cause){if(pending===operation)pending=void 0;operation.removeOwnerAbortWatch?.();operation.removeOwnerAbortWatch=void 0;if(operation.requestedStop!==void 0){notifyPendingStop(operation,operation.requestedStop.reason,operation.requestedStop.origin)}notifyPendingStop(operation,disposed?"disconnect":"api",disposed?"disconnect":"lifecycle");linked.release();if(disposed||beginRevision!==revision||linked.controller.signal.aborted){return{status:"stale",key:request.key}}const error=lookupError(request.key,cause);safeReport(options.onError,error);return{status:"failed",key:request.key,error}}},attach(ref,host){const session=active;if(session===void 0||!sameRef(session.ref,ref)){return Promise.resolve({status:"stale",ref})}if(session.attachTask!==void 0)return session.attachTask;const task=(async()=>{let placement;let attachment;let attachedByHost=false;let phase="popup";try{if(session.popup&&host.calculatePopupPlacement!==void 0){placement=await host.calculatePopupPlacement({ref:session.ref,gui:session.gui,preferred:session.popupPosition,cellElement:session.params.cellElement,params:session.params,signal:session.linked.controller.signal})}if(!currentSession(session)){return{status:"stale",ref:session.ref}}phase="after-attach";attachment=await host.attach({ref:session.ref,gui:session.gui,mode:session.popup?"popup":"inline",popupPosition:session.popupPosition,placement,cellElement:session.params.cellElement,params:session.params,signal:session.linked.controller.signal});attachedByHost=true;if(!currentSession(session)){await detachOrphan(host,attachment,session,"stale");return{status:"stale",ref:session.ref}}session.host=host;session.attachment=attachment;session.attached=true;const afterAttach=await manager.editor.afterAttach(session.ref.key,session.ref.generation);if(afterAttach.status==="attached"){return{status:"attached",ref:session.ref,mode:session.popup?"popup":"inline"}}const ownedSession=active===session;if(ownedSession){active=void 0;releaseSessionSignal(session);notifyStopResult(session.ref.key,session.ref,session.onStopResult,"api","lifecycle",{status:"cancelled",key:session.ref.key,generation:session.ref.generation})}const cleanup=detachSession(session,afterAttach.status==="stale"?"stale":"attach-failed");await cleanup;if(afterAttach.status==="failed"){safeReport(options.onError,afterAttach.error);return{status:"failed",ref:session.ref,error:afterAttach.error}}return{status:"stale",ref:session.ref}}catch(cause){const ownedSession=active===session;if(ownedSession){active=void 0;releaseSessionSignal(session);notifyStopResult(session.ref.key,session.ref,session.onStopResult,"api","lifecycle",{status:"cancelled",key:session.ref.key,generation:session.ref.generation})}const orphanCleanup=attachedByHost?detachOrphan(host,attachment,session,"attach-failed"):Promise.resolve();await manager.editor.cancel(session.ref.key,session.ref.generation);await orphanCleanup;const error=lifecycleError(phase==="popup"?"POPUP_FAILED":"AFTER_ATTACH_FAILED",phase,session.ref,cause);safeReport(options.onError,error);return{status:"failed",ref:session.ref,error}}})();session.attachTask=task;return task},stop(reason,stopOptions={}){const session=active;if(session===void 0){if(pending!==void 0){return Promise.resolve(retirePending(pending,reason,"controller"))}return Promise.resolve({status:"not-active"})}return stopSession(session,reason,stopOptions.cancel)},async handleKey(event){if(event.isComposing===true)return{handled:false};let reason;if(event.key==="Enter")reason="enter";else if(event.key==="Tab")reason="tab";else if(event.key==="Escape"||event.key==="Esc"){reason="escape"}else{return{handled:false}}try{event.preventDefault?.()}catch{}const result=await controller.stop(reason);if(reason!=="tab")return{handled:true,reason,result};return{handled:true,reason,navigation:event.shiftKey===true?"previous-cell":"next-cell",result}},handleBlur(){return controller.stop("blur")},handleMouseStop(){return controller.stop("mouse")},lookup(){if(active!==void 0){return{status:"mounted",ref:active.ref,gui:active.gui,popup:active.popup,popupPosition:active.popupPosition,attached:active.attached,params:active.params}}return pending===void 0?{status:"idle"}:{status:"starting",key:pending.key}},focusIn(ref){const session=active;if(session===void 0||ref!==void 0&&!sameRef(session.ref,ref)){return false}return focusInSession(session)},focusOut(ref){const session=active;if(session===void 0||ref!==void 0&&!sameRef(session.ref,ref)){return false}return focusOutSession(session)},async destroy(ref){const session=active;if(session===void 0||ref!==void 0&&!sameRef(session.ref,ref)){return false}abortInFlightStop(session,"api");const result=await stopSession(session,"api",true,"controller",false);if(!isTerminalStop(result)){await forceCancelSession(session,"api","controller")}return result.status!=="not-mounted"},async disconnect(){if(disposed)return;disposed=true;++revision;if(pending!==void 0){retirePending(pending,"disconnect","disconnect")}const session=active;if(session!==void 0){abortInFlightStop(session,"disconnect");const result=await stopSession(session,"disconnect",true,"disconnect",false);if(!isTerminalStop(result)){await forceCancelSession(session,"disconnect","disconnect")}}},stats(){return{active:active===void 0?0:1,attached:active!==void 0&&active.attached?1:0,starting:pending===void 0?0:1,disposed,revision}}};return controller}function hasValidationChild(wrapper){try{for(const child of Array.from(wrapper.children)){if(child.classList.contains("sy-grid__cell-editor-validation")){return true}}}catch{return true}return false}function clearValidationAttributesIfUnused(wrapper){if(hasValidationChild(wrapper))return;try{wrapper.removeAttribute("aria-invalid")}catch{}try{wrapper.removeAttribute("data-invalid")}catch{}}function renderGridEditorValidation(wrapper,message){let element;try{if(!wrapper.isConnected)return null;element=wrapper.ownerDocument.createElement("div");element.className="sy-grid__cell-editor-validation";element.setAttribute("role","alert");element.setAttribute("aria-live","polite");element.textContent=message;wrapper.setAttribute("aria-invalid","true");wrapper.dataset.invalid="true";wrapper.append(element)}catch{try{element?.remove()}catch{}clearValidationAttributesIfUnused(wrapper);return null}let cleared=false;return{wrapper,element,clear(){if(cleared)return;cleared=true;try{element.remove()}catch{}clearValidationAttributesIfUnused(wrapper)}}}function finite(value,fallback=0){return Number.isFinite(value)?value:fallback}function clamp(value,lower,upper){if(upper<lower)return lower;return Math.min(Math.max(value,lower),upper)}function placeGridEditorPopup(anchor,popup,viewport,options={}){const margin=Math.max(0,finite(options.margin??8,8));const gap=Math.max(0,finite(options.gap??4,4));const viewportLeft=finite(viewport.left)+margin;const viewportTop=finite(viewport.top)+margin;const viewportRight=Math.max(viewportLeft,finite(viewport.right,viewportLeft)-margin);const viewportBottom=Math.max(viewportTop,finite(viewport.bottom,viewportTop)-margin);const maxWidth=Math.max(0,viewportRight-viewportLeft);const requestedWidth=Math.max(options.touch===true?44:0,finite(popup.width),finite(anchor.width));const width=Math.min(requestedWidth,maxWidth);const popupHeight=Math.max(0,finite(popup.height));const rawLeft=options.rtl===true?finite(anchor.right)-width:finite(anchor.left);const left=clamp(rawLeft,viewportLeft,viewportRight-width);const preferred=options.preferred??"over";if(preferred==="over"){const top=clamp(finite(anchor.top),viewportTop,viewportBottom);const maxHeight=Math.max(0,viewportBottom-top);return{position:"fixed",placement:"over",left,top,width,maxWidth,maxHeight}}const belowTop=finite(anchor.bottom)+gap;const underTop=Math.max(viewportTop,belowTop);const aboveBottom=finite(anchor.top)-gap;const belowSpace=Math.max(0,viewportBottom-underTop);const aboveSpace=Math.max(0,aboveBottom-viewportTop);const useAbove=belowSpace<popupHeight&&aboveSpace>belowSpace;if(useAbove){const maxHeight=aboveSpace;const visibleHeight=Math.min(popupHeight,maxHeight);return{position:"fixed",placement:"above",left,top:Math.max(viewportTop,aboveBottom-visibleHeight),width,maxWidth,maxHeight}}return{position:"fixed",placement:"under",left,top:underTop,width,maxWidth,maxHeight:belowSpace}}const sharedGlobalRegistry=createGridComponentRegistry();function hasOwn(value,key){return Object.prototype.hasOwnProperty.call(value,key)}function normalizedComponentName(value){return typeof value==="string"&&value.trim().length>0?value.trim():void 0}function hasRequestLocalDefinition(request,name){const local=request.local;if(local===void 0)return false;const group=local[request.kind];return group!==null&&group!==void 0&&typeof group==="object"&&hasOwn(group,name)}function linkAbortSignals(requestSignal,lifecycleSignal){if(requestSignal===void 0||requestSignal===lifecycleSignal){return{signal:requestSignal??lifecycleSignal,release(){}}}const controller=new AbortController;const sources=[requestSignal,lifecycleSignal];const listeners=[];for(const source of sources){if(source.aborted){controller.abort(source.reason);break}const onAbort=()=>controller.abort(source.reason);source.addEventListener("abort",onAbort,{once:true});listeners.push([source,onAbort])}return{signal:controller.signal,release(){for(const[source,listener]of listeners){source.removeEventListener("abort",listener)}listeners.length=0}}}function asGlobalRegistry(){return sharedGlobalRegistry}function createGridComponentManager(options={}){const local=createGridComponentRegistry();const global=asGlobalRegistry();const lifecycleController=new AbortController;const reportError=options.onError===void 0?void 0:error=>{try{options.onError?.(error)}catch{}};const runtimeOptions={timeoutMs:options.timeoutMs,onError:reportError};const renderer=createGridRendererController({...options.renderer,runtime:runtimeOptions,onError:reportError});const editor=createGridEditorAdapter(runtimeOptions);const filter=createGridFilterAdapter({...runtimeOptions,modelsEqual:options.modelsEqual});const floatingFilter=createGridFloatingFilterAdapter({...runtimeOptions,modelsEqual:options.modelsEqual});let external=null;let disconnected=false;let disconnectTask;let externalRevision=0;let externalTail=Promise.resolve();let externalAvailabilityCleanup;let externalUnavailableSource;function abortedLookupError(kind,name,cause){return new contracts.GridComponentError(`${kind} component lookup was aborted because the grid disconnected or the request was cancelled.`,{code:"ABORTED",phase:"lookup",componentKind:kind,componentName:name,retryable:true,cause})}function assertConnected(kind,name){if(!disconnected)return;throw abortedLookupError(kind,normalizedComponentName(name),lifecycleController.signal.reason)}return{renderer,editor,filter,floatingFilter,register(scope,kind,name,definition){assertConnected(kind,name);(scope==="global"?global:local).register(scope,kind,name,definition)},replace(scope,kind,name,definition){assertConnected(kind,name);(scope==="global"?global:local).replace(scope,kind,name,definition)},unregister(scope,kind,name){assertConnected(kind,name);return(scope==="global"?global:local).unregister(scope,kind,name)},list(scope,kind){return(scope==="global"?global:local).list(scope,kind)},async resolve(request){const name=normalizedComponentName(request.name);assertConnected(request.kind,name);const linked=linkAbortSignals(request.signal,lifecycleController.signal);try{if(linked.signal.aborted){throw abortedLookupError(request.kind,name,linked.signal.reason)}const resolveLocally=hasOwn(request,"definition")||name===void 0||hasRequestLocalDefinition(request,name)||local.has("local",request.kind,name);const forwardedRequest={kind:request.kind,name:request.name,local:request.local,signal:linked.signal,...hasOwn(request,"definition")?{definition:request.definition}:{}};const resolved=resolveLocally?await local.resolve(forwardedRequest):await global.resolve(forwardedRequest);if(disconnected||linked.signal.aborted){throw abortedLookupError(request.kind,name,linked.signal.reason)}return resolved}finally{linked.release()}},setExternalFilter(source){if(disconnected)return Promise.resolve(null);if(source!==null&&externalAvailabilityCleanup!==void 0&&Object.is(externalUnavailableSource,source)){return Promise.resolve(null)}externalAvailabilityCleanup?.();externalAvailabilityCleanup=void 0;externalUnavailableSource=void 0;const revision=++externalRevision;const operation=externalTail.then(async()=>{if(disconnected||revision!==externalRevision)return null;const previous=external;external=null;await previous?.destroy();if(disconnected||revision!==externalRevision||source===null){return null}let next;try{next=createGridExternalFilterController(source,{timeoutMs:options.timeoutMs,onError:reportError})}catch(cause){if(cause instanceof contracts.GridComponentError&&cause.code==="INVALID_INSTANCE"){reportError?.(cause);externalUnavailableSource=source;externalAvailabilityCleanup=subscribeGridExternalFilterAvailability(source,()=>{externalAvailabilityCleanup=void 0;externalUnavailableSource=void 0;if(disconnected||revision!==externalRevision){return}try{options.onExternalFilterAvailable?.()}catch{}});return null}throw cause}external=next;return next});externalTail=operation.then(()=>void 0,()=>void 0);return operation},getExternalFilter(){return external},createRichSelectEditor(richSelectOptions){return createGridRichSelectEditorDefinition(richSelectOptions)},disconnect(){if(disconnectTask!==void 0)return disconnectTask;disconnected=true;++externalRevision;externalAvailabilityCleanup?.();externalAvailabilityCleanup=void 0;externalUnavailableSource=void 0;lifecycleController.abort(new Error("Grid component manager disconnected."));local.clear();const componentCleanup=Promise.all([renderer.dispose(),editor.runtime.dispose(),filter.disconnect(),floatingFilter.disconnect()]);const externalCleanup=(async()=>{await externalTail;const previousExternal=external;external=null;await previousExternal?.destroy()})();disconnectTask=Promise.all([componentCleanup,externalCleanup]).then(()=>void 0);return disconnectTask}}}exports.createGridComponentManager=createGridComponentManager;exports.createGridEditorFacadeController=createGridEditorFacadeController;exports.createGridFilterFacadeController=createGridFilterFacadeController;exports.placeGridEditorPopup=placeGridEditorPopup;exports.renderGridEditorValidation=renderGridEditorValidation;

package/dist/cjs/connector-8ebOKxbI.js

@@ -0,0 +1 @@
+"use strict";const DEFAULT_FALLBACK=["top","right","bottom","left"];function _centerAlong(reference,tooltipSize,side){if(side==="top"||side==="bottom"){return reference.x+reference.width/2-tooltipSize.width/2}return reference.y+reference.height/2-tooltipSize.height/2}function _placeOnSide(reference,tooltipSize,side,offset){if(side==="top"){return{x:_centerAlong(reference,tooltipSize,"top"),y:reference.y-tooltipSize.height-offset}}if(side==="bottom"){return{x:_centerAlong(reference,tooltipSize,"bottom"),y:reference.y+reference.height+offset}}if(side==="left"){return{x:reference.x-tooltipSize.width-offset,y:_centerAlong(reference,tooltipSize,"left")}}return{x:reference.x+reference.width+offset,y:_centerAlong(reference,tooltipSize,"right")}}function _overflowAgainst(rect,viewport,padding){const top=Math.max(0,viewport.y+padding-rect.y);const left=Math.max(0,viewport.x+padding-rect.x);const right=Math.max(0,rect.x+rect.width-(viewport.x+viewport.width-padding));const bottom=Math.max(0,rect.y+rect.height-(viewport.y+viewport.height-padding));return{top,right,bottom,left}}function coerceNonNegative(value,def){if(value===void 0)return def;if(typeof value!=="number"||!Number.isFinite(value)||value<0){return 0}return value}function isValidSide(side){return side==="top"||side==="right"||side==="bottom"||side==="left"}function dedupeSides(sides,exclude){const order=sides??DEFAULT_FALLBACK;const seen=new Set;const out=[];for(const side of order){if(!isValidSide(side))continue;if(side===exclude)continue;if(seen.has(side))continue;seen.add(side);out.push(side)}return out}function anchorToRect(anchor){if(anchor.kind==="point"){return{x:anchor.x,y:anchor.y,width:0,height:0}}return{x:anchor.x,y:anchor.y,width:anchor.width,height:anchor.height}}function isAnchorFinite(anchor){if(anchor.kind==="point"){return Number.isFinite(anchor.x)&&Number.isFinite(anchor.y)}return Number.isFinite(anchor.x)&&Number.isFinite(anchor.y)&&Number.isFinite(anchor.width)&&Number.isFinite(anchor.height)}function totalOverflow(o){return o.top+o.right+o.bottom+o.left}function clamp(value,lo,hi){if(lo>hi)return lo;if(value<lo)return lo;if(value>hi)return hi;return value}function horizontalLineOverlap(y,height,lineY,gap){const bandTop=lineY-gap;const bandBottom=lineY+gap;return Math.max(0,Math.min(y+height,bandBottom)-Math.max(y,bandTop))}function avoidHorizontalLineOverlap(input){const{x,y,tooltip,viewport,side,lineY}=input;if(side!=="left"&&side!=="right")return{x,y};if(!tooltip||!viewport||!Number.isFinite(x)||!Number.isFinite(y)||!Number.isFinite(tooltip.width)||!Number.isFinite(tooltip.height)||tooltip.width<=0||tooltip.height<=0||!Number.isFinite(viewport.x)||!Number.isFinite(viewport.y)||!Number.isFinite(viewport.width)||!Number.isFinite(viewport.height)||viewport.width<=0||viewport.height<=0||!Number.isFinite(lineY)){return{x,y}}const gap=coerceNonNegative(input.gap,4);const padding=coerceNonNegative(input.padding,4);const minY=viewport.y+padding;const maxY=viewport.y+viewport.height-tooltip.height-padding;const currentY=clamp(y,minY,maxY);if(horizontalLineOverlap(currentY,tooltip.height,lineY,gap)===0){return{x,y:currentY}}const aboveY=lineY-tooltip.height-gap;const belowY=lineY+gap;const candidates=[aboveY,belowY].map((candidateY,index)=>{const nextY=clamp(candidateY,minY,maxY);return{y:nextY,overlap:horizontalLineOverlap(nextY,tooltip.height,lineY,gap),distance:Math.abs(nextY-currentY),index}}).sort((a,b)=>a.overlap-b.overlap||a.distance-b.distance||a.index-b.index);return{x,y:candidates[0]?.y??currentY}}function computeTooltipPlacement(input){const{anchor,tooltip,viewport,preferredSide:preferredSideInput,offset:offsetInput,padding:paddingInput,flipFallbackOrder}=input;if(!tooltip||!Number.isFinite(tooltip.width)||!Number.isFinite(tooltip.height)||tooltip.width<=0||tooltip.height<=0){console.warn("[Syidax] sy-chart tooltip-engine: degenerate tooltip size; falling back to viewport top-left.");const side=isValidSide(preferredSideInput)?preferredSideInput:"top";return{x:viewport?.x??0,y:viewport?.y??0,side,flipped:false,clamped:false,overflow:{top:0,right:0,bottom:0,left:0}}}if(!viewport||!Number.isFinite(viewport.x)||!Number.isFinite(viewport.y)||!Number.isFinite(viewport.width)||!Number.isFinite(viewport.height)||viewport.width<=0||viewport.height<=0){console.warn("[Syidax] sy-chart tooltip-engine: degenerate viewport; falling back to viewport top-left.");const side=isValidSide(preferredSideInput)?preferredSideInput:"top";return{x:viewport?.x??0,y:viewport?.y??0,side,flipped:false,clamped:false,overflow:{top:0,right:0,bottom:0,left:0}}}const offset=coerceNonNegative(offsetInput,8);const padding=coerceNonNegative(paddingInput,4);let preferredSide;if(isValidSide(preferredSideInput)){preferredSide=preferredSideInput}else if(preferredSideInput===void 0){preferredSide="top"}else{console.warn(`[Syidax] sy-chart tooltip-engine: invalid preferredSide "${String(preferredSideInput)}"; coerced to "top".`);preferredSide="top"}let workingAnchor;if(!anchor||anchor.kind!=="point"&&anchor.kind!=="rect"){console.warn("[Syidax] sy-chart tooltip-engine: invalid anchor; coerced to viewport center.");workingAnchor={kind:"point",x:viewport.x+viewport.width/2,y:viewport.y+viewport.height/2}}else if(!isAnchorFinite(anchor)){console.warn("[Syidax] sy-chart tooltip-engine: non-finite anchor; coerced to viewport center.");workingAnchor={kind:"point",x:viewport.x+viewport.width/2,y:viewport.y+viewport.height/2}}else{workingAnchor=anchor}const reference=anchorToRect(workingAnchor);const preferredPos=_placeOnSide(reference,tooltip,preferredSide,offset);const preferredRect={x:preferredPos.x,y:preferredPos.y,width:tooltip.width,height:tooltip.height};const preferredOverflow=_overflowAgainst(preferredRect,viewport,padding);if(totalOverflow(preferredOverflow)===0){return{x:preferredPos.x,y:preferredPos.y,side:preferredSide,flipped:false,clamped:false,overflow:{top:0,right:0,bottom:0,left:0}}}const fallbacks=dedupeSides(flipFallbackOrder,preferredSide);let bestSide=preferredSide;let bestPos=preferredPos;let bestTotal=totalOverflow(preferredOverflow);for(const side of fallbacks){const pos=_placeOnSide(reference,tooltip,side,offset);const r={x:pos.x,y:pos.y,width:tooltip.width,height:tooltip.height};const overflow=_overflowAgainst(r,viewport,padding);const total=totalOverflow(overflow);if(total===0){return{x:pos.x,y:pos.y,side,flipped:true,clamped:false,overflow:{top:0,right:0,bottom:0,left:0}}}if(total<bestTotal){bestTotal=total;bestSide=side;bestPos=pos}}const minX=viewport.x+padding;const maxX=viewport.x+viewport.width-tooltip.width-padding;const minY=viewport.y+padding;const maxY=viewport.y+viewport.height-tooltip.height-padding;const clampedX=clamp(bestPos.x,minX,maxX);const clampedY=clamp(bestPos.y,minY,maxY);const clampedRect={x:clampedX,y:clampedY,width:tooltip.width,height:tooltip.height};const clampedOverflow=_overflowAgainst(clampedRect,viewport,padding);return{x:clampedX,y:clampedY,side:bestSide,flipped:bestSide!==preferredSide,clamped:true,overflow:clampedOverflow}}function avoidTooltipCardOverlap(cards,viewport,gap=6){const result=cards.map(card=>({...card})),occupied=[];const area=(a,b)=>Math.max(0,Math.min(a.x+a.width+gap,b.x+b.width)-Math.max(a.x-gap,b.x))*Math.max(0,Math.min(a.y+a.height+gap,b.y+b.height)-Math.max(a.y-gap,b.y));for(const card of result)if(card.locked)occupied.push(card);for(const card of result){if(card.locked)continue;const clamp2=(x,y)=>({...card,x:Math.max(gap,Math.min(Math.max(gap,viewport.width-gap-card.width),x)),y:Math.max(gap,Math.min(Math.max(gap,viewport.height-gap-card.height),y))});const base=clamp2(card.x,card.y),candidates=[base];for(const other of occupied){const xs=[base.x,other.x-card.width-gap,other.x+other.width+gap];const ys=[base.y,other.y+other.height+gap,other.y-card.height-gap];for(const y of ys)for(const x of xs)candidates.push(clamp2(x,y))}let best=base,bestArea=Infinity,bestDistance=Infinity;for(const candidate of candidates){const overlap=occupied.reduce((sum,other)=>sum+area(candidate,other),0);const distance=(candidate.x-base.x)**2+(candidate.y-base.y)**2;if(overlap<bestArea||overlap===bestArea&&distance<bestDistance){best=candidate;bestArea=overlap;bestDistance=distance}}card.x=best.x;card.y=best.y;occupied.push(card)}return result}function tooltipBoxBounds(input){const offset=input.offset??10;const width=input.box?.width??0;const height=input.box?.height??0;const left=input.side==="left"?input.cssX-offset-width:input.side==="right"?input.cssX+offset:input.cssX-width/2;const top=input.side==="top"?input.cssY-offset-height:input.side==="bottom"?input.cssY+offset:input.cssY-height/2;return{left,top,right:left+width,bottom:top+height}}function closestMidpoint(point,candidates){return candidates.map(candidate=>({candidate,distanceSq:(candidate.x-point.x)**2+(candidate.y-point.y)**2})).sort((a,b)=>a.distanceSq-b.distanceSq)[0].candidate}function tooltipConnectorEnd(input){const offset=input.offset??10;if(!input.box){if(input.side==="top")return{x:input.cssX,y:input.cssY-offset};if(input.side==="bottom")return{x:input.cssX,y:input.cssY+offset};if(input.side==="left")return{x:input.cssX-offset,y:input.cssY};return{x:input.cssX+offset,y:input.cssY}}const{left,top,right,bottom}=tooltipBoxBounds(input);const midX=(left+right)/2;const midY=(top+bottom)/2;const point={x:input.pointCssX,y:input.pointCssY};const edgeMidpoints={bottom:{x:midX,y:bottom},right:{x:right,y:midY},left:{x:left,y:midY},top:{x:midX,y:top}};const candidates=[];if(bottom<input.pointCssY)candidates.push(edgeMidpoints.bottom);if(right<input.pointCssX)candidates.push(edgeMidpoints.right);if(left>input.pointCssX)candidates.push(edgeMidpoints.left);if(top>input.pointCssY)candidates.push(edgeMidpoints.top);return closestMidpoint(point,candidates.length>0?candidates:Object.values(edgeMidpoints))}exports.avoidHorizontalLineOverlap=avoidHorizontalLineOverlap;exports.avoidTooltipCardOverlap=avoidTooltipCardOverlap;exports.computeTooltipPlacement=computeTooltipPlacement;exports.tooltipConnectorEnd=tooltipConnectorEnd;

package/dist/cjs/contracts-CtPI2qPw.js

@@ -0,0 +1 @@
+"use strict";class GridComponentError extends Error{code;phase;componentKind;componentName;mountKey;generation;retryable;cause;constructor(message,details){super(message);this.name="GridComponentError";this.code=details.code;this.phase=details.phase;this.componentKind=details.componentKind;this.componentName=details.componentName;this.mountKey=details.mountKey;this.generation=details.generation;this.retryable=details.retryable;this.cause=details.cause}}exports.GridComponentError=GridComponentError;

package/dist/cjs/data-zoom-model-DWEnQJnh.js

@@ -0,0 +1 @@
+"use strict";var zoomWindow=require("./zoom-window-oCyi6HPg.js");const DATA_ZOOM_TRACK_PAD=8;function dataZoomTrackFor(orientation,width,height){if(orientation==="horizontal")return{start:DATA_ZOOM_TRACK_PAD,end:Math.max(DATA_ZOOM_TRACK_PAD+1,width-DATA_ZOOM_TRACK_PAD)};return{start:Math.max(DATA_ZOOM_TRACK_PAD+1,height-DATA_ZOOM_TRACK_PAD),end:DATA_ZOOM_TRACK_PAD}}function normalizeDataZoomExtent(extent){if(!extent||!Number.isFinite(extent.min)||!Number.isFinite(extent.max))return null;const min=Math.min(extent.min,extent.max);const max=Math.max(extent.min,extent.max);if(!(max>min))return null;return{min,max}}function resolveDataZoomWindow(window,extent,minSpan=0){if(!window)return{min:extent.min,max:extent.max};const raw=Array.isArray(window)?{min:window[0],max:window[1]}:window;return zoomWindow.clampZoomWindow({min:raw.min,max:raw.max},extent,minSpan)}function isFullDataZoomWindow(window,extent){return zoomWindow.isFullZoomWindow(window??void 0,extent)}function dataZoomWindowsEqual(a,b,epsilon=1e-9){if(a===b)return true;if(!a||!b)return false;return Math.abs(a.min-b.min)<=epsilon&&Math.abs(a.max-b.max)<=epsilon}function dataZoomTrackPixel(value,extent,track){const span=extent.max-extent.min;if(!(span>0))return track.start;return track.start+(value-extent.min)/span*(track.end-track.start)}function dataZoomTrackValue(px,extent,track){const length=track.end-track.start;if(length===0)return extent.min;return extent.min+(px-track.start)/length*(extent.max-extent.min)}function dataZoomWindowPixels(window,extent,track){return{start:dataZoomTrackPixel(window.min,extent,track),end:dataZoomTrackPixel(window.max,extent,track)}}function dataZoomSpanForPixels(pixels,extent,track){const length=Math.abs(track.end-track.start);const span=extent.max-extent.min;if(!(length>0)||!(pixels>0))return 0;return Math.min(span,span*(pixels/length))}function dragDataZoomWindow(kind,startWindow,deltaPx,extent,track,minSpan=0){const length=track.end-track.start;if(!Number.isFinite(deltaPx)||length===0)return startWindow;const deltaValue=deltaPx/length*(extent.max-extent.min);const floor=Math.max(0,Math.min(minSpan,extent.max-extent.min));if(kind==="window")return zoomWindow.clampZoomWindow({min:startWindow.min+deltaValue,max:startWindow.max+deltaValue},extent,floor);if(kind==="handle-min"){const min=Math.max(extent.min,Math.min(startWindow.max-floor,startWindow.min+deltaValue));return{min,max:startWindow.max}}const max=Math.min(extent.max,Math.max(startWindow.min+floor,startWindow.max+deltaValue));return{min:startWindow.min,max}}function stepDataZoomWindow(window,extent,fraction){const span=window.max-window.min;if(!Number.isFinite(fraction)||fraction===0||!(span>0))return window;const delta=span*fraction;return zoomWindow.clampZoomWindow({min:window.min+delta,max:window.max+delta},extent,0)}function pageDataZoomWindow(window,extent,towardValue){if(!Number.isFinite(towardValue))return window;if(towardValue<window.min)return stepDataZoomWindow(window,extent,-1);if(towardValue>window.max)return stepDataZoomWindow(window,extent,1);return window}function keyboardDataZoomAction(event){if(event.ctrlKey||event.metaKey||event.altKey)return null;switch(event.key){case"ArrowRight":case"ArrowUp":return{kind:"pan",direction:1};case"ArrowLeft":case"ArrowDown":return{kind:"pan",direction:-1};case"PageUp":return{kind:"page",direction:1};case"PageDown":return{kind:"page",direction:-1};case"Home":return{kind:"home"};case"End":return{kind:"end"};case"+":case"=":return{kind:"zoom",direction:"in"};case"-":return{kind:"zoom",direction:"out"};case"Escape":case"0":return{kind:"reset"};default:return null}}function applyDataZoomKeyAction(action,window,extent,stepFraction,minSpan=0){const fraction=Number.isFinite(stepFraction)&&stepFraction>0?stepFraction:.1;const span=window.max-window.min;switch(action.kind){case"pan":return stepDataZoomWindow(window,extent,action.direction*fraction);case"page":return stepDataZoomWindow(window,extent,action.direction);case"zoom":return zoomWindow.zoomWindowBy(window,extent,action.direction==="in"?zoomWindow.ZOOM_KEYBOARD_IN_FACTOR:zoomWindow.ZOOM_KEYBOARD_OUT_FACTOR,.5,minSpan);case"home":return zoomWindow.clampZoomWindow({min:extent.min,max:extent.min+span},extent,0);case"end":return zoomWindow.clampZoomWindow({min:extent.max-span,max:extent.max},extent,0);case"reset":return null;default:return window}}function formatDataZoomValue(value,format){if(format){try{return String(format(value))}catch{}}if(!Number.isFinite(value))return"";const rounded=Math.round(value*100)/100;return String(rounded)}exports.DATA_ZOOM_TRACK_PAD=DATA_ZOOM_TRACK_PAD;exports.applyDataZoomKeyAction=applyDataZoomKeyAction;exports.dataZoomSpanForPixels=dataZoomSpanForPixels;exports.dataZoomTrackFor=dataZoomTrackFor;exports.dataZoomTrackPixel=dataZoomTrackPixel;exports.dataZoomTrackValue=dataZoomTrackValue;exports.dataZoomWindowPixels=dataZoomWindowPixels;exports.dataZoomWindowsEqual=dataZoomWindowsEqual;exports.dragDataZoomWindow=dragDataZoomWindow;exports.formatDataZoomValue=formatDataZoomValue;exports.isFullDataZoomWindow=isFullDataZoomWindow;exports.keyboardDataZoomAction=keyboardDataZoomAction;exports.normalizeDataZoomExtent=normalizeDataZoomExtent;exports.pageDataZoomWindow=pageDataZoomWindow;exports.resolveDataZoomWindow=resolveDataZoomWindow;

package/dist/cjs/data-zoom-target-BO1_-I0t.js

@@ -0,0 +1 @@
+"use strict";function resolveDataZoomTarget(target,forId,root,fallbackRoot){if(target)return target;if(!forId)return null;const inRoot=typeof root?.getElementById==="function"?root.getElementById(forId):null;const found=inRoot??(typeof fallbackRoot?.getElementById==="function"?fallbackRoot.getElementById(forId):null);return found??null}async function whenTargetDefined(target){if(target.getZoomExtent)return;if(typeof customElements!=="undefined"&&target.localName.includes("-"))await customElements.whenDefined(target.localName)}exports.resolveDataZoomTarget=resolveDataZoomTarget;exports.whenTargetDefined=whenTargetDefined;

package/dist/cjs/device-pixel-box-COQLb1eD.js

@@ -0,0 +1 @@
+"use strict";function devicePixelBoxOf(entries,target){const entry=entries.find(e=>e.target===target)??entries[0];const box=entry?.devicePixelContentBoxSize?.[0];if(!box)return void 0;const width=Math.round(box.inlineSize);const height=Math.round(box.blockSize);if(!Number.isFinite(width)||!Number.isFinite(height)||width<=0||height<=0)return void 0;return{width,height}}function sameDevicePixelBox(a,b){if(a===b)return true;if(!a||!b)return false;return a.width===b.width&&a.height===b.height}exports.devicePixelBoxOf=devicePixelBoxOf;exports.sameDevicePixelBox=sameDevicePixelBox;

package/dist/cjs/drawing-export-CdJsjlzv.js

@@ -0,0 +1 @@
+"use strict";const CHROME_SELECTOR='[data-selection-id], [data-handle-id], [class*="__drawing-marquee"], [class*="__drawing--preview"]';function snapshotDrawingLayer(svg,options={}){if(typeof document==="undefined"||!svg)return null;const clone=svg.cloneNode(true);for(const chrome of Array.from(clone.querySelectorAll(CHROME_SELECTOR)))chrome.remove();const count=clone.querySelectorAll("[data-drawing-id]").length;if(count===0)return null;clone.removeAttribute("style");clone.removeAttribute("aria-hidden");const width=Number(svg.getAttribute("width"))||svg.clientWidth||0;const height=Number(svg.getAttribute("height"))||svg.clientHeight||0;const left=Number.parseFloat(svg.style.left);const top=Number.parseFloat(svg.style.top);return{markup:new XMLSerializer().serializeToString(clone),x:options.plotX??(Number.isFinite(left)?left:0),y:options.plotY??(Number.isFinite(top)?top:0),width,height,count}}function drawingsFileBaseName(base){const trimmed=(base||"").trim();return`${trimmed||"chart"}-drawings`}exports.drawingsFileBaseName=drawingsFileBaseName;exports.snapshotDrawingLayer=snapshotDrawingLayer;

package/dist/cjs/engine-swap-license-BYrMn26A.js

@@ -0,0 +1 @@
+"use strict";var chartLicenseBridge=require("./chart-license-bridge-DAODso1A.js");var pointContextMenu=require("./point-context-menu-CWB4nv9m.js");const ENGINE_LICENSE_FEATURE=chartLicenseBridge.CHART_FEATURE.webgpu;const STREAMING_LICENSE_FEATURE=chartLicenseBridge.CHART_FEATURE.streaming;function isEngineSwapFeature(feature){return feature===ENGINE_LICENSE_FEATURE||feature===STREAMING_LICENSE_FEATURE}const DEFAULT_BRIDGE={entitlementFor:chartLicenseBridge.entitlementFor,ensureEntitlement:chartLicenseBridge.ensureEntitlement,subscribe:chartLicenseBridge.subscribe,refuseChartFeature:chartLicenseBridge.refuseChartFeature,reflectLicenseState:chartLicenseBridge.reflectLicenseState,setLicenseFrozen:chartLicenseBridge.setLicenseFrozen};const STREAM_HANDLE_WRITE="getStreamSource";function reportError(error){const report=globalThis.reportError;if(typeof report==="function")report(error);else if(typeof console!=="undefined")console.error(error)}function finiteNumber(value){return typeof value==="number"&&Number.isFinite(value)}function positiveNumber(value){return finiteNumber(value)&&value>0}function requestedStreamingInputs(inputs,options={}){const asked=[];const source=inputs.streamSource!==void 0&&inputs.streamSource!==null;const max=options.capacity==="finite"?finiteNumber(inputs.streamMax):positiveNumber(inputs.streamMax)&&Math.floor(inputs.streamMax)>0;if(source)asked.push("stream-source");if(max)asked.push("stream-max");if(source||max||options.streamImplied===true){if(positiveNumber(inputs.streamWindow))asked.push("stream-window");if(positiveNumber(inputs.streamWindowMs))asked.push("stream-window-ms")}if(typeof inputs.frameBudget==="number"&&!Number.isNaN(inputs.frameBudget))asked.push("frame-budget");return asked}function engineLicenseVerdict(state){const resolution=pointContextMenu.resolveChartEngine({requested:"pro",engineClass:"engine-swap",entitlement:state,gpuAvailable:true,moduleAvailable:true,hasStandardRenderer:true});if(resolution.effective==="pro")return Object.freeze({state});const code=pointContextMenu.isChartLicenseEngineCode(resolution.code)?resolution.code:"license-required";return Object.freeze({state,code,reason:resolution.reason??void 0})}function engineSwapOutcome(input){const{requested}=pointContextMenu.normalizeChartEngineRequest(input.requested);if(input.tier==="pro")return{code:"ok",reason:input.degradedReason??null};if(input.license?.code)return{code:input.license.code,reason:input.license.reason??null};if(requested==="standard")return{code:"ok",reason:null};if(input.featureFallbackReason)return{code:requested==="auto"?"auto-standard":"no-pro-renderer",reason:input.featureFallbackReason};if(input.fallbackReason){if(input.renderer&&input.renderer.reason===input.fallbackReason)return{code:input.renderer.code,reason:input.fallbackReason};return{code:"gpu-unavailable",reason:input.fallbackReason}}return{code:"auto-standard",reason:null}}function engineSwapStatus(requested,effective,outcome,licenseState){return Object.freeze({requested:pointContextMenu.normalizeChartEngineRequest(requested).requested,effective,reason:outcome.reason,code:outcome.code,entitlement:licenseState?Object.freeze({feature:ENGINE_LICENSE_FEATURE,state:licenseState}):null})}function rendererCodeOf(moduleInBuild){return moduleInBuild?"gpu-unavailable":"renderer-not-in-build"}function engineFailureOutcome(reason){return{code:reason===pointContextMenu.GPU_PRO_NOT_IN_BUILD_REASON?"renderer-not-in-build":"gpu-unavailable",reason}}class EngineSwapLicense{unsubscribe;connected=false;refused=new Set;frozen=new Set;seen=new Map;undelivered=[];deliveryScheduled=false;settleWaiters=new Set;parked;queue=null;waiting=0;host;onChange;bridge;hostless=Object.freeze({});constructor(host,onChange,bridge=DEFAULT_BRIDGE){this.host=host;this.onChange=onChange;this.bridge=bridge}connect(){if(this.unsubscribe)return;this.connected=true;this.unsubscribe=this.bridge.subscribe(this.element(),change=>{if(!isEngineSwapFeature(change.feature))return;if(change.feature===STREAMING_LICENSE_FEATURE)return;this.observe(change.feature,change.state);this.deliver()});for(const feature of[...this.seen.keys()])this.state(feature);this.wakeSettleWaiters()}disconnect(){this.connected=false;this.unsubscribe?.();this.unsubscribe=void 0;for(const change of[...this.undelivered].reverse())this.seen.set(change.feature,change.previousState);this.undelivered=[]}state(feature){if(feature===STREAMING_LICENSE_FEATURE){this.bridge.reflectLicenseState(this.host(),feature,"module-missing");return"unsupported-environment"}const{state}=this.bridge.entitlementFor(this.element(),feature);this.observe(feature,state);if(this.undelivered.length>0)this.scheduleDelivery();return state}element(){return this.host()??this.hostless}observe(feature,state){const previousState=this.seen.get(feature);if(previousState===state)return;if(previousState!==void 0&&!this.connected)return;this.seen.set(feature,state);this.reflect(feature,state);this.wakeSettleWaiters();if(previousState===void 0)return;for(const key of[...this.refused])if(key.startsWith(`${feature}|`))this.refused.delete(key);this.undelivered.push(Object.freeze({feature,state,previousState}))}scheduleDelivery(){if(this.deliveryScheduled)return;this.deliveryScheduled=true;queueMicrotask(()=>{this.deliveryScheduled=false;this.deliver()})}deliver(){while(this.connected&&this.undelivered.length>0){const change=this.undelivered.shift();try{this.onChange(change)}catch(error){reportError(error)}}}reflect(feature,state){const el=this.host();if(!el)return;let shownFeature=feature;let shownState=state;if(state==="valid"){for(const[other,otherState]of this.seen){if(otherState!=="valid"){shownFeature=other;shownState=otherState;break}}}try{this.bridge.reflectLicenseState(el,shownFeature,shownState)}catch{}}refuse(feature,state,input){if(state==="valid"||state==="pending")return;const el=this.host();if(!el)return;const key=`${feature}|${state}|${input}`;if(this.refused.has(key))return;this.refused.add(key);queueMicrotask(()=>{try{this.bridge.refuseChartFeature(el,{feature,state},{method:input,...feature===STREAMING_LICENSE_FEATURE?{code:"module-missing"}:{}})}catch{}})}isFrozen(feature){return this.frozen.has(feature)}setFrozen(feature,frozen){const had=this.frozen.size>0;if(frozen)this.frozen.add(feature);else this.frozen.delete(feature);const has=this.frozen.size>0;if(had!==has)this.bridge.setLicenseFrozen(this.host(),has)}parkStream(source,shown){if(this.parked?.source===source)return;this.releaseParked();const parked={source,shown:[...shown],refusedWrite:false,stop:()=>void 0};this.parked=parked;try{parked.stop=source.subscribe(()=>this.parkedWrite(parked))}catch{}}parkedWrite(parked){if(this.parked!==parked)return;const state=this.state(STREAMING_LICENSE_FEATURE);if(state==="valid"||state==="pending")return;parked.refusedWrite=true;this.refuse(STREAMING_LICENSE_FEATURE,state,STREAM_HANDLE_WRITE)}resumeStream(source,shown){const parked=this.parked;if(!parked||parked.source!==source)return true;this.releaseParked();return!parked.refusedWrite&&parked.shown.length===shown.length&&parked.shown.every((item,i)=>item===shown[i])}releaseParked(){const parked=this.parked;this.parked=void 0;try{parked?.stop()}catch{}}run(feature,asks,body){if(this.waiting===0&&(!asks||this.state(feature)!=="pending")){this.deliver();return Promise.resolve(body())}this.waiting+=1;const previous=this.queue??Promise.resolve();const next=previous.then(async()=>{while(this.state(feature)==="pending")await this.settled(feature);this.deliver();return await body()});const done=next.then(()=>void 0,()=>void 0).then(()=>{this.waiting-=1;if(this.queue===done)this.queue=null});this.queue=done;return next}async settled(feature){const answer=await this.bridge.ensureEntitlement(this.element(),feature);if(answer.state!=="pending"||this.state(feature)!=="pending")return;await new Promise(resolve=>this.settleWaiters.add(resolve))}wakeSettleWaiters(){if(this.settleWaiters.size===0)return;const waiters=[...this.settleWaiters];this.settleWaiters.clear();for(const wake of waiters)wake()}}exports.ENGINE_LICENSE_FEATURE=ENGINE_LICENSE_FEATURE;exports.EngineSwapLicense=EngineSwapLicense;exports.STREAMING_LICENSE_FEATURE=STREAMING_LICENSE_FEATURE;exports.engineFailureOutcome=engineFailureOutcome;exports.engineLicenseVerdict=engineLicenseVerdict;exports.engineSwapOutcome=engineSwapOutcome;exports.engineSwapStatus=engineSwapStatus;exports.rendererCodeOf=rendererCodeOf;exports.requestedStreamingInputs=requestedStreamingInputs;

package/dist/cjs/errors-DNua3ZWy.js

@@ -0,0 +1 @@
+"use strict";const WARNINGS_SYMBOL_KEY="syidax.license.warnings/v1";const LICENSE_PRODUCTS=["core","chart","grid"];const FEATURE_ID_PATTERN=/^(core|chart|grid)\.[a-z0-9]+(?:-[a-z0-9]+)*(?:\.[a-z0-9]+(?:-[a-z0-9]+)*)*$/;const LICENSE_ERROR_NAME="SyidaxLicenseError";const LICENSE_STATE_CHANGED_EVENT="licenseStateChanged";const LICENSE_FEATURE_REFUSED_EVENT="licenseFeatureRefused";const LICENSE_ATTR=Object.freeze({state:"data-license-state",feature:"data-license-feature",frozen:"data-license-frozen",refused:"data-license-refused"});const LICENSE_WARNING_PREFIX="[Syidax] ";const MAX_LICENSE_WARNING_KEYS=256;const DIAGNOSTIC_CODES={"license-required":true,"license-pending":true,"module-missing":true,"load-failed":true,"engine-unsupported":true,disposed:true,stale:true};const ENTITLEMENT_STATES={none:true,pending:true,valid:true,insufficient:true,"not-yet-valid":true,expired:true,invalid:true,revoked:true,"unsupported-environment":true};const ENTITLEMENT_CODES={"no-certificate":true,"verification-pending":true,granted:true,"product-not-granted":true,"feature-not-granted":true,"grant-not-started":true,"grant-expired":true,"certificate-revoked":true,malformed:true,"too-large":true,"unsupported-alg":true,"unknown-kid":true,"bad-signature":true,"wrong-issuer":true,"wrong-audience":true,"wrong-environment":true,"wrong-organization":true,"schema-mismatch":true,"invalid-field":true,"stale-revision":true,revoked:true,"revocation-invalid":true,"cross-origin-url":true,"fetch-failed":true,"context-required":true,"unsupported-environment":true,superseded:true};const LICENSE_ID_TEXT=/(?:org|lf|cert)_[A-Za-z0-9_-]*/gi;const REDACTED="[redacted]";const MAX_NAME_LENGTH=128;const MAX_REASON_LENGTH=500;const MAX_MESSAGE_LENGTH=1e3;const MAX_WARNING_KEY_LENGTH=512;function has(table,value){return typeof value==="string"&&Object.prototype.hasOwnProperty.call(table,value)}function clean(text,maxLength){const redacted=text.replace(LICENSE_ID_TEXT,REDACTED);return redacted.length>maxLength?`${redacted.slice(0,maxLength-1)}…`:redacted}function textOf(value){if(typeof value==="string")return value;try{if(typeof value==="object"&&value!==null&&typeof value.message==="string"){return value.message}return String(value)}catch{return"unknown reason"}}function shown(value){return clean(typeof value==="string"?value:typeof value,64)}function optionalName(value,label){if(value===void 0)return void 0;if(typeof value!=="string"||value.length===0)throw new TypeError(`License diagnostic ${label} must be a non-empty string.`);return clean(value,MAX_NAME_LENGTH)}function subject(input,what){if(typeof input!=="object"||input===null)throw new TypeError(`${what} needs an object.`);const{product,feature,state,tag,method}=input;if(typeof product!=="string"||!LICENSE_PRODUCTS.includes(product)){throw new TypeError(`${what}: unknown product "${shown(product)}".`)}if(typeof feature!=="string"||!FEATURE_ID_PATTERN.test(feature)||!feature.startsWith(`${product}.`)){throw new TypeError(`${what}: feature must be a ${product} feature ID such as "${product}.<feature>".`)}if(!has(ENTITLEMENT_STATES,state))throw new TypeError(`${what}: unknown license state "${shown(state)}".`);const result={product,feature,state};const cleanTag=optionalName(tag,"tag");const cleanMethod=optionalName(method,"method");if(cleanTag!==void 0)result.tag=cleanTag;if(cleanMethod!==void 0)result.method=cleanMethod;return result}function defaultMessage(code,fields,reason){const where=fields.tag!==void 0?`<${fields.tag}>${fields.method!==void 0?`.${fields.method}()`:""}: `:fields.method!==void 0?`${fields.method}(): `:"";const feature=`"${fields.feature}"`;switch(code){case"license-required":return`${where}${feature} needs a valid ${fields.product} Pro license (license state: ${fields.state}).`;case"license-pending":return`${where}${feature} is waiting for the ${fields.product} license verification to finish.`;case"module-missing":return`${where}${feature} is licensed, but its module is not installed or not selected.`;case"load-failed":return`${where}${feature} could not load its module${reason!==void 0?` (${reason})`:""}.`;case"engine-unsupported":return`${where}${feature} is licensed, but this environment lacks the engine it needs.`;case"disposed":return`${where}${feature} was refused because the element was disposed.`;case"stale":return`${where}${feature} was abandoned because the ${fields.product} license changed while it was running.`}}class SyidaxLicenseError extends Error{constructor(init){const fields=subject(init,"createLicenseError");const code=init.code;if(!has(DIAGNOSTIC_CODES,code))throw new TypeError(`createLicenseError: unknown code "${shown(code)}".`);const reason=init.reason===void 0?void 0:clean(textOf(init.reason),MAX_REASON_LENGTH);if(init.message!==void 0&&typeof init.message!=="string")throw new TypeError("createLicenseError: message must be a string.");const message=init.message!==void 0?clean(init.message,MAX_MESSAGE_LENGTH):defaultMessage(code,fields,reason);super(message);const target=this;target.code=code;target.product=fields.product;target.feature=fields.feature;target.state=fields.state;if(fields.tag!==void 0)target.tag=fields.tag;if(fields.method!==void 0)target.method=fields.method;if(reason!==void 0)target.reason=reason}}Object.defineProperty(SyidaxLicenseError.prototype,"name",{value:LICENSE_ERROR_NAME,writable:true,configurable:true,enumerable:false});function createLicenseError(init){return new SyidaxLicenseError(init)}function isLicenseError(value){try{if(typeof value!=="object"&&typeof value!=="function"||value===null)return false;const candidate=value;return candidate.name===LICENSE_ERROR_NAME&&has(DIAGNOSTIC_CODES,candidate.code)}catch{return false}}function eventDetail(detail){const fields=subject(detail,"dispatchLicenseEvent");const{code,previousState}=detail;if(!has(DIAGNOSTIC_CODES,code)&&!has(ENTITLEMENT_CODES,code))throw new TypeError(`dispatchLicenseEvent: unknown code "${shown(code)}".`);const result={product:fields.product,feature:fields.feature,state:fields.state,code};if(fields.tag!==void 0)result.tag=fields.tag;if(fields.method!==void 0)result.method=fields.method;if(previousState!==void 0){if(!has(ENTITLEMENT_STATES,previousState))throw new TypeError(`dispatchLicenseEvent: unknown previous state "${shown(previousState)}".`);result.previousState=previousState}return Object.freeze(result)}function dispatchLicenseEvent(target,type,detail){if(type!==LICENSE_STATE_CHANGED_EVENT&&type!==LICENSE_FEATURE_REFUSED_EVENT){throw new TypeError(`dispatchLicenseEvent: unknown event type "${shown(type)}".`)}const cleanDetail=eventDetail(detail);const EventType=globalThis.CustomEvent;if(typeof EventType!=="function"||target===null||target===void 0||typeof target.dispatchEvent!=="function"){return false}return target.dispatchEvent(new EventType(type,{detail:cleanDetail,bubbles:true,composed:true}))}let privateWarnings;function isWarningRegistry(value){if(typeof value!=="object"||value===null)return false;const candidate=value;return candidate.version===1&&candidate.keys instanceof Set&&typeof candidate.suppressed==="boolean"}function warningRegistry(){try{const key=Symbol.for(WARNINGS_SYMBOL_KEY);const existing=globalThis[key];if(existing===void 0){const registry={version:1,keys:new Set,suppressed:false};Object.defineProperty(globalThis,key,{value:registry,configurable:false,enumerable:false,writable:false});return registry}if(isWarningRegistry(existing))return existing}catch{}privateWarnings??={version:1,keys:new Set,suppressed:false};return privateWarnings}function emitWarning(text){const sink=typeof console==="undefined"?void 0:console;if(!sink||typeof sink.warn!=="function")return false;sink.warn(`${LICENSE_WARNING_PREFIX}${text}`);return true}function warnLicenseOnce(key,message){try{const id=String(key).slice(0,MAX_WARNING_KEY_LENGTH);const registry=warningRegistry();if(registry.keys.has(id))return false;if(registry.keys.size>=MAX_LICENSE_WARNING_KEYS){if(registry.suppressed)return false;registry.suppressed=true;emitWarning(`Further license warnings are suppressed on this page (${MAX_LICENSE_WARNING_KEYS} distinct warnings shown).`);return false}registry.keys.add(id);const text=clean(textOf(message),MAX_MESSAGE_LENGTH);return emitWarning(text.startsWith(LICENSE_WARNING_PREFIX)?text.slice(LICENSE_WARNING_PREFIX.length):text)}catch{return false}}exports.FEATURE_ID_PATTERN=FEATURE_ID_PATTERN;exports.LICENSE_ATTR=LICENSE_ATTR;exports.LICENSE_FEATURE_REFUSED_EVENT=LICENSE_FEATURE_REFUSED_EVENT;exports.LICENSE_PRODUCTS=LICENSE_PRODUCTS;exports.LICENSE_STATE_CHANGED_EVENT=LICENSE_STATE_CHANGED_EVENT;exports.SyidaxLicenseError=SyidaxLicenseError;exports.createLicenseError=createLicenseError;exports.dispatchLicenseEvent=dispatchLicenseEvent;exports.isLicenseError=isLicenseError;exports.warnLicenseOnce=warnLicenseOnce;