@agoric/zoe 0.28.0-u23.0 → 0.28.0-u23.1

package/bundles/esbuild-bundle-20251114T162438.596Z.js

@@ -1 +0,0 @@
-var globalAssert=globalThis.assert;if(globalAssert===void 0){throw Error(`Cannot initialize @endo/errors, missing globalThis.assert, import 'ses' before '@endo/errors'`)}var missing=["typeof","error","fail","equal","string","note","details","Fail","quote","makeAssert"].filter(name=>globalAssert[name]===void 0);if(missing.length>0){throw Error(`Cannot initialize @endo/errors, missing globalThis.assert methods ${missing.join(", ")}`)}var{bare,details:redacted,error:makeError,Fail:throwRedacted,makeAssert:_omittedMakeAssert,note,quote,...assertions}=globalAssert;var assert2=(value,optDetails,errContructor,options)=>globalAssert(value,optDetails,errContructor,options);Object.assign(assert2,assertions);var bareOrQuote=bare||quote;var localThis=globalThis;var{Object:Object2,Reflect:Reflect2,Array:Array2,String:String2,JSON:JSON2,Error:Error2}=localThis;var{freeze}=Object2;var{apply}=Reflect2;var uncurryThis=fn=>(receiver,...args)=>apply(fn,receiver,args);var arrayPush=uncurryThis(Array2.prototype.push);var arrayIncludes=uncurryThis(Array2.prototype.includes);var stringSplit=uncurryThis(String2.prototype.split);var q=JSON2.stringify;var Fail=(literals,...args)=>{let msg=literals[0];for(let i=0;i<args.length;i+=1){msg=`${msg}${args[i]}${literals[i+1]}`}throw Error2(msg)};var makeEnvironmentCaptor=(aGlobal,dropNames=false)=>{const capturedEnvironmentOptionNames=[];const getEnvironmentOption2=(optionName,defaultSetting,optOtherValues=void 0)=>{typeof optionName==="string"||Fail`Environment option name ${q(optionName)} must be a string.`;typeof defaultSetting==="string"||Fail`Environment option default setting ${q(defaultSetting)} must be a string.`;let setting=defaultSetting;const globalProcess=aGlobal.process||void 0;const globalEnv=typeof globalProcess==="object"&&globalProcess.env||void 0;if(typeof globalEnv==="object"){if(optionName in globalEnv){if(!dropNames){arrayPush(capturedEnvironmentOptionNames,optionName)}const optionValue=globalEnv[optionName];typeof optionValue==="string"||Fail`Environment option named ${q(optionName)}, if present, must have a corresponding string value, got ${q(optionValue)}`;setting=optionValue}}optOtherValues===void 0||setting===defaultSetting||arrayIncludes(optOtherValues,setting)||Fail`Unrecognized ${q(optionName)} value ${q(setting)}. Expected one of ${q([defaultSetting,...optOtherValues])}`;return setting};freeze(getEnvironmentOption2);const getEnvironmentOptionsList2=optionName=>{const option=getEnvironmentOption2(optionName,"");return freeze(option===""?[]:stringSplit(option,","))};freeze(getEnvironmentOptionsList2);const environmentOptionsListHas2=(optionName,element)=>arrayIncludes(getEnvironmentOptionsList2(optionName),element);const getCapturedEnvironmentOptionNames=()=>{return freeze([...capturedEnvironmentOptionNames])};freeze(getCapturedEnvironmentOptionNames);return freeze({getEnvironmentOption:getEnvironmentOption2,getEnvironmentOptionsList:getEnvironmentOptionsList2,environmentOptionsListHas:environmentOptionsListHas2,getCapturedEnvironmentOptionNames})};freeze(makeEnvironmentCaptor);var{getEnvironmentOption,getEnvironmentOptionsList,environmentOptionsListHas}=makeEnvironmentCaptor(localThis,true);var{quote:q2,Fail:Fail2}=assert;var{hasOwn,freeze:freeze2,entries}=Object;var isJSONRecord=val=>typeof val==="object"&&val!==null&&!Array.isArray(val);var simplifyTag=tag=>{for(const prefix of["Alleged: ","DebugName: "]){if(tag.startsWith(prefix)){return tag.slice(prefix.length)}}return tag};var makeMessageBreakpointTester=optionName=>{let breakpoints=JSON.parse(getEnvironmentOption(optionName,"null"));if(breakpoints===null){return void 0}let breakpointsTable;const getBreakpoints=()=>breakpoints;freeze2(getBreakpoints);const setBreakpoints=(newBreakpoints=breakpoints)=>{isJSONRecord(newBreakpoints)||Fail2`Expected ${q2(optionName)} option to be a JSON breakpoints record`;const newBreakpointsTable={__proto__:null};for(const[tag,methodBPs]of entries(newBreakpoints)){tag===simplifyTag(tag)||Fail2`Just use simple tag ${q2(simplifyTag(tag))} rather than ${q2(tag)}`;isJSONRecord(methodBPs)||Fail2`Expected ${q2(optionName)} option's ${q2(tag)} to be a JSON methods breakpoints record`;for(const[methodName,count]of entries(methodBPs)){count==="*"||typeof count==="number"&&Number.isSafeInteger(count)&&count>=0||Fail2`Expected ${q2(optionName)} option's ${q2(tag)}.${q2(methodName)} to be "*" or a non-negative integer`;const classBPs=hasOwn(newBreakpointsTable,methodName)?newBreakpointsTable[methodName]:newBreakpointsTable[methodName]={__proto__:null};classBPs[tag]=count}}breakpoints=newBreakpoints;breakpointsTable=newBreakpointsTable};freeze2(setBreakpoints);const shouldBreakpoint=(recipient,methodName)=>{if(methodName===void 0||methodName===null){return false}const classBPs=breakpointsTable[methodName]||breakpointsTable["*"];if(classBPs===void 0){return false}let tag=simplifyTag(recipient[Symbol.toStringTag]);let count=classBPs[tag];if(count===void 0){tag="*";count=classBPs[tag];if(count===void 0){return false}}if(count==="*"){return true}if(count===0){return true}assert(typeof count==="number"&&count>=1);classBPs[tag]=count-1;return false};freeze2(shouldBreakpoint);const breakpointTester=freeze2({getBreakpoints,setBreakpoints,shouldBreakpoint});breakpointTester.setBreakpoints();return breakpointTester};freeze2(makeMessageBreakpointTester);var{details:X,quote:q3,Fail:Fail3}=assert;var{getOwnPropertyDescriptors,getPrototypeOf,freeze:freeze3}=Object;var{apply:apply2,ownKeys}=Reflect;var onDelivery=makeMessageBreakpointTester("ENDO_DELIVERY_BREAKPOINTS");var isPrimitive=val=>!val||typeof val!=="object"&&typeof val!=="function";var compareStringified=(a,b)=>{if(typeof a===typeof b){const left=String(a);const right=String(b);return left<right?-1:left>right?1:0}if(typeof a==="symbol"){assert(typeof b==="string");return-1}assert(typeof a==="string");assert(typeof b==="symbol");return 1};var getMethodNames=val=>{let layer=val;const names=new Set;while(layer!==null&&layer!==Object.prototype){const descs=getOwnPropertyDescriptors(layer);for(const name of ownKeys(descs)){if(typeof val[name]==="function"){names.add(name)}}if(isPrimitive(val)){break}layer=getPrototypeOf(layer)}return harden([...names].sort(compareStringified))};freeze3(getMethodNames);var{isArray}=Array;var{prototype:functionPrototype}=Function;var{getOwnPropertyDescriptor,getPrototypeOf:getPrototypeOf2,hasOwn:hasOwn2,isFrozen,prototype:objectPrototype}=Object;var{apply:apply3}=Reflect;var{toStringTag:toStringTagSymbol}=Symbol;var typedArrayPrototype=getPrototypeOf2(Uint8Array.prototype);var typedArrayToStringTagDesc=getOwnPropertyDescriptor(typedArrayPrototype,toStringTagSymbol);assert(typedArrayToStringTagDesc);var getTypedArrayToStringTag=typedArrayToStringTagDesc.get;assert(typeof getTypedArrayToStringTag==="function");var isPrimitive2=val=>!val||typeof val!=="object"&&typeof val!=="function";harden(isPrimitive2);var isObject=val=>!!val&&(typeof val==="object"||typeof val==="function");harden(isObject);var isTypedArray=object=>{const tag=apply3(getTypedArrayToStringTag,object,[]);return tag!==void 0};harden(isTypedArray);var PASS_STYLE=Symbol.for("passStyle");var assertChecker=(cond,details)=>{assert(cond,details);return true};harden(assertChecker);var CX=check=>{const reject=(T,...subs)=>check(false,redacted(T,...subs));return reject};harden(CX);var getOwnDataDescriptor=(candidate,propName,shouldBeEnumerable,check)=>{const desc=getOwnPropertyDescriptor(candidate,propName);return(desc!==void 0||!!check&&CX(check)`${quote(propName)} property expected: ${candidate}`)&&(hasOwn2(desc,"value")||!!check&&CX(check)`${quote(propName)} must not be an accessor property: ${candidate}`)&&(shouldBeEnumerable?desc.enumerable||!!check&&CX(check)`${quote(propName)} must be an enumerable property: ${candidate}`:!desc.enumerable||!!check&&CX(check)`${quote(propName)} must not be an enumerable property: ${candidate}`)?desc:void 0};harden(getOwnDataDescriptor);var getTag=tagRecord=>tagRecord[Symbol.toStringTag];harden(getTag);var checkPassStyle=(obj,passStyle,expectedPassStyle,check)=>{return passStyle===expectedPassStyle||!!check&&CX(check)`Expected ${quote(expectedPassStyle)}, not ${quote(passStyle)}: ${obj}`};harden(checkPassStyle);var makeCheckTagRecord=checkProto=>{const checkTagRecord2=(tagRecord,expectedPassStyle,check)=>{return(!isPrimitive2(tagRecord)||!!check&&CX(check)`A non-object cannot be a tagRecord: ${tagRecord}`)&&(isFrozen(tagRecord)||!!check&&CX(check)`A tagRecord must be frozen: ${tagRecord}`)&&(!isArray(tagRecord)||!!check&&CX(check)`An array cannot be a tagRecord: ${tagRecord}`)&&checkPassStyle(tagRecord,getOwnDataDescriptor(tagRecord,PASS_STYLE,false,check).value,expectedPassStyle,check)&&(typeof getOwnDataDescriptor(tagRecord,Symbol.toStringTag,false,check).value==="string"||!!check&&CX(check)`A [Symbol.toStringTag]-named property must be a string: ${tagRecord}`)&&checkProto(tagRecord,getPrototypeOf2(tagRecord),check)};return harden(checkTagRecord2)};var checkTagRecord=makeCheckTagRecord((val,proto,check)=>proto===objectPrototype||!!check&&check(false,redacted`A tagRecord must inherit from Object.prototype: ${val}`));harden(checkTagRecord);var checkFunctionTagRecord=makeCheckTagRecord((val,proto,check)=>proto===functionPrototype||proto!==null&&getPrototypeOf2(proto)===functionPrototype||!!check&&check(false,redacted`For functions, a tagRecord must inherit from Function.prototype: ${val}`));harden(checkFunctionTagRecord);var canBeMethod=func=>typeof func==="function"&&!(PASS_STYLE in func);harden(canBeMethod);var canBeMethodName=key=>typeof key==="string"||typeof key==="symbol"||typeof key==="number";harden(canBeMethodName);var getRemotableMethodNames=behaviorMethods=>getMethodNames(behaviorMethods);harden(getRemotableMethodNames);var{ownKeys:ownKeys2}=Reflect;var{isArray:isArray2}=Array;var{getPrototypeOf:getPrototypeOf3,isFrozen:isFrozen2,prototype:objectPrototype2,getOwnPropertyDescriptors:getOwnPropertyDescriptors2,hasOwn:hasOwn3}=Object;var checkIface=(iface,check)=>{return(typeof iface==="string"||!!check&&CX(check)`For now, interface ${iface} must be a string; unimplemented`)&&(iface==="Remotable"||iface.startsWith("Alleged: ")||iface.startsWith("DebugName: ")||!!check&&CX(check)`For now, iface ${quote(iface)} must be "Remotable" or begin with "Alleged: " or "DebugName: "; unimplemented`)};var assertIface=iface=>checkIface(iface,assertChecker);harden(assertIface);var checkRemotableProtoOf=(original,check)=>{!isPrimitive2(original)||throwRedacted`Remotables must be objects or functions: ${original}`;const proto=getPrototypeOf3(original);if(proto===objectPrototype2||proto===null||proto===Function.prototype){return!!check&&CX(check)`Remotables must be explicitly declared: ${quote(original)}`}if(typeof original==="object"){const protoProto=getPrototypeOf3(proto);if(protoProto!==objectPrototype2&&protoProto!==null){return checkRemotable(proto,check)}if(!checkTagRecord(proto,"remotable",check)){return false}}else if(typeof original==="function"){if(!checkFunctionTagRecord(proto,"remotable",check)){return false}}const passStyleKey=PASS_STYLE;const tagKey=Symbol.toStringTag;const{[passStyleKey]:_passStyleDesc,[tagKey]:{value:iface},...restDescs}=getOwnPropertyDescriptors2(proto);return(ownKeys2(restDescs).length===0||!!check&&CX(check)`Unexpected properties on Remotable Proto ${ownKeys2(restDescs)}`)&&checkIface(iface,check)};var confirmedRemotables=new WeakSet;var checkRemotable=(val,check)=>{if(confirmedRemotables.has(val)){return true}if(!isFrozen2(val)){return!!check&&CX(check)`cannot serialize non-frozen objects like ${val}`}if(!RemotableHelper.canBeValid(val,check)){return false}const result=checkRemotableProtoOf(val,check);if(result){confirmedRemotables.add(val)}return result};var getInterfaceOf=val=>{if(isPrimitive2(val)||val[PASS_STYLE]!=="remotable"||!checkRemotable(val)){return void 0}return getTag(val)};harden(getInterfaceOf);var RemotableHelper=harden({styleName:"remotable",canBeValid:(candidate,check=void 0)=>{const validType=(!isPrimitive2(candidate)||!!check&&CX(check)`cannot serialize non-objects as Remotable ${candidate}`)&&(!isArray2(candidate)||!!check&&CX(check)`cannot serialize arrays as Remotable ${candidate}`);if(!validType){return false}const descs=getOwnPropertyDescriptors2(candidate);if(typeof candidate==="object"){return ownKeys2(descs).every(key=>{return(hasOwn3(descs[key],"value")||!!check&&CX(check)`cannot serialize Remotables with accessors like ${quote(String(key))} in ${candidate}`)&&(key===Symbol.toStringTag&&checkIface(candidate[key],check)||(canBeMethod(candidate[key])||!!check&&CX(check)`cannot serialize Remotables with non-methods like ${quote(String(key))} in ${candidate}`)&&(key!==PASS_STYLE||!!check&&CX(check)`A pass-by-remote cannot shadow ${quote(PASS_STYLE)}`))})}else if(typeof candidate==="function"){const{name:nameDesc,length:lengthDesc,[Symbol.toStringTag]:toStringTagDesc,...restDescs}=descs;const restKeys=ownKeys2(restDescs);return(nameDesc&&typeof nameDesc.value==="string"||!!check&&CX(check)`Far function name must be a string, in ${candidate}`)&&(lengthDesc&&typeof lengthDesc.value==="number"||!!check&&CX(check)`Far function length must be a number, in ${candidate}`)&&(toStringTagDesc===void 0||(typeof toStringTagDesc.value==="string"||!!check&&CX(check)`Far function @@toStringTag must be a string, in ${candidate}`)&&checkIface(toStringTagDesc.value,check))&&(restKeys.length===0||!!check&&CX(check)`Far functions unexpected properties besides .name and .length ${restKeys}`)}return!!check&&CX(check)`unrecognized typeof ${candidate}`},assertRestValid:candidate=>checkRemotable(candidate,assertChecker),every:(_passable,_fn)=>true});var{prototype:functionPrototype2}=Function;var{getPrototypeOf:getPrototypeOf4,setPrototypeOf,create,isFrozen:isFrozen3,prototype:objectPrototype3}=Object;var makeRemotableProto=(remotable,iface)=>{let oldProto=getPrototypeOf4(remotable);if(typeof remotable==="object"){if(oldProto===null){oldProto=objectPrototype3}oldProto===objectPrototype3||throwRedacted`For now, remotables cannot inherit from anything unusual, in ${remotable}`}else if(typeof remotable==="function"){oldProto!==null||throwRedacted`Original function must not inherit from null: ${remotable}`;oldProto===functionPrototype2||getPrototypeOf4(oldProto)===functionPrototype2||throwRedacted`Far functions must originally inherit from Function.prototype, in ${remotable}`}else{throwRedacted`unrecognized typeof ${remotable}`}return harden(create(oldProto,{[PASS_STYLE]:{value:"remotable"},[Symbol.toStringTag]:{value:iface}}))};var assertCanBeRemotable=candidate=>RemotableHelper.canBeValid(candidate,assertChecker);var Remotable=(iface="Remotable",props=void 0,remotable={})=>{assertIface(iface);assert(iface);props===void 0||throwRedacted`Remotable props not yet implemented ${props}`;assertCanBeRemotable(remotable);!(PASS_STYLE in remotable)||throwRedacted`Remotable ${remotable} is already marked as a ${quote(remotable[PASS_STYLE])}`;harden.isFake||!isFrozen3(remotable)||throwRedacted`Remotable ${remotable} is already frozen`;const remotableProto=makeRemotableProto(remotable,iface);const mutateHardenAndCheck=target=>{setPrototypeOf(target,remotableProto);harden(target);assertCanBeRemotable(target)};mutateHardenAndCheck({});mutateHardenAndCheck(remotable);assert(iface!==void 0);return remotable};harden(Remotable);var GET_METHOD_NAMES="__getMethodNames__";var getMethodNamesMethod=harden({[GET_METHOD_NAMES](){return getMethodNames(this)}})[GET_METHOD_NAMES];var getMethodNamesDescriptor=harden({value:getMethodNamesMethod,enumerable:false,configurable:false,writable:false});var Far=(farName,remotable=void 0)=>{const r=remotable===void 0?{}:remotable;if(typeof r==="object"&&!(GET_METHOD_NAMES in r)){Object.defineProperty(r,GET_METHOD_NAMES,getMethodNamesDescriptor)}return Remotable(`Alleged: ${farName}`,void 0,r)};harden(Far);var ToFarFunction=(farName,func)=>{if(getInterfaceOf(func)!==void 0){return func}return Far(farName,(...args)=>func(...args))};harden(ToFarFunction);var mapIterable=(baseIterable,func)=>Far("mapped iterable",{[Symbol.iterator]:()=>{const baseIterator=baseIterable[Symbol.iterator]();return Far("mapped iterator",{next:()=>{const{value:baseValue,done}=baseIterator.next();const value=done?baseValue:func(baseValue);return harden({value,done})}})}});harden(mapIterable);var filterIterable=(baseIterable,pred)=>Far("filtered iterable",{[Symbol.iterator]:()=>{const baseIterator=baseIterable[Symbol.iterator]();return Far("filtered iterator",{next:()=>{for(;;){const result=baseIterator.next();const{value,done}=result;if(done||pred(value)){return result}}}})}});harden(filterIterable);var{getPrototypeOf:getPrototypeOf5,getOwnPropertyDescriptors:getOwnPropertyDescriptors3,hasOwn:hasOwn4,entries:entries2}=Object;var errorConstructors=new Map([["Error",Error],["EvalError",EvalError],["RangeError",RangeError],["ReferenceError",ReferenceError],["SyntaxError",SyntaxError],["TypeError",TypeError],["URIError",URIError]]);if(typeof AggregateError!=="undefined"){errorConstructors.set("AggregateError",AggregateError)}var getErrorConstructor=name=>errorConstructors.get(name);harden(getErrorConstructor);var checkErrorLike=(candidate,check=void 0)=>{return candidate instanceof Error||!!check&&CX(check)`Error expected: ${candidate}`};harden(checkErrorLike);var isErrorLike=candidate=>checkErrorLike(candidate);harden(isErrorLike);var checkRecursivelyPassableErrorPropertyDesc=(propName,desc,passStyleOfRecur,check=void 0)=>{if(desc.enumerable){return!!check&&CX(check)`Passable Error ${quote(propName)} own property must not be enumerable: ${desc}`}if(!hasOwn4(desc,"value")){return!!check&&CX(check)`Passable Error ${quote(propName)} own property must be a data property: ${desc}`}const{value}=desc;switch(propName){case"message":case"stack":{return typeof value==="string"||!!check&&CX(check)`Passable Error ${quote(propName)} own property must be a string: ${value}`}case"cause":{return checkRecursivelyPassableError(value,passStyleOfRecur,check)}case"errors":{if(!Array.isArray(value)||passStyleOfRecur(value)!=="copyArray"){return!!check&&CX(check)`Passable Error ${quote(propName)} own property must be a copyArray: ${value}`}return value.every(err=>checkRecursivelyPassableError(err,passStyleOfRecur,check))}default:{break}}return!!check&&CX(check)`Passable Error has extra unpassed property ${quote(propName)}`};harden(checkRecursivelyPassableErrorPropertyDesc);var checkRecursivelyPassableError=(candidate,passStyleOfRecur,check=void 0)=>{if(!checkErrorLike(candidate,check)){return false}const proto=getPrototypeOf5(candidate);const{name}=proto;const errConstructor=getErrorConstructor(name);if(errConstructor===void 0||errConstructor.prototype!==proto){return!!check&&CX(check)`Passable Error must inherit from an error class .prototype: ${candidate}`}const descs=getOwnPropertyDescriptors3(candidate);if(!("message"in descs)){return!!check&&CX(check)`Passable Error must have an own "message" string property: ${candidate}`}return entries2(descs).every(([propName,desc])=>checkRecursivelyPassableErrorPropertyDesc(propName,desc,passStyleOfRecur,check))};harden(checkRecursivelyPassableError);var ErrorHelper=harden({styleName:"error",canBeValid:checkErrorLike,assertRestValid:(candidate,passStyleOfRecur)=>checkRecursivelyPassableError(candidate,passStyleOfRecur,assertChecker)});var{ownKeys:ownKeys3}=Reflect;var wellKnownSymbolNames=new Map(ownKeys3(Symbol).filter(name=>typeof name==="string"&&typeof Symbol[name]==="symbol").filter(name=>{!name.startsWith("@@")||throwRedacted`Did not expect Symbol to have a symbol-valued property name starting with "@@" ${quote(name)}`;return true}).map(name=>[Symbol[name],`@@${name}`]));var isPassableSymbol=sym=>typeof sym==="symbol"&&(typeof Symbol.keyFor(sym)==="string"||wellKnownSymbolNames.has(sym));harden(isPassableSymbol);var assertPassableSymbol=sym=>isPassableSymbol(sym)||throwRedacted`Only registered symbols or well-known symbols are passable: ${quote(sym)}`;harden(assertPassableSymbol);var nameForPassableSymbol=sym=>{const name=Symbol.keyFor(sym);if(name===void 0){return wellKnownSymbolNames.get(sym)}if(name.startsWith("@@")){return`@@${name}`}return name};harden(nameForPassableSymbol);var AtAtPrefixPattern=/^@@(.*)$/;harden(AtAtPrefixPattern);var passableSymbolForName=name=>{typeof name==="string"||throwRedacted`${quote(name)} must be a string, not ${quote(typeof name)}`;const match=AtAtPrefixPattern.exec(name);if(match){const suffix=match[1];if(suffix.startsWith("@@")){return Symbol.for(suffix)}else{const sym=Symbol[suffix];if(typeof sym==="symbol"){return sym}throwRedacted`Reserved for well known symbol ${quote(suffix)}: ${quote(name)}`}}return Symbol.for(name)};harden(passableSymbolForName);var hasWellFormedStringMethod=!!String.prototype.isWellFormed;var isWellFormedString=hasWellFormedStringMethod?str=>typeof str==="string"&&str.isWellFormed():str=>{if(typeof str!=="string"){return false}for(const ch of str){const cp=ch.codePointAt(0);if(cp>=55296&&cp<=57343){return false}}return true};harden(isWellFormedString);var assertWellFormedString=str=>{isWellFormedString(str)||throwRedacted`Expected well-formed unicode string: ${str}`};harden(assertWellFormedString);var ONLY_WELL_FORMED_STRINGS_PASSABLE=getEnvironmentOption("ONLY_WELL_FORMED_STRINGS_PASSABLE","disabled",["enabled"])==="enabled";var assertPassableString=str=>{typeof str==="string"||throwRedacted`Expected string ${str}`;!ONLY_WELL_FORMED_STRINGS_PASSABLE||assertWellFormedString(str)};harden(assertPassableString);var makeReleasingExecutorKit=()=>{let internalResolve;let internalReject;const resolve=value=>{if(internalResolve){internalResolve(value);internalResolve=null;internalReject=null}else{assert(internalResolve===null)}};const reject=reason=>{if(internalReject){internalReject(reason);internalResolve=null;internalReject=null}else{assert(internalReject===null)}};const executor=(res,rej)=>{assert(internalResolve===void 0&&internalReject===void 0);internalResolve=res;internalReject=rej};return harden({resolve,reject,executor})};harden(makeReleasingExecutorKit);var isPrimitive3=val=>!val||typeof val!=="object"&&typeof val!=="function";var knownPromises=new WeakMap;var markSettled=record=>{if(!record||record.settled){return new Set}const{deferreds}=record;Object.assign(record,{deferreds:void 0,settled:true});Object.freeze(record);return deferreds};var getMemoRecord=value=>{if(isPrimitive3(value)){return harden({settled:true})}let record=knownPromises.get(value);if(!record){record={deferreds:new Set,settled:false};knownPromises.set(value,record);Promise.resolve(value).then(val=>{for(const{resolve}of markSettled(record)){resolve(val)}},err=>{for(const{reject}of markSettled(record)){reject(err)}})}return record};var{race}={race(values5){let deferred;const cachedValues=[];const C=this;const result=new C((resolve,reject)=>{deferred={resolve,reject};for(const value of values5){cachedValues.push(value);const{settled,deferreds}=getMemoRecord(value);if(settled){C.resolve(value).then(resolve,reject)}else{deferreds.add(deferred)}}});return result.finally(()=>{for(const value of cachedValues){const{deferreds}=getMemoRecord(value);if(deferreds){deferreds.delete(deferred)}}})}};function isPromise(maybePromise){return Promise.resolve(maybePromise)===maybePromise}harden(isPromise);var BestPipelinablePromise=globalThis.HandledPromise||Promise;function makePromiseKit(){const{resolve,reject,executor}=makeReleasingExecutorKit();const promise=new BestPipelinablePromise(executor);return harden({promise,resolve,reject})}harden(makePromiseKit);function racePromises(values5){return harden(race.call(BestPipelinablePromise,values5))}harden(racePromises);var{getPrototypeOf:getPrototypeOf6}=Object;var{ownKeys:ownKeys4}=Reflect;var{isArray:isArray3,prototype:arrayPrototype}=Array;var CopyArrayHelper=harden({styleName:"copyArray",canBeValid:(candidate,check=void 0)=>isArray3(candidate)||!!check&&check(false,redacted`Array expected: ${candidate}`),assertRestValid:(candidate,passStyleOfRecur)=>{getPrototypeOf6(candidate)===arrayPrototype||assert.fail(redacted`Malformed array: ${candidate}`,TypeError);const len=getOwnDataDescriptor(candidate,"length",false,assertChecker).value;for(let i=0;i<len;i+=1){passStyleOfRecur(getOwnDataDescriptor(candidate,i,true,assertChecker).value)}ownKeys4(candidate).length===len+1||assert.fail(redacted`Arrays must not have non-indexes: ${candidate}`,TypeError)}});var{getPrototypeOf:getPrototypeOf7,getOwnPropertyDescriptor:getOwnPropertyDescriptor2}=Object;var{ownKeys:ownKeys5,apply:apply4}=Reflect;var adaptImmutableArrayBuffer=()=>{const anArrayBuffer=new ArrayBuffer(0);if(anArrayBuffer.sliceToImmutable===void 0){return{immutableArrayBufferPrototype:null,immutableGetter:()=>false}}const anImmutableArrayBuffer=anArrayBuffer.sliceToImmutable();const immutableArrayBufferPrototype2=getPrototypeOf7(anImmutableArrayBuffer);const immutableGetter2=getOwnPropertyDescriptor2(immutableArrayBufferPrototype2,"immutable").get;return{immutableArrayBufferPrototype:immutableArrayBufferPrototype2,immutableGetter:immutableGetter2}};var{immutableArrayBufferPrototype,immutableGetter}=adaptImmutableArrayBuffer();var ByteArrayHelper=harden({styleName:"byteArray",canBeValid:(candidate,check=void 0)=>candidate instanceof ArrayBuffer&&candidate.immutable||!!check&&check(false,redacted`Immutable ArrayBuffer expected: ${candidate}`),assertRestValid:(candidate,_passStyleOfRecur)=>{getPrototypeOf7(candidate)===immutableArrayBufferPrototype||assert.fail(redacted`Malformed ByteArray ${candidate}`,TypeError);apply4(immutableGetter,candidate,[])||throwRedacted`Must be an immutable ArrayBuffer: ${candidate}`;ownKeys5(candidate).length===0||assert.fail(redacted`ByteArrays must not have own properties: ${candidate}`,TypeError)}});var{ownKeys:ownKeys6}=Reflect;var{getPrototypeOf:getPrototypeOf8,prototype:objectPrototype4}=Object;var checkObjectPrototype=(candidate,check=void 0)=>{return getPrototypeOf8(candidate)===objectPrototype4||!!check&&CX(check)`Records must inherit from Object.prototype: ${candidate}`};var checkPropertyCanBeValid=(candidate,key,value,check=void 0)=>{return(typeof key==="string"||!!check&&CX(check)`Records can only have string-named properties: ${candidate}`)&&(!canBeMethod(value)||!!check&&CX(check)`Records cannot contain non-far functions because they may be methods of an implicit Remotable: ${candidate}`)};var CopyRecordHelper=harden({styleName:"copyRecord",canBeValid:(candidate,check=void 0)=>{return checkObjectPrototype(candidate,check)&&ownKeys6(candidate).every(key=>checkPropertyCanBeValid(candidate,key,candidate[key],check))},assertRestValid:(candidate,passStyleOfRecur)=>{for(const name of ownKeys6(candidate)){const{value}=getOwnDataDescriptor(candidate,name,true,assertChecker);passStyleOfRecur(value)}}});var{ownKeys:ownKeys7}=Reflect;var{getOwnPropertyDescriptors:getOwnPropertyDescriptors4}=Object;var TaggedHelper=harden({styleName:"tagged",canBeValid:(candidate,check=void 0)=>checkPassStyle(candidate,candidate[PASS_STYLE],"tagged",check),assertRestValid:(candidate,passStyleOfRecur)=>{checkTagRecord(candidate,"tagged",assertChecker);const passStyleKey=PASS_STYLE;const tagKey=Symbol.toStringTag;const{[passStyleKey]:_passStyleDesc,[tagKey]:_labelDesc,payload:_payloadDesc,...restDescs}=getOwnPropertyDescriptors4(candidate);ownKeys7(restDescs).length===0||throwRedacted`Unexpected properties on tagged record ${ownKeys7(restDescs)}`;passStyleOfRecur(getOwnDataDescriptor(candidate,"payload",true,assertChecker).value)}});var{isFrozen:isFrozen4,getPrototypeOf:getPrototypeOf9,getOwnPropertyDescriptor:getOwnPropertyDescriptor3,hasOwn:hasOwn5}=Object;var{ownKeys:ownKeys8}=Reflect;var{toStringTag}=Symbol;var checkPromiseOwnKeys=(pr,check)=>{const keys2=ownKeys8(pr);if(keys2.length===0){return true}const unknownKeys=keys2.filter(key=>typeof key!=="symbol"||!hasOwn5(Promise.prototype,key));if(unknownKeys.length!==0){return CX(check)`${pr} - Must not have any own properties: ${quote(unknownKeys)}`}const checkSafeOwnKey=key=>{if(key===toStringTag){const tagDesc=getOwnPropertyDescriptor3(pr,toStringTag);assert(tagDesc!==void 0);return(hasOwn5(tagDesc,"value")||CX(check)`Own @@toStringTag must be a data property, not an accessor: ${quote(tagDesc)}`)&&(typeof tagDesc.value==="string"||CX(check)`Own @@toStringTag value must be a string: ${quote(tagDesc.value)}`)&&(!tagDesc.enumerable||CX(check)`Own @@toStringTag must not be enumerable: ${quote(tagDesc)}`)}const val=pr[key];if(val===void 0||typeof val==="number"){return true}if(typeof val==="object"&&val!==null&&isFrozen4(val)&&getPrototypeOf9(val)===Object.prototype){const subKeys=ownKeys8(val);if(subKeys.length===0){return true}if(subKeys.length===1&&subKeys[0]==="destroyed"&&val.destroyed===false){return true}}return CX(check)`Unexpected Node async_hooks additions to promise: ${pr}.${quote(String(key))} is ${val}`};return keys2.every(checkSafeOwnKey)};var checkSafePromise=(pr,check)=>{return(isFrozen4(pr)||CX(check)`${pr} - Must be frozen`)&&(isPromise(pr)||CX(check)`${pr} - Must be a promise`)&&(getPrototypeOf9(pr)===Promise.prototype||CX(check)`${pr} - Must inherit from Promise.prototype: ${quote(getPrototypeOf9(pr))}`)&&checkPromiseOwnKeys(pr,check)};harden(checkSafePromise);var isSafePromise=pr=>checkSafePromise(pr,x=>x);harden(isSafePromise);var assertSafePromise=pr=>checkSafePromise(pr,assertChecker);var{ownKeys:ownKeys9}=Reflect;var{isFrozen:isFrozen5,getOwnPropertyDescriptors:getOwnPropertyDescriptors5,values}=Object;var makeHelperTable=passStyleHelpers=>{const HelperTable={__proto__:null,copyArray:void 0,byteArray:void 0,copyRecord:void 0,tagged:void 0,error:void 0,remotable:void 0};for(const helper of passStyleHelpers){const{styleName}=helper;styleName in HelperTable||throwRedacted`Unrecognized helper: ${quote(styleName)}`;HelperTable[styleName]===void 0||throwRedacted`conflicting helpers for ${quote(styleName)}`;HelperTable[styleName]=helper}for(const styleName of ownKeys9(HelperTable)){HelperTable[styleName]!==void 0||throwRedacted`missing helper for ${quote(styleName)}`}return harden(HelperTable)};var assertValid=(helper,candidate,passStyleOfRecur)=>{helper.canBeValid(candidate,assertChecker);helper.assertRestValid(candidate,passStyleOfRecur)};var makePassStyleOf=passStyleHelpers=>{const HelperTable=makeHelperTable(passStyleHelpers);const remotableHelper=HelperTable.remotable;const passStyleMemo=new WeakMap;const passStyleOf2=passable=>{const inProgress=new Set;const passStyleOfRecur=inner=>{const innerIsObject=!isPrimitive2(inner);if(innerIsObject){const innerStyle=passStyleMemo.get(inner);if(innerStyle){return innerStyle}!inProgress.has(inner)||throwRedacted`Pass-by-copy data cannot be cyclic ${inner}`;inProgress.add(inner)}const passStyle=passStyleOfInternal(inner);if(innerIsObject){passStyleMemo.set(inner,passStyle);inProgress.delete(inner)}return passStyle};const passStyleOfInternal=inner=>{const typestr=typeof inner;switch(typestr){case"undefined":case"boolean":case"number":case"bigint":{return typestr}case"string":{assertPassableString(inner);return"string"}case"symbol":{assertPassableSymbol(inner);return"symbol"}case"object":{if(inner===null){return"null"}if(!isFrozen5(inner)){assert.fail(isTypedArray(inner)?redacted`Cannot pass mutable typed arrays like ${inner}.`:redacted`Cannot pass non-frozen objects like ${inner}. Use harden()`)}if(isPromise(inner)){assertSafePromise(inner);return"promise"}typeof inner.then!=="function"||throwRedacted`Cannot pass non-promise thenables`;const passStyleTag=inner[PASS_STYLE];if(passStyleTag!==void 0){assert.typeof(passStyleTag,"string");const helper=HelperTable[passStyleTag];helper!==void 0||throwRedacted`Unrecognized PassStyle: ${quote(passStyleTag)}`;assertValid(helper,inner,passStyleOfRecur);return passStyleTag}for(const helper of passStyleHelpers){if(helper.canBeValid(inner)){helper.assertRestValid(inner,passStyleOfRecur);return helper.styleName}}assertValid(remotableHelper,inner,passStyleOfRecur);return"remotable"}case"function":{isFrozen5(inner)||throwRedacted`Cannot pass non-frozen objects like ${inner}. Use harden()`;typeof inner.then!=="function"||throwRedacted`Cannot pass non-promise thenables`;assertValid(remotableHelper,inner,passStyleOfRecur);return"remotable"}default:{throw assert.fail(redacted`Unrecognized typeof ${quote(typestr)}`,TypeError)}}};return passStyleOfRecur(passable)};return harden(passStyleOf2)};var PassStyleOfEndowmentSymbol=Symbol.for("@endo passStyleOf");var passStyleOf=globalThis&&globalThis[PassStyleOfEndowmentSymbol]||makePassStyleOf([CopyArrayHelper,ByteArrayHelper,CopyRecordHelper,TaggedHelper,ErrorHelper,RemotableHelper]);var assertPassable=val=>{passStyleOf(val)};harden(assertPassable);var isPassable=specimen=>{try{return passStyleOf(specimen)!==void 0}catch(_){return false}};harden(isPassable);var isPassableErrorPropertyDesc=(name,desc)=>checkRecursivelyPassableErrorPropertyDesc(name,desc,passStyleOf);var toPassableError=err=>{harden(err);if(checkRecursivelyPassableError(err,passStyleOf)){return err}const{name,message}=err;const{cause:causeDesc,errors:errorsDesc}=getOwnPropertyDescriptors5(err);let cause;let errors;if(causeDesc&&isPassableErrorPropertyDesc("cause",causeDesc)){cause=causeDesc.value}if(errorsDesc&&isPassableErrorPropertyDesc("errors",errorsDesc)){errors=errorsDesc.value}const errConstructor=getErrorConstructor(`${name}`)||Error;const newError=makeError(`${message}`,errConstructor,{cause,errors});harden(newError);note(newError,redacted`copied from error ${err}`);passStyleOf(newError)==="error"||throwRedacted`Expected ${newError} to be a passable error`;return newError};harden(toPassableError);var toThrowable=specimen=>{harden(specimen);if(isErrorLike(specimen)){return toPassableError(specimen)}if(!isPrimitive2(specimen)){const passStyle=passStyleOf(specimen);switch(passStyle){case"copyArray":{const elements=specimen;for(const element of elements){element===toThrowable(element)||throwRedacted`nested toThrowable coercion not yet supported ${element}`}break}case"copyRecord":{const rec=specimen;for(const val of values(rec)){val===toThrowable(val)||throwRedacted`nested toThrowable coercion not yet supported ${val}`}break}case"tagged":{const tg=specimen;const{payload}=tg;payload===toThrowable(payload)||throwRedacted`nested toThrowable coercion not yet supported ${payload}`;break}case"error":{const er=specimen;er===toThrowable(er)||throwRedacted`nested toThrowable coercion not yet supported ${er}`;break}default:{throw throwRedacted`A ${quote(passStyle)} is not throwable: ${specimen}`}}}return specimen};harden(toThrowable);var{create:create2,prototype:objectPrototype5}=Object;var makeTagged=(tag,payload)=>{typeof tag==="string"||throwRedacted`The tag of a tagged record must be a string: ${tag}`;assertPassable(harden(payload));return harden(create2(objectPrototype5,{[PASS_STYLE]:{value:"tagged"},[Symbol.toStringTag]:{value:tag},payload:{value:payload,enumerable:true}}))};harden(makeTagged);var identChecker=(cond,_details)=>cond;harden(identChecker);var isCopyArray=arr=>passStyleOf(arr)==="copyArray";harden(isCopyArray);var isByteArray=arr=>passStyleOf(arr)==="byteArray";harden(isByteArray);var isRecord=record=>passStyleOf(record)==="copyRecord";harden(isRecord);var isRemotable=remotable=>passStyleOf(remotable)==="remotable";harden(isRemotable);var assertCopyArray=(arr,optNameOfArray="Alleged array")=>{const passStyle=passStyleOf(arr);passStyle==="copyArray"||throwRedacted`${quote(optNameOfArray)} ${arr} must be a pass-by-copy array, not ${quote(passStyle)}`};harden(assertCopyArray);var assertByteArray=(arr,optNameOfArray="Alleged byteArray")=>{const passStyle=passStyleOf(arr);passStyle==="byteArray"||throwRedacted`${quote(optNameOfArray)} ${arr} must be a pass-by-copy binary data, not ${quote(passStyle)}`};harden(assertByteArray);var assertRecord=(record,optNameOfRecord="Alleged record")=>{const passStyle=passStyleOf(record);passStyle==="copyRecord"||throwRedacted`${quote(optNameOfRecord)} ${record} must be a pass-by-copy record, not ${quote(passStyle)}`};harden(assertRecord);var assertRemotable=(remotable,optNameOfRemotable="Alleged remotable")=>{const passStyle=passStyleOf(remotable);passStyle==="remotable"||throwRedacted`${quote(optNameOfRemotable)} ${remotable} must be a remotable, not ${quote(passStyle)}`};harden(assertRemotable);var checkAtom=(val,check)=>{let passStyle;try{passStyle=passStyleOf(val)}catch(err){return check!==identChecker&&check(false,redacted`Not even Passable: ${quote(err)}: ${val}`)}switch(passStyle){case"undefined":case"null":case"boolean":case"number":case"bigint":case"string":case"byteArray":case"symbol":{return true}default:{return check!==identChecker&&check(false,redacted`A ${quote(passStyle)} cannot be an atom: ${val}`)}}};var isAtom=val=>checkAtom(val,identChecker);harden(isAtom);var assertAtom=val=>{checkAtom(val,assertChecker)};harden(assertAtom);var hiddenPriorError;var hiddenCurrentTurn=0;var hiddenCurrentEvent=0;var VERBOSE=environmentOptionsListHas("DEBUG","track-turns");var ENABLED=getEnvironmentOption("TRACK_TURNS","disabled",["enabled"])==="enabled";var addRejectionNote=detailsNote=>reason=>{if(reason instanceof Error){globalThis.assert.note(reason,detailsNote)}if(VERBOSE){console.log("REJECTED at top of event loop",reason)}};var wrapFunction=(func,sendingError,X3)=>(...args)=>{hiddenPriorError=sendingError;hiddenCurrentTurn+=1;hiddenCurrentEvent=0;try{let result;try{result=func(...args)}catch(err){if(err instanceof Error){globalThis.assert.note(err,X3`Thrown from: ${hiddenPriorError}:${hiddenCurrentTurn}.${hiddenCurrentEvent}`)}if(VERBOSE){console.log("THROWN to top of event loop",err)}throw err}const detailsNote=X3`Rejection from: ${hiddenPriorError}:${hiddenCurrentTurn}.${hiddenCurrentEvent}`;Promise.resolve(result).catch(addRejectionNote(detailsNote));return result}finally{hiddenPriorError=void 0}};var trackTurns=funcs=>{if(!ENABLED||typeof globalThis==="undefined"||!globalThis.assert){return funcs}const{details:X3,note:annotateError}=globalThis.assert;hiddenCurrentEvent+=1;const sendingError=Error(`Event: ${hiddenCurrentTurn}.${hiddenCurrentEvent}`);if(hiddenPriorError!==void 0){annotateError(sendingError,X3`Caused by: ${hiddenPriorError}`)}return funcs.map(func=>func&&wrapFunction(func,sendingError,X3))};var{details:X2,quote:q4,Fail:Fail4,error:makeError2}=assert;var{assign,freeze:freeze4}=Object;var onSend=makeMessageBreakpointTester("ENDO_SEND_BREAKPOINTS");var baseFreezableProxyHandler={set(_target,_prop,_value){return false},isExtensible(_target){return false},setPrototypeOf(_target,_value){return false},deleteProperty(_target,_prop){return false}};var makeEProxyHandler=(recipient,HandledPromise2)=>harden({...baseFreezableProxyHandler,get:(_target,propertyKey,receiver)=>{return harden({[propertyKey](...args){if(this!==receiver){return HandledPromise2.reject(makeError2(X2`Unexpected receiver for "${q4(propertyKey)}" method of E(${q4(recipient)})`))}if(onSend&&onSend.shouldBreakpoint(recipient,propertyKey)){debugger}return HandledPromise2.applyMethod(recipient,propertyKey,args)}}[propertyKey])},apply:(_target,_thisArg,argArray=[])=>{if(onSend&&onSend.shouldBreakpoint(recipient,void 0)){debugger}return HandledPromise2.applyFunction(recipient,argArray)},has:(_target,_p)=>{return true}});var makeESendOnlyProxyHandler=(recipient,HandledPromise2)=>harden({...baseFreezableProxyHandler,get:(_target,propertyKey,receiver)=>{return harden({[propertyKey](...args){this===receiver||Fail4`Unexpected receiver for "${q4(propertyKey)}" method of E.sendOnly(${q4(recipient)})`;if(onSend&&onSend.shouldBreakpoint(recipient,propertyKey)){debugger}HandledPromise2.applyMethodSendOnly(recipient,propertyKey,args);return void 0}}[propertyKey])},apply:(_target,_thisArg,argsArray=[])=>{if(onSend&&onSend.shouldBreakpoint(recipient,void 0)){debugger}HandledPromise2.applyFunctionSendOnly(recipient,argsArray);return void 0},has:(_target,_p)=>{return true}});var makeEGetProxyHandler=(x,HandledPromise2)=>harden({...baseFreezableProxyHandler,has:(_target,_prop)=>true,get:(_target,prop)=>HandledPromise2.get(x,prop)});var funcTarget=freeze4(()=>{});var objTarget=freeze4({__proto__:null});var makeE=HandledPromise2=>{return harden(assign(x=>new Proxy(funcTarget,makeEProxyHandler(x,HandledPromise2)),{get:x=>new Proxy(objTarget,makeEGetProxyHandler(x,HandledPromise2)),resolve:HandledPromise2.resolve,sendOnly:x=>new Proxy(funcTarget,makeESendOnlyProxyHandler(x,HandledPromise2)),when:(x,onfulfilled,onrejected)=>HandledPromise2.resolve(x).then(...trackTurns([onfulfilled,onrejected]))}))};var E_default=makeE;var hp=HandledPromise;var E=E_default(hp);var{ownKeys:ownKeys10}=Reflect;var{fromEntries}=Object;var deeplyFulfilled=async val=>{if(isAtom(val)){return val}if(isPromise(val)){return E.when(val,nonp=>deeplyFulfilled(nonp))}const passStyle=passStyleOf(val);switch(passStyle){case"copyRecord":{const rec=val;const names=ownKeys10(rec);const valPs=names.map(name=>deeplyFulfilled(rec[name]));return E.when(Promise.all(valPs),vals=>harden(fromEntries(vals.map((c,i)=>[names[i],c]))))}case"copyArray":{const arr=val;const valPs=arr.map(p=>deeplyFulfilled(p));return E.when(Promise.all(valPs),vals=>harden(vals))}case"byteArray":{const byteArray=val;return byteArray}case"tagged":{const tgd=val;const tag=getTag(tgd);return E.when(deeplyFulfilled(tgd.payload),payload=>makeTagged(tag,payload))}case"remotable":{const rem=val;return rem}case"error":{const err=val;return err}case"promise":{const prom=val;return E.when(prom,nonp=>deeplyFulfilled(nonp))}default:{throw assert.fail(redacted`Unexpected passStyle ${quote(passStyle)}`,TypeError)}}};harden(deeplyFulfilled);var{ownKeys:ownKeys11}=Reflect;var{isArray:isArray4}=Array;var{getOwnPropertyDescriptors:getOwnPropertyDescriptors6,defineProperties,is,entries:entries3,fromEntries:fromEntries2,freeze:freeze5,hasOwn:hasOwn6}=Object;var QCLASS="@qclass";var hasQClass=encoded=>hasOwn6(encoded,QCLASS);var qclassMatches=(encoded,qclass)=>!isPrimitive2(encoded)&&!isArray4(encoded)&&hasQClass(encoded)&&encoded[QCLASS]===qclass;var dontEncodeRemotableToCapData=rem=>throwRedacted`remotable unexpected: ${rem}`;var dontEncodePromiseToCapData=prom=>throwRedacted`promise unexpected: ${prom}`;var dontEncodeErrorToCapData=err=>throwRedacted`error object unexpected: ${err}`;var makeEncodeToCapData=(encodeOptions={})=>{const{encodeRemotableToCapData=dontEncodeRemotableToCapData,encodePromiseToCapData=dontEncodePromiseToCapData,encodeErrorToCapData=dontEncodeErrorToCapData}=encodeOptions;const encodeToCapDataRecur=passable=>{const passStyle=passStyleOf(passable);switch(passStyle){case"null":case"boolean":case"string":{return passable}case"undefined":{return{[QCLASS]:"undefined"}}case"number":{if(Number.isNaN(passable)){return{[QCLASS]:"NaN"}}else if(passable===Infinity){return{[QCLASS]:"Infinity"}}else if(passable===-Infinity){return{[QCLASS]:"-Infinity"}}return is(passable,-0)?0:passable}case"bigint":{return{[QCLASS]:"bigint",digits:String(passable)}}case"symbol":{assertPassableSymbol(passable);const name=nameForPassableSymbol(passable);return{[QCLASS]:"symbol",name}}case"copyRecord":{if(hasOwn6(passable,QCLASS)){const{[QCLASS]:qclassValue,...rest}=passable;const result={[QCLASS]:"hilbert",original:encodeToCapDataRecur(qclassValue)};if(ownKeys11(rest).length>=1){result.rest=encodeToCapDataRecur(freeze5(rest))}return result}const names=ownKeys11(passable).sort();return fromEntries2(names.map(name=>[name,encodeToCapDataRecur(passable[name])]))}case"copyArray":{return passable.map(encodeToCapDataRecur)}case"byteArray":{throw throwRedacted`marsal of byteArray not yet implemented: ${passable}`}case"tagged":{return{[QCLASS]:"tagged",tag:getTag(passable),payload:encodeToCapDataRecur(passable.payload)}}case"remotable":{const encoded=encodeRemotableToCapData(passable,encodeToCapDataRecur);if(qclassMatches(encoded,"slot")){return encoded}throw throwRedacted`internal: Remotable encoding must be an object with ${quote(QCLASS)} ${quote("slot")}: ${encoded}`}case"promise":{const encoded=encodePromiseToCapData(passable,encodeToCapDataRecur);if(qclassMatches(encoded,"slot")){return encoded}throw throwRedacted`internal: Promise encoding must be an object with ${quote(QCLASS,"slot")}: ${encoded}`}case"error":{const encoded=encodeErrorToCapData(passable,encodeToCapDataRecur);if(qclassMatches(encoded,"error")){return encoded}throw throwRedacted`internal: Error encoding must be an object with ${quote(QCLASS,"error")}: ${encoded}`}default:{throw assert.fail(redacted`internal: Unrecognized passStyle ${quote(passStyle)}`,TypeError)}}};const encodeToCapData=passable=>{if(isErrorLike(passable)){return harden(encodeErrorToCapData(passable,encodeToCapDataRecur))}return harden(encodeToCapDataRecur(passable))};return harden(encodeToCapData)};harden(makeEncodeToCapData);var dontDecodeRemotableOrPromiseFromCapData=slotEncoding=>throwRedacted`remotable or promise unexpected: ${slotEncoding}`;var dontDecodeErrorFromCapData=errorEncoding=>throwRedacted`error unexpected: ${errorEncoding}`;var makeDecodeFromCapData=(decodeOptions={})=>{const{decodeRemotableFromCapData=dontDecodeRemotableOrPromiseFromCapData,decodePromiseFromCapData=dontDecodeRemotableOrPromiseFromCapData,decodeErrorFromCapData=dontDecodeErrorFromCapData}=decodeOptions;decodeRemotableFromCapData===decodePromiseFromCapData||throwRedacted`An implementation restriction for now: If either decodeRemotableFromCapData or decodePromiseFromCapData is provided, both must be provided and they must be the same: ${quote(decodeRemotableFromCapData)} vs ${quote(decodePromiseFromCapData)}`;const decodeFromCapData=jsonEncoded=>{if(isPrimitive2(jsonEncoded)){return jsonEncoded}if(isArray4(jsonEncoded)){return jsonEncoded.map(encodedVal=>decodeFromCapData(encodedVal))}else if(hasQClass(jsonEncoded)){const qclass=jsonEncoded[QCLASS];typeof qclass==="string"||throwRedacted`invalid ${quote(QCLASS)} typeof ${quote(typeof qclass)}`;switch(qclass){case"undefined":{return void 0}case"NaN":{return NaN}case"Infinity":{return Infinity}case"-Infinity":{return-Infinity}case"bigint":{const{digits}=jsonEncoded;typeof digits==="string"||throwRedacted`invalid digits typeof ${quote(typeof digits)}`;return BigInt(digits)}case"@@asyncIterator":{return Symbol.asyncIterator}case"symbol":{const{name}=jsonEncoded;return passableSymbolForName(name)}case"tagged":{const{tag,payload}=jsonEncoded;return makeTagged(tag,decodeFromCapData(payload))}case"slot":{const decoded=decodeRemotableFromCapData(jsonEncoded,decodeFromCapData);return decoded}case"error":{const decoded=decodeErrorFromCapData(jsonEncoded,decodeFromCapData);if(passStyleOf(decoded)==="error"){return decoded}throw throwRedacted`internal: decodeErrorFromCapData option must return an error: ${decoded}`}case"hilbert":{const{original,rest}=jsonEncoded;hasOwn6(jsonEncoded,"original")||throwRedacted`Invalid Hilbert Hotel encoding ${jsonEncoded}`;const result={[QCLASS]:decodeFromCapData(original)};if(hasOwn6(jsonEncoded,"rest")){const isNonEmptyObject=typeof rest==="object"&&rest!==null&&ownKeys11(rest).length>=1;if(!isNonEmptyObject){throw throwRedacted`Rest encoding must be a non-empty object: ${rest}`}const restObj=decodeFromCapData(rest);!hasOwn6(restObj,QCLASS)||throwRedacted`Rest must not contain its own definition of ${quote(QCLASS)}`;defineProperties(result,getOwnPropertyDescriptors6(restObj))}return result}case"ibid":{throw throwRedacted`The capData protocol no longer supports ${quote(QCLASS)} ${quote(qclass)}`}default:{throw assert.fail(redacted`unrecognized ${quote(QCLASS)} ${quote(qclass)}`,TypeError)}}}else{assert(typeof jsonEncoded==="object"&&jsonEncoded!==null);const decodeEntry=([name,encodedVal])=>{typeof name==="string"||throwRedacted`Property ${quote(name)} of ${jsonEncoded} must be a string`;return[name,decodeFromCapData(encodedVal)]};const decodedEntries=entries3(jsonEncoded).map(decodeEntry);return fromEntries2(decodedEntries)}};return harden(decodeFromCapData)};function isNat(allegedNum){if(typeof allegedNum==="bigint"){return allegedNum>=0}if(typeof allegedNum!=="number"){return false}return Number.isSafeInteger(allegedNum)&&allegedNum>=0}function Nat(allegedNum){if(typeof allegedNum==="bigint"){if(allegedNum<0n){throw RangeError(`${allegedNum} is negative`)}return allegedNum}if(typeof allegedNum==="number"){if(!Number.isSafeInteger(allegedNum)){throw RangeError(`${allegedNum} is not a safe integer`)}if(allegedNum<0){throw RangeError(`${allegedNum} is negative`)}return BigInt(allegedNum)}throw TypeError(`${allegedNum} is a ${typeof allegedNum} but must be a bigint or a number`)}var{entries:entries4,fromEntries:fromEntries3}=Object;var objectMap=(original,mapFn)=>{const ents=entries4(original);const mapEnts=ents.map(([k,v])=>[k,mapFn(v,k)]);return harden(fromEntries3(mapEnts))};harden(objectMap);var{ownKeys:ownKeys12}=Reflect;var{isArray:isArray5}=Array;var{is:is2,entries:entries5,fromEntries:fromEntries4,hasOwn:hasOwn7}=Object;var BANG="!".charCodeAt(0);var DASH="-".charCodeAt(0);var startsSpecial=encodedStr=>{if(encodedStr===""){return false}const code=encodedStr.charCodeAt(0);return BANG<=code&&code<=DASH};var dontEncodeRemotableToSmallcaps=rem=>throwRedacted`remotable unexpected: ${rem}`;var dontEncodePromiseToSmallcaps=prom=>throwRedacted`promise unexpected: ${prom}`;var dontEncodeErrorToSmallcaps=err=>throwRedacted`error object unexpected: ${quote(err)}`;var makeEncodeToSmallcaps=(encodeOptions={})=>{const{encodeRemotableToSmallcaps=dontEncodeRemotableToSmallcaps,encodePromiseToSmallcaps=dontEncodePromiseToSmallcaps,encodeErrorToSmallcaps=dontEncodeErrorToSmallcaps}=encodeOptions;const assertEncodedError=encoding=>{typeof encoding==="object"&&hasOwn7(encoding,"#error")||throwRedacted`internal: Error encoding must have "#error" property: ${quote(encoding)}`;const message=encoding["#error"];typeof message==="string"&&(!startsSpecial(message)||message.charAt(0)==="!")||throwRedacted`internal: Error encoding must have string message: ${quote(message)}`};const encodeToSmallcapsRecur=passable=>{const passStyle=passStyleOf(passable);switch(passStyle){case"null":case"boolean":{return passable}case"string":{if(startsSpecial(passable)){return`!${passable}`}return passable}case"undefined":{return"#undefined"}case"number":{if(Number.isNaN(passable)){return"#NaN"}else if(passable===Infinity){return"#Infinity"}else if(passable===-Infinity){return"#-Infinity"}return is2(passable,-0)?0:passable}case"bigint":{const str=String(passable);return passable<0n?str:`+${str}`}case"symbol":{assertPassableSymbol(passable);const name=nameForPassableSymbol(passable);return`%${name}`}case"copyRecord":{const names=ownKeys12(passable).sort();return fromEntries4(names.map(name=>[encodeToSmallcapsRecur(name),encodeToSmallcapsRecur(passable[name])]))}case"copyArray":{return passable.map(encodeToSmallcapsRecur)}case"byteArray":{throw throwRedacted`marsal of byteArray not yet implemented: ${passable}`}case"tagged":{return{"#tag":encodeToSmallcapsRecur(getTag(passable)),payload:encodeToSmallcapsRecur(passable.payload)}}case"remotable":{const result=encodeRemotableToSmallcaps(passable,encodeToSmallcapsRecur);if(typeof result==="string"&&result.charAt(0)==="$"){return result}throw throwRedacted`internal: Remotable encoding must start with "$": ${result}`}case"promise":{const result=encodePromiseToSmallcaps(passable,encodeToSmallcapsRecur);if(typeof result==="string"&&result.charAt(0)==="&"){return result}throw throwRedacted`internal: Promise encoding must start with "&": ${result}`}case"error":{const result=encodeErrorToSmallcaps(passable,encodeToSmallcapsRecur);assertEncodedError(result);return result}default:{throw assert.fail(redacted`internal: Unrecognized passStyle ${quote(passStyle)}`,TypeError)}}};const encodeToSmallcaps=passable=>{if(isErrorLike(passable)){const result=harden(encodeErrorToSmallcaps(passable,encodeToSmallcapsRecur));assertEncodedError(result);return result}return harden(encodeToSmallcapsRecur(passable))};return harden(encodeToSmallcaps)};harden(makeEncodeToSmallcaps);var dontDecodeRemotableFromSmallcaps=encoding=>throwRedacted`remotable unexpected: ${encoding}`;var dontDecodePromiseFromSmallcaps=encoding=>throwRedacted`promise unexpected: ${encoding}`;var dontDecodeErrorFromSmallcaps=encoding=>throwRedacted`error unexpected: ${quote(encoding)}`;var makeDecodeFromSmallcaps=(decodeOptions={})=>{const{decodeRemotableFromSmallcaps=dontDecodeRemotableFromSmallcaps,decodePromiseFromSmallcaps=dontDecodePromiseFromSmallcaps,decodeErrorFromSmallcaps=dontDecodeErrorFromSmallcaps}=decodeOptions;const decodeFromSmallcaps=encoding=>{switch(typeof encoding){case"boolean":case"number":{return encoding}case"string":{if(!startsSpecial(encoding)){return encoding}const c=encoding.charAt(0);switch(c){case"!":{return encoding.slice(1)}case"%":{return passableSymbolForName(encoding.slice(1))}case"#":{switch(encoding){case"#undefined":{return void 0}case"#NaN":{return NaN}case"#Infinity":{return Infinity}case"#-Infinity":{return-Infinity}default:{throw assert.fail(redacted`unknown constant "${quote(encoding)}"`,TypeError)}}}case"+":case"-":{return BigInt(encoding)}case"$":{const result=decodeRemotableFromSmallcaps(encoding,decodeFromSmallcaps);if(passStyleOf(result)!=="remotable"){throwRedacted`internal: decodeRemotableFromSmallcaps option must return a remotable: ${result}`}return result}case"&":{const result=decodePromiseFromSmallcaps(encoding,decodeFromSmallcaps);if(passStyleOf(result)!=="promise"){throwRedacted`internal: decodePromiseFromSmallcaps option must return a promise: ${result}`}return result}default:{throw throwRedacted`Special char ${quote(c)} reserved for future use: ${encoding}`}}}case"object":{if(encoding===null){return encoding}if(isArray5(encoding)){return encoding.map(val=>decodeFromSmallcaps(val))}if(hasOwn7(encoding,"#tag")){const{"#tag":tag,payload,...rest}=encoding;typeof tag==="string"||throwRedacted`Value of "#tag", the tag, must be a string: ${encoding}`;ownKeys12(rest).length===0||throwRedacted`#tag record unexpected properties: ${quote(ownKeys12(rest))}`;return makeTagged(decodeFromSmallcaps(tag),decodeFromSmallcaps(payload))}if(hasOwn7(encoding,"#error")){const result=decodeErrorFromSmallcaps(encoding,decodeFromSmallcaps);passStyleOf(result)==="error"||throwRedacted`internal: decodeErrorFromSmallcaps option must return an error: ${result}`;return result}const decodeEntry=([encodedName,encodedVal])=>{typeof encodedName==="string"||throwRedacted`Property name ${quote(encodedName)} of ${encoding} must be a string`;encodedName.charAt(0)!=="#"||throwRedacted`Unrecognized record type ${quote(encodedName)}: ${encoding}`;const name=decodeFromSmallcaps(encodedName);typeof name==="string"||throwRedacted`Decoded property name ${name} from ${encoding} must be a string`;return[name,decodeFromSmallcaps(encodedVal)]};const decodedEntries=entries5(encoding).map(decodeEntry);return fromEntries4(decodedEntries)}default:{throw assert.fail(redacted`internal: unrecognized JSON typeof ${quote(typeof encoding)}: ${encoding}`,TypeError)}}};return harden(decodeFromSmallcaps)};var{defineProperties:defineProperties2,hasOwn:hasOwn8}=Object;var{isArray:isArray6}=Array;var{ownKeys:ownKeys13}=Reflect;var defaultValToSlotFn=x=>x;var defaultSlotToValFn=(x,_)=>x;var makeMarshal=(convertValToSlot=defaultValToSlotFn,convertSlotToVal=defaultSlotToValFn,{errorTagging="on",marshalName="anon-marshal",errorIdNum=1e4,marshalSaveError=err=>console.log("Temporary logging of sent error",err),serializeBodyFormat="capdata"}={})=>{assert.typeof(marshalName,"string");errorTagging==="on"||errorTagging==="off"||throwRedacted`The errorTagging option can only be "on" or "off" ${errorTagging}`;const nextErrorId=()=>{errorIdNum+=1;return`error:${marshalName}#${errorIdNum}`};const toCapData=root=>{const slots=[];const slotMap=new Map;const encodeSlotCommon=passable=>{let index=slotMap.get(passable);if(index!==void 0){assert.typeof(index,"number");return harden({index,repeat:true})}index=slots.length;const slot=convertValToSlot(passable);slots.push(slot);slotMap.set(passable,index);return harden({index,repeat:false})};const encodeErrorCommon=(err,encodeRecur)=>{const message=encodeRecur(`${err.message}`);assert.typeof(message,"string");const name=encodeRecur(`${err.name}`);assert.typeof(name,"string");if(errorTagging==="on"){const errorId=encodeRecur(nextErrorId());assert.typeof(errorId,"string");note(err,redacted`Sent as ${errorId}`);marshalSaveError(err);return harden({errorId,message,name})}else{return harden({message,name})}};if(serializeBodyFormat==="capdata"){const encodeSlotToCapData=(passable,iface=void 0)=>{const{index,repeat}=encodeSlotCommon(passable);if(repeat===true||iface===void 0){return harden({[QCLASS]:"slot",index})}else{return harden({[QCLASS]:"slot",iface,index})}};const encodeRemotableToCapData=(val,_encodeRecur)=>encodeSlotToCapData(val,getInterfaceOf(val));const encodePromiseToCapData=(promise,_encodeRecur)=>encodeSlotToCapData(promise);const encodeErrorToCapData=(err,encodeRecur)=>{const errData=encodeErrorCommon(err,encodeRecur);return harden({[QCLASS]:"error",...errData})};const encodeToCapData=makeEncodeToCapData({encodeRemotableToCapData,encodePromiseToCapData,encodeErrorToCapData});const encoded=encodeToCapData(root);const body=JSON.stringify(encoded);return harden({body,slots})}else if(serializeBodyFormat==="smallcaps"){const encodeSlotToSmallcaps=(prefix,passable,iface=void 0)=>{const{index,repeat}=encodeSlotCommon(passable);if(repeat===true||iface===void 0){return`${prefix}${index}`}return`${prefix}${index}.${iface}`};const encodeRemotableToSmallcaps=(remotable,_encodeRecur)=>encodeSlotToSmallcaps("$",remotable,getInterfaceOf(remotable));const encodePromiseToSmallcaps=(promise,_encodeRecur)=>encodeSlotToSmallcaps("&",promise);const encodeErrorToSmallcaps=(err,encodeRecur)=>{const errData=encodeErrorCommon(err,encodeRecur);const{message,...rest}=errData;return harden({"#error":message,...rest})};const encodeToSmallcaps=makeEncodeToSmallcaps({encodeRemotableToSmallcaps,encodePromiseToSmallcaps,encodeErrorToSmallcaps});const encoded=encodeToSmallcaps(root);const smallcapsBody=JSON.stringify(encoded);return harden({body:`#${smallcapsBody}`,slots})}else{throw throwRedacted`Unrecognized serializeBodyFormat: ${quote(serializeBodyFormat)}`}};const makeFullRevive=slots=>{const valMap=new Map;const decodeSlotCommon=slotData=>{const{iface=void 0,index,...rest}=slotData;ownKeys13(rest).length===0||throwRedacted`unexpected encoded slot properties ${quote(ownKeys13(rest))}`;const extant=valMap.get(index);if(extant){return extant}const slot=slots[Number(Nat(index))];const val=convertSlotToVal(slot,iface);valMap.set(index,val);return val};const decodeErrorCommon=(errData,decodeRecur)=>{const{errorId=void 0,message,name,cause=void 0,errors=void 0,...rest}=errData;const dName=decodeRecur(name);const dMessage=decodeRecur(message);const dErrorId=errorId&&decodeRecur(errorId);if(typeof dName!=="string"){throw throwRedacted`invalid error name typeof ${quote(typeof dName)}`}if(typeof dMessage!=="string"){throw throwRedacted`invalid error message typeof ${quote(typeof dMessage)}`}const errConstructor=getErrorConstructor(dName)||Error;const errorName=dErrorId===void 0?`Remote${errConstructor.name}`:`Remote${errConstructor.name}(${dErrorId})`;const options={errorName,sanitize:false};if(cause){options.cause=decodeRecur(cause)}if(errors){options.errors=decodeRecur(errors)}const rawError=makeError(dMessage,errConstructor,options);const descs=objectMap(rest,data=>({value:decodeRecur(data),writable:false,enumerable:false,configurable:false}));defineProperties2(rawError,descs);harden(rawError);return toPassableError(rawError)};const decodeRemotableOrPromiseFromCapData=(rawTree,_decodeRecur)=>{const{[QCLASS]:_,...slotData}=rawTree;return decodeSlotCommon(slotData)};const decodeErrorFromCapData=(rawTree,decodeRecur)=>{const{[QCLASS]:_,...errData}=rawTree;return decodeErrorCommon(errData,decodeRecur)};const reviveFromCapData=makeDecodeFromCapData({decodeRemotableFromCapData:decodeRemotableOrPromiseFromCapData,decodePromiseFromCapData:decodeRemotableOrPromiseFromCapData,decodeErrorFromCapData});const makeDecodeSlotFromSmallcaps=prefix=>{return(stringEncoding,_decodeRecur)=>{assert(stringEncoding.charAt(0)===prefix);const i=stringEncoding.indexOf(".");const index=Number(stringEncoding.slice(1,i<0?void 0:i));const iface=i<0?void 0:stringEncoding.slice(i+1);return decodeSlotCommon({iface,index})}};const decodeRemotableFromSmallcaps=makeDecodeSlotFromSmallcaps("$");const decodePromiseFromSmallcaps=makeDecodeSlotFromSmallcaps("&");const decodeErrorFromSmallcaps=(encoding,decodeRecur)=>{const{"#error":message,...restErrData}=encoding;!hasOwn8(restErrData,"message")||throwRedacted`unexpected encoded error property ${quote("message")}`;return decodeErrorCommon({message,...restErrData},decodeRecur)};const reviveFromSmallcaps=makeDecodeFromSmallcaps({decodeRemotableFromSmallcaps,decodePromiseFromSmallcaps,decodeErrorFromSmallcaps});return harden({reviveFromCapData,reviveFromSmallcaps})};const fromCapData=data=>{const{body,slots}=data;typeof body==="string"||throwRedacted`unserialize() given non-capdata (.body is ${body}, not string)`;isArray6(data.slots)||throwRedacted`unserialize() given non-capdata (.slots are not Array)`;const{reviveFromCapData,reviveFromSmallcaps}=makeFullRevive(slots);let result;if(body.charAt(0)==="#"){const smallcapsBody=body.slice(1);const encoding=harden(JSON.parse(smallcapsBody));result=harden(reviveFromSmallcaps(encoding))}else{const rawTree=harden(JSON.parse(body));result=harden(reviveFromCapData(rawTree))}assertPassable(result);return result};return harden({toCapData,fromCapData,serialize:toCapData,unserialize:fromCapData})};var{freeze:freeze6}=Object;var doNotConvertValToSlot=val=>throwRedacted`Marshal's stringify rejects presences and promises ${val}`;var doNotConvertSlotToVal=(slot,_iface)=>throwRedacted`Marshal's parse must not encode any slots ${slot}`;var badArrayHandler=harden({get:(_target,name,_receiver)=>{if(name==="length"){return 0}throw throwRedacted`Marshal's parse must not encode any slot positions ${name}`}});var arrayTarget=freeze6([]);var badArray=new Proxy(arrayTarget,badArrayHandler);var{serialize,unserialize}=makeMarshal(doNotConvertValToSlot,doNotConvertSlotToVal,{errorTagging:"off",serializeBodyFormat:"capdata"});var stringify=val=>serialize(val).body;harden(stringify);var parse=str=>unserialize(freeze6({body:str,slots:badArray}));harden(parse);var{ownKeys:ownKeys14}=Reflect;var{isArray:isArray7}=Array;var{stringify:quote2}=JSON;var makeYesIndenter=()=>{const strings=[];let level=0;let needSpace=false;const line=()=>{needSpace=false;return strings.push("\n","  ".repeat(level))};return harden({open:openBracket=>{level+=1;if(needSpace){strings.push(" ")}needSpace=false;return strings.push(openBracket)},line,next:token=>{if(needSpace&&token!==","&&token!==")"){strings.push(" ")}needSpace=true;return strings.push(token)},close:closeBracket=>{assert(level>=1);level-=1;line();return strings.push(closeBracket)},done:()=>{assert.equal(level,0);return strings.join("")}})};var badPairPattern=/^(?:\w\w|<<|>>|\+\+|--|<!|->)$/;var makeNoIndenter=()=>{const strings=[];return harden({open:openBracket=>strings.push(openBracket),line:()=>strings.length,next:token=>{if(strings.length>=1){const last=strings[strings.length-1];if(last.length>=1&&token.length>=1){const pair=`${last[last.length-1]}${token[0]}`;if(badPairPattern.test(pair)){strings.push(" ")}}}return strings.push(token)},close:closeBracket=>{if(strings.length>=1&&strings[strings.length-1]===","){strings.pop()}return strings.push(closeBracket)},done:()=>strings.join("")})};var identPattern=/^[a-zA-Z]\w*$/;harden(identPattern);var AtAtPrefixPattern2=/^@@(.*)$/;harden(AtAtPrefixPattern2);var decodeToJustin=(encoding,shouldIndent=false,slots=[])=>{const prepare=rawTree=>{if(isPrimitive2(rawTree)){return}assert.typeof(rawTree,"object");assert(rawTree!==null);if(QCLASS in rawTree){const qclass=rawTree[QCLASS];typeof qclass==="string"||throwRedacted`invalid qclass typeof ${quote(typeof qclass)}`;assert(!isArray7(rawTree));switch(rawTree["@qclass"]){case"undefined":case"NaN":case"Infinity":case"-Infinity":{return}case"bigint":{const{digits}=rawTree;typeof digits==="string"||throwRedacted`invalid digits typeof ${quote(typeof digits)}`;return}case"@@asyncIterator":{return}case"symbol":{const{name}=rawTree;assert.typeof(name,"string");const sym=passableSymbolForName(name);assert.typeof(sym,"symbol");return}case"tagged":{const{tag,payload}=rawTree;assert.typeof(tag,"string");prepare(payload);return}case"slot":{const{index,iface}=rawTree;assert.typeof(index,"number");Nat(index);if(iface!==void 0){assert.typeof(iface,"string")}return}case"hilbert":{const{original,rest}=rawTree;"original"in rawTree||throwRedacted`Invalid Hilbert Hotel encoding ${rawTree}`;prepare(original);if("rest"in rawTree){if(typeof rest!=="object"){throw throwRedacted`Rest ${rest} encoding must be an object`}if(rest===null){throw throwRedacted`Rest ${rest} encoding must not be null`}if(isArray7(rest)){throw throwRedacted`Rest ${rest} encoding must not be an array`}if(QCLASS in rest){throw throwRedacted`Rest encoding ${rest} must not contain ${quote(QCLASS)}`}const names=ownKeys14(rest);for(const name of names){typeof name==="string"||throwRedacted`Property name ${name} of ${rawTree} must be a string`;prepare(rest[name])}}return}case"error":{const{name,message}=rawTree;if(typeof name!=="string"){throw throwRedacted`invalid error name typeof ${quote(typeof name)}`}getErrorConstructor(name)!==void 0||throwRedacted`Must be the name of an Error constructor ${name}`;typeof message==="string"||throwRedacted`invalid error message typeof ${quote(typeof message)}`;return}default:{assert.fail(redacted`unrecognized ${quote(QCLASS)} ${quote(qclass)}`,TypeError)}}}else if(isArray7(rawTree)){const{length}=rawTree;for(let i=0;i<length;i+=1){prepare(rawTree[i])}}else{const names=ownKeys14(rawTree);for(const name of names){if(typeof name!=="string"){throw throwRedacted`Property name ${name} of ${rawTree} must be a string`}prepare(rawTree[name])}}};const makeIndenter=shouldIndent?makeYesIndenter:makeNoIndenter;let out=makeIndenter();const decode=rawTree=>{return recur(rawTree)};const decodeProperty=(name,value)=>{out.line();if(name==="__proto__"){out.next(`["__proto__"]:`)}else if(identPattern.test(name)){out.next(`${name}:`)}else{out.next(`${quote2(name)}:`)}decode(value);out.next(",")};const recur=rawTree=>{if(isPrimitive2(rawTree)){return out.next(quote2(rawTree))}assert.typeof(rawTree,"object");assert(rawTree!==null);if(QCLASS in rawTree){const qclass=rawTree[QCLASS];assert.typeof(qclass,"string");assert(!isArray7(rawTree));switch(rawTree["@qclass"]){case"undefined":case"NaN":case"Infinity":case"-Infinity":{return out.next(qclass)}case"bigint":{const{digits}=rawTree;assert.typeof(digits,"string");return out.next(`${BigInt(digits)}n`)}case"@@asyncIterator":{return out.next("Symbol.asyncIterator")}case"symbol":{const{name}=rawTree;assert.typeof(name,"string");const sym=passableSymbolForName(name);assert.typeof(sym,"symbol");const registeredName=nameForPassableSymbol(sym);if(registeredName===void 0){const match=AtAtPrefixPattern2.exec(name);assert(match!==null);const suffix=match[1];assert(Symbol[suffix]===sym);assert(identPattern.test(suffix));return out.next(`Symbol.${suffix}`)}return out.next(`passableSymbolForName(${quote2(registeredName)})`)}case"tagged":{const{tag,payload}=rawTree;out.next(`makeTagged(${quote2(tag)}`);out.next(",");decode(payload);return out.next(")")}case"slot":{const{iface}=rawTree;const index=Number(Nat(rawTree.index));const nestedRender=arg=>{const oldOut=out;try{out=makeNoIndenter();decode(arg);return out.done()}finally{out=oldOut}};if(index<slots.length){const renderedSlot=nestedRender(slots[index]);return iface===void 0?out.next(`slotToVal(${renderedSlot})`):out.next(`slotToVal(${renderedSlot},${nestedRender(iface)})`)}return iface===void 0?out.next(`slot(${index})`):out.next(`slot(${index},${nestedRender(iface)})`)}case"hilbert":{const{original,rest}=rawTree;out.open("{");decodeProperty(QCLASS,original);if("rest"in rawTree){assert.typeof(rest,"object");assert(rest!==null);const names=ownKeys14(rest);for(const name of names){if(typeof name!=="string"){throw throwRedacted`Property name ${quote(name)} of ${rest} must be a string`}decodeProperty(name,rest[name])}}return out.close("}")}case"error":{const{name,message,cause=void 0,errors=void 0}=rawTree;cause===void 0||throwRedacted`error cause not yet implemented in marshal-justin`;name!==`AggregateError`||throwRedacted`AggregateError not yet implemented in marshal-justin`;errors===void 0||throwRedacted`error errors not yet implemented in marshal-justin`;return out.next(`${name}(${quote2(message)})`)}default:{throw assert.fail(redacted`unrecognized ${quote(QCLASS)} ${quote(qclass)}`,TypeError)}}}else if(isArray7(rawTree)){const{length}=rawTree;if(length===0){return out.next("[]")}else{out.open("[");for(let i=0;i<length;i+=1){out.line();decode(rawTree[i]);out.next(",")}return out.close("]")}}else{const names=ownKeys14(rawTree);if(names.length===0){return out.next("{}")}else{out.open("{");for(const name of names){decodeProperty(name,rawTree[name])}return out.close("}")}}};prepare(encoding);decode(encoding);return out.done()};harden(decodeToJustin);var passableAsJustin=(passable,shouldIndent=true)=>{let slotCount=0;const convertValToSlot=val=>`s${slotCount++}`;const{toCapData}=makeMarshal(convertValToSlot);const{body,slots}=toCapData(passable);const encoded=JSON.parse(body);return decodeToJustin(encoded,shouldIndent,slots)};harden(passableAsJustin);var qp=payload=>`\`${passableAsJustin(harden(payload),true)}\``;harden(qp);var{isArray:isArray8}=Array;var{fromEntries:fromEntries5,is:is3}=Object;var{ownKeys:ownKeys15}=Reflect;var rC0=/[\x00-\x1F]/;var getSuffix=(str,index)=>index===0?str:str.substring(index);var recordNames=record=>harden(ownKeys15(record).sort().reverse());harden(recordNames);var recordValues=(record,names)=>harden(names.map(name=>record[name]));harden(recordValues);var zeroes=Array(16).fill(void 0).map((_,i)=>"0".repeat(i));var zeroPad=(n,size)=>{const nStr=`${n}`;const fillLen=size-nStr.length;if(fillLen===0)return nStr;assert(fillLen>0&&fillLen<zeroes.length);return`${zeroes[fillLen]}${nStr}`};harden(zeroPad);var asNumber=new Float64Array(1);var asBits=new BigUint64Array(asNumber.buffer);var CanonicalNaNBits="fff8000000000000";var encodeBinary64=n=>{if(is3(n,-0)){n=0}else if(is3(n,NaN)){return`f${CanonicalNaNBits}`}asNumber[0]=n;let bits=asBits[0];if(n<0){bits^=0xffffffffffffffffn}else{bits^=0x8000000000000000n}return`f${zeroPad(bits.toString(16),16)}`};var decodeBinary64=(encoded,skip=0)=>{encoded.charAt(skip)==="f"||throwRedacted`Encoded number expected: ${encoded}`;let bits=BigInt(`0x${getSuffix(encoded,skip+1)}`);if(encoded.charAt(skip+1)<"8"){bits^=0xffffffffffffffffn}else{bits^=0x8000000000000000n}asBits[0]=bits;const result=asNumber[0];!is3(result,-0)||throwRedacted`Unexpected negative zero: ${getSuffix(encoded,skip)}`;return result};var encodeBigInt=n=>{const abs=n<0n?-n:n;const nDigits=abs.toString().length;const lDigits=nDigits.toString().length;if(n<0n){return`n${"#".repeat(lDigits-1)}${(10**lDigits-nDigits).toString().padStart(lDigits,"0")}:${(10n**BigInt(nDigits)+n).toString().padStart(nDigits,"0")}`}else{return`p${"~".repeat(lDigits-1)}${nDigits}:${n}`}};var rBigIntPayload=/([0-9]+)(:([0-9]+$|)|)/s;var decodeBigInt=encoded=>{const typePrefix=encoded.charAt(0);typePrefix==="p"||typePrefix==="n"||throwRedacted`Encoded bigint expected: ${encoded}`;const{index:lDigits,1:snDigits,2:tail,3:digits}=encoded.match(rBigIntPayload)||throwRedacted`Digit count expected: ${encoded}`;snDigits.length===lDigits||throwRedacted`Unary-prefixed decimal digit count expected: ${encoded}`;let nDigits=parseInt(snDigits,10);if(typePrefix==="n"){nDigits=10**lDigits-nDigits}tail.charAt(0)===":"||throwRedacted`Separator expected: ${encoded}`;digits.length===nDigits||throwRedacted`Fixed-length digit sequence expected: ${encoded}`;let n=BigInt(digits);if(typePrefix==="n"){n=-(10n**BigInt(nDigits)-n)}return n};var stringEscapes=Array(34).fill(void 0).map((_,cp)=>{switch(String.fromCharCode(cp)){case" ":return"!_";case"!":return"!|";default:return`!${String.fromCharCode(cp+33)}`}});stringEscapes["^".charCodeAt(0)]="_@";stringEscapes["_".charCodeAt(0)]="__";var encodeCompactStringSuffix=str=>str.replace(/[\0-!^_]/g,ch=>stringEscapes[ch.charCodeAt(0)]);var decodeCompactStringSuffix=encoded=>{return encoded.replace(/([\0-!_])(.|\n)?/g,(esc,prefix,suffix)=>{switch(esc){case"!_":return" ";case"!|":return"!";case"_@":return"^";case"__":return"_";default:{const ch=suffix;prefix==="!"&&suffix!==void 0&&ch>="!"&&ch<="@"||throwRedacted`invalid string escape: ${quote(esc)}`;return String.fromCharCode(ch.charCodeAt(0)-33)}}})};var encodeLegacyStringSuffix=str=>str;var decodeLegacyStringSuffix=encoded=>encoded;var encodeCompactArray=(array,encodePassable)=>{const chars=["^"];for(const element of array){const enc=encodePassable(element);chars.push(enc," ")}return chars.join("")};var decodeCompactArray=(encoded,decodePassable,skip=0)=>{const elements=[];let depth=0;let nextIndex=skip+1;let currentElementStart=skip+1;for(const{0:ch,index:i}of encoded.matchAll(/[\^ ]/g)){const index=i;if(index<=skip){if(index===skip){ch==="^"||throwRedacted`Encoded array expected: ${getSuffix(encoded,skip)}`}}else if(ch==="^"){depth+=1}else{if(index===nextIndex){depth-=1;depth>=0||throwRedacted`unexpected array element terminator: ${encoded.slice(skip,index+2)}`}if(depth===0){elements.push(decodePassable(encoded.slice(currentElementStart,index)));currentElementStart=index+1}}nextIndex=index+1}depth===0||throwRedacted`unterminated array: ${getSuffix(encoded,skip)}`;nextIndex===encoded.length||throwRedacted`unterminated array element: ${getSuffix(encoded,currentElementStart)}`;return harden(elements)};var encodeLegacyArray=(array,encodePassable)=>{const chars=["["];for(const element of array){const enc=encodePassable(element);for(const c of enc){if(c==="\0"||c==="
"){chars.push("
")}chars.push(c)}chars.push("\0")}return chars.join("")};var decodeLegacyArray=(encoded,decodePassable,skip=0)=>{const elements=[];const elemChars=[];let stillToSkip=skip+1;let inEscape=false;for(const c of encoded){if(stillToSkip>0){stillToSkip-=1;if(stillToSkip===0){c==="["||throwRedacted`Encoded array expected: ${getSuffix(encoded,skip)}`}}else if(inEscape){c==="\0"||c==="
"||throwRedacted`Unexpected character after u0001 escape: ${c}`;elemChars.push(c)}else if(c==="\0"){const encodedElement=elemChars.join("");elemChars.length=0;const element=decodePassable(encodedElement);elements.push(element)}else if(c==="
"){inEscape=true;continue}else{elemChars.push(c)}inEscape=false}!inEscape||throwRedacted`unexpected end of encoding ${getSuffix(encoded,skip)}`;elemChars.length===0||throwRedacted`encoding terminated early: ${getSuffix(encoded,skip)}`;return harden(elements)};var encodeByteArray=(byteArray,_encodePassable)=>{throwRedacted`encodePassable(byteArray) not yet implemented: ${byteArray}`;return""};var encodeRecord=(record,encodeArray,encodePassable)=>{const names=recordNames(record);const values5=recordValues(record,names);return`(${encodeArray(harden([names,values5]),encodePassable)}`};var decodeRecord=(encoded,decodeArray,decodePassable,skip=0)=>{assert(encoded.charAt(skip)==="(");const unzippedEntries=decodeArray(encoded,decodePassable,skip+1);unzippedEntries.length===2||throwRedacted`expected keys,values pair: ${getSuffix(encoded,skip)}`;const[keys2,vals]=unzippedEntries;passStyleOf(keys2)==="copyArray"&&passStyleOf(vals)==="copyArray"&&keys2.length===vals.length&&keys2.every(key=>typeof key==="string")||throwRedacted`not a valid record encoding: ${getSuffix(encoded,skip)}`;const mapEntries=keys2.map((key,i)=>[key,vals[i]]);const record=harden(fromEntries5(mapEntries));assertRecord(record,"decoded record");return record};var encodeTagged=(tagged,encodeArray,encodePassable)=>`:${encodeArray(harden([getTag(tagged),tagged.payload]),encodePassable)}`;var decodeTagged=(encoded,decodeArray,decodePassable,skip=0)=>{assert(encoded.charAt(skip)===":");const taggedPayload=decodeArray(encoded,decodePassable,skip+1);taggedPayload.length===2||throwRedacted`expected tag,payload pair: ${getSuffix(encoded,skip)}`;const[tag,payload]=taggedPayload;passStyleOf(tag)==="string"||throwRedacted`not a valid tagged encoding: ${getSuffix(encoded,skip)}`;return makeTagged(tag,payload)};var makeEncodeRemotable=(unsafeEncodeRemotable,verifyEncoding)=>{const encodeRemotable=(r,innerEncode)=>{const encoding=unsafeEncodeRemotable(r,innerEncode);typeof encoding==="string"&&encoding.charAt(0)==="r"||throwRedacted`Remotable encoding must start with "r": ${encoding}`;verifyEncoding(encoding,"Remotable");return encoding};return encodeRemotable};var makeEncodePromise=(unsafeEncodePromise,verifyEncoding)=>{const encodePromise=(p,innerEncode)=>{const encoding=unsafeEncodePromise(p,innerEncode);typeof encoding==="string"&&encoding.charAt(0)==="?"||throwRedacted`Promise encoding must start with "?": ${encoding}`;verifyEncoding(encoding,"Promise");return encoding};return encodePromise};var makeEncodeError=(unsafeEncodeError,verifyEncoding)=>{const encodeError=(err,innerEncode)=>{const encoding=unsafeEncodeError(err,innerEncode);typeof encoding==="string"&&encoding.charAt(0)==="!"||throwRedacted`Error encoding must start with "!": ${encoding}`;verifyEncoding(encoding,"Error");return encoding};return encodeError};var makeInnerEncode=(encodeStringSuffix,encodeArray,options)=>{const{encodeRemotable:unsafeEncodeRemotable,encodePromise:unsafeEncodePromise,encodeError:unsafeEncodeError,verifyEncoding=()=>{}}=options;const encodeRemotable=makeEncodeRemotable(unsafeEncodeRemotable,verifyEncoding);const encodePromise=makeEncodePromise(unsafeEncodePromise,verifyEncoding);const encodeError=makeEncodeError(unsafeEncodeError,verifyEncoding);const innerEncode=passable=>{if(isErrorLike(passable)){return encodeError(passable,innerEncode)}const passStyle=passStyleOf(passable);switch(passStyle){case"null":{return"v"}case"undefined":{return"z"}case"number":{return encodeBinary64(passable)}case"string":{return`s${encodeStringSuffix(passable)}`}case"boolean":{return`b${passable}`}case"bigint":{return encodeBigInt(passable)}case"remotable":{return encodeRemotable(passable,innerEncode)}case"error":{return encodeError(passable,innerEncode)}case"promise":{return encodePromise(passable,innerEncode)}case"symbol":{const name=nameForPassableSymbol(passable);assert.typeof(name,"string");return`y${encodeStringSuffix(name)}`}case"copyArray":{return encodeArray(passable,innerEncode)}case"byteArray":{return encodeByteArray(passable,innerEncode)}case"copyRecord":{return encodeRecord(passable,encodeArray,innerEncode)}case"tagged":{return encodeTagged(passable,encodeArray,innerEncode)}default:{throw throwRedacted`a ${quote(passStyle)} cannot be used as a collection passable`}}};return innerEncode};var liberalDecoders={decodeRemotable:(_encoding,_innerDecode)=>void 0,decodePromise:(_encoding,_innerDecode)=>void 0,decodeError:(_encoding,_innerDecode)=>void 0};var makeInnerDecode=(decodeStringSuffix,decodeArray,options)=>{const{decodeRemotable,decodePromise,decodeError}=options;const innerDecode=(encoded,skip=0)=>{switch(encoded.charAt(skip)){case"v":{return null}case"z":{return void 0}case"f":{return decodeBinary64(encoded,skip)}case"s":{return decodeStringSuffix(getSuffix(encoded,skip+1))}case"b":{const substring=getSuffix(encoded,skip+1);if(substring==="true"){return true}else if(substring==="false"){return false}throw throwRedacted`expected encoded boolean to be "btrue" or "bfalse": ${substring}`}case"n":case"p":{return decodeBigInt(getSuffix(encoded,skip))}case"r":{return decodeRemotable(getSuffix(encoded,skip),innerDecode)}case"?":{return decodePromise(getSuffix(encoded,skip),innerDecode)}case"!":{return decodeError(getSuffix(encoded,skip),innerDecode)}case"y":{const name=decodeStringSuffix(getSuffix(encoded,skip+1));return passableSymbolForName(name)}case"[":case"^":{return decodeArray(encoded,innerDecode,skip)}case"(":{return decodeRecord(encoded,decodeArray,innerDecode,skip)}case":":{return decodeTagged(encoded,decodeArray,innerDecode,skip)}default:{throw throwRedacted`invalid database key: ${getSuffix(encoded,skip)}`}}};return innerDecode};var makePassableKit=(options={})=>{const{encodeRemotable=(r,_)=>throwRedacted`remotable unexpected: ${r}`,encodePromise=(p,_)=>throwRedacted`promise unexpected: ${p}`,encodeError=(err,_)=>throwRedacted`error unexpected: ${err}`,format="legacyOrdered",decodeRemotable=(encoding,_)=>throwRedacted`remotable unexpected: ${encoding}`,decodePromise=(encoding,_)=>throwRedacted`promise unexpected: ${encoding}`,decodeError=(encoding,_)=>throwRedacted`error unexpected: ${encoding}`}=options;let encodePassable;const encodeOptions={encodeRemotable,encodePromise,encodeError,format};if(format==="compactOrdered"){const liberalDecode=makeInnerDecode(decodeCompactStringSuffix,decodeCompactArray,liberalDecoders);const verifyEncoding=(encoding,label)=>{!encoding.match(rC0)||throwRedacted`${bareOrQuote(label)} encoding must not contain a C0 control character: ${encoding}`;const decoded=decodeCompactArray(`^v ${encoding} v `,liberalDecode);isArray8(decoded)&&decoded.length===3&&decoded[0]===null&&decoded[2]===null||throwRedacted`${bareOrQuote(label)} encoding must be embeddable: ${encoding}`};const encodeCompact=makeInnerEncode(encodeCompactStringSuffix,encodeCompactArray,{...encodeOptions,verifyEncoding});encodePassable=passable=>`~${encodeCompact(passable)}`}else if(format==="legacyOrdered"){encodePassable=makeInnerEncode(encodeLegacyStringSuffix,encodeLegacyArray,encodeOptions)}else{throw throwRedacted`Unrecognized format: ${quote(format)}`}const decodeOptions={decodeRemotable,decodePromise,decodeError};const decodeCompact=makeInnerDecode(decodeCompactStringSuffix,decodeCompactArray,decodeOptions);const decodeLegacy=makeInnerDecode(decodeLegacyStringSuffix,decodeLegacyArray,decodeOptions);const decodePassable=encoded=>{if(encoded.charAt(0)==="~"){return decodeCompact(encoded,1)}return decodeLegacy(encoded)};return harden({encodePassable,decodePassable})};harden(makePassableKit);var makeEncodePassable=encodeOptions=>{const{encodePassable}=makePassableKit(encodeOptions);return encodePassable};harden(makeEncodePassable);var makeDecodePassable=decodeOptions=>{const{decodePassable}=makePassableKit(decodeOptions);return decodePassable};harden(makeDecodePassable);var isEncodedRemotable=encoded=>encoded.charAt(0)==="r";harden(isEncodedRemotable);var passStylePrefixes={error:"!",copyRecord:"(",tagged:":",promise:"?",copyArray:"[^",byteArray:"a",boolean:"b",number:"f",bigint:"np",remotable:"r",string:"s",null:"v",symbol:"y",undefined:"z"};Object.setPrototypeOf(passStylePrefixes,null);harden(passStylePrefixes);var{isNaN:NumberIsNaN}=Number;var{entries:entries6,fromEntries:fromEntries6,setPrototypeOf:setPrototypeOf2,is:is4}=Object;var ENDO_RANK_STRINGS=getEnvironmentOption("ENDO_RANK_STRINGS","utf16-code-unit-order",["unicode-code-point-order","error-if-order-choice-matters"]);var sameValueZero=(x,y)=>x===y||is4(x,y);var trivialComparator=(left,right)=>left<right?-1:left===right?0:1;harden(trivialComparator);var compareByCodePoints=(left,right)=>{const leftIter=left[Symbol.iterator]();const rightIter=right[Symbol.iterator]();for(;;){const{value:leftChar}=leftIter.next();const{value:rightChar}=rightIter.next();if(leftChar===void 0&&rightChar===void 0){return 0}else if(leftChar===void 0){return-1}else if(rightChar===void 0){return 1}const leftCodepoint=leftChar.codePointAt(0);const rightCodepoint=rightChar.codePointAt(0);if(leftCodepoint<rightCodepoint)return-1;if(leftCodepoint>rightCodepoint)return 1}};harden(compareByCodePoints);var compareNumerics=(left,right)=>{if(left<right)return-1;if(left>right)return 1;if(NumberIsNaN(left)===NumberIsNaN(right))return 0;if(NumberIsNaN(right))return-1;assert(NumberIsNaN(left));return 1};var passStyleRanks=fromEntries6(entries6(passStylePrefixes).sort(([_leftStyle,leftPrefixes],[_rightStyle,rightPrefixes])=>{return trivialComparator(leftPrefixes,rightPrefixes)}).map(([passStyle,prefixes],index)=>{prefixes===prefixes.split("").sort().join("")||throwRedacted`unsorted prefixes for passStyle ${quote(passStyle)}: ${quote(prefixes)}`;const cover=[prefixes.charAt(0),String.fromCharCode(prefixes.charCodeAt(prefixes.length-1)+1)];return[passStyle,{index,cover}]}));setPrototypeOf2(passStyleRanks,null);harden(passStyleRanks);var getPassStyleCover=passStyle=>passStyleRanks[passStyle].cover;harden(getPassStyleCover);var memoOfSorted=new WeakMap;var comparatorMirrorImages=new WeakMap;var makeComparatorKit=(compareRemotables=(_x,_y)=>NaN)=>{const comparator=(left,right)=>{if(sameValueZero(left,right)){return 0}const leftStyle=passStyleOf(left);const rightStyle=passStyleOf(right);if(leftStyle!==rightStyle){return compareNumerics(passStyleRanks[leftStyle].index,passStyleRanks[rightStyle].index)}switch(leftStyle){case"remotable":{return compareRemotables(left,right)}case"undefined":case"null":case"error":case"promise":{return 0}case"boolean":case"bigint":{return trivialComparator(left,right)}case"string":{switch(ENDO_RANK_STRINGS){case"utf16-code-unit-order":{return trivialComparator(left,right)}case"unicode-code-point-order":{return compareByCodePoints(left,right)}case"error-if-order-choice-matters":{const result1=trivialComparator(left,right);const result2=compareByCodePoints(left,right);result1===result2||throwRedacted`Comparisons differed: ${left} vs ${right}, ${quote(result1)} vs ${quote(result2)}`;return result1}default:{throw throwRedacted`Unexpected ENDO_RANK_STRINGS ${quote(ENDO_RANK_STRINGS)}`}}}case"symbol":{return comparator(nameForPassableSymbol(left),nameForPassableSymbol(right))}case"number":{return compareNumerics(left,right)}case"copyRecord":{const leftNames=recordNames(left);const rightNames=recordNames(right);const result=comparator(leftNames,rightNames);if(result!==0){return result}const leftValues=recordValues(left,leftNames);const rightValues=recordValues(right,rightNames);return comparator(leftValues,rightValues)}case"copyArray":{const len=Math.min(left.length,right.length);for(let i=0;i<len;i+=1){const result=comparator(left[i],right[i]);if(result!==0){return result}}return comparator(left.length,right.length)}case"byteArray":{const{byteLength:leftLen}=left;const{byteLength:rightLen}=right;if(leftLen<rightLen){return-1}if(leftLen>rightLen){return 1}const leftArray=Object.getPrototypeOf(left)===ArrayBuffer.prototype?new Uint8Array(left):new Uint8Array(left.slice(0));const rightArray=Object.getPrototypeOf(right)===ArrayBuffer.prototype?new Uint8Array(right):new Uint8Array(right.slice(0));for(let i=0;i<leftLen;i+=1){const leftByte=leftArray[i];const rightByte=rightArray[i];if(leftByte<rightByte){return-1}if(leftByte>rightByte){return 1}}return 0}case"tagged":{const labelComp=comparator(getTag(left),getTag(right));if(labelComp!==0){return labelComp}return comparator(left.payload,right.payload)}default:{throw throwRedacted`Unrecognized passStyle: ${quote(leftStyle)}`}}};const outerComparator=(x,y)=>comparator(x,y)||0;const antiComparator=(x,y)=>outerComparator(y,x);memoOfSorted.set(outerComparator,new WeakSet);memoOfSorted.set(antiComparator,new WeakSet);comparatorMirrorImages.set(outerComparator,antiComparator);comparatorMirrorImages.set(antiComparator,outerComparator);return harden({comparator:outerComparator,antiComparator})};var isRankSorted=(passables,compare)=>{const subMemoOfSorted=memoOfSorted.get(compare);assert(subMemoOfSorted!==void 0);if(subMemoOfSorted.has(passables)){return true}assert(passStyleOf(passables)==="copyArray");for(let i=1;i<passables.length;i+=1){if(compare(passables[i-1],passables[i])>=1){return false}}subMemoOfSorted.add(passables);return true};harden(isRankSorted);var assertRankSorted=(sorted,compare)=>isRankSorted(sorted,compare)||throwRedacted`Must be rank sorted: ${sorted} vs ${sortByRank(sorted,compare)}`;harden(assertRankSorted);var sortByRank=(passables,compare)=>{let unsorted;if(Array.isArray(passables)){harden(passables);if(isRankSorted(passables,compare)){return passables}unsorted=[...passables]}else{unsorted=Array.from(passables,harden)}const sorted=unsorted.sort(compare);if(compare(true,void 0)>0){let i=sorted.length-1;while(i>=0&&sorted[i]===void 0)i-=1;const n=sorted.length-i-1;if(n>0&&n<sorted.length){sorted.copyWithin(n,0);sorted.fill(void 0,0,n)}}harden(sorted);const subMemoOfSorted=memoOfSorted.get(compare);assert(subMemoOfSorted!==void 0);subMemoOfSorted.add(sorted);return sorted};harden(sortByRank);var rankSearch=(sorted,compare,key,bias="leftMost")=>{assertRankSorted(sorted,compare);let left=0;let right=sorted.length;while(left<right){const m=Math.floor((left+right)/2);const comp=compare(sorted[m],key);if(comp<=-1||comp===0&&bias==="rightMost"){left=m+1}else{assert(comp>=1||comp===0&&bias==="leftMost");right=m}}return bias==="leftMost"?left:right-1};var getIndexCover=(sorted,compare,[leftKey,rightKey])=>{assertRankSorted(sorted,compare);const leftIndex=rankSearch(sorted,compare,leftKey,"leftMost");const rightIndex=rankSearch(sorted,compare,rightKey,"rightMost");return[leftIndex,rightIndex]};harden(getIndexCover);var FullRankCover=harden(["","{"]);var coveredEntries=(sorted,[leftIndex,rightIndex])=>{const iterable=harden({[Symbol.iterator]:()=>{let i=leftIndex;return harden({next:()=>{if(i<=rightIndex){const element=sorted[i];i+=1;return harden({value:[i,element],done:false})}else{return harden({value:void 0,done:true})}}})}});return iterable};harden(coveredEntries);var maxRank=(compare,a,b)=>compare(a,b)>=0?a:b;var minRank=(compare,a,b)=>compare(a,b)<=0?a:b;var unionRankCovers=(compare,covers)=>{const unionRankCoverPair=([leftA,rightA],[leftB,rightB])=>[minRank(compare,leftA,leftB),maxRank(compare,rightA,rightB)];return covers.reduce(unionRankCoverPair,["{",""])};harden(unionRankCovers);var intersectRankCovers=(compare,covers)=>{const intersectRankCoverPair=([leftA,rightA],[leftB,rightB])=>[maxRank(compare,leftA,leftB),minRank(compare,rightA,rightB)];return covers.reduce(intersectRankCoverPair,["","{"])};var{comparator:compareRank,antiComparator:compareAntiRank}=makeComparatorKit();var makeFullOrderComparatorKit=(longLived=false)=>{let numSeen=0;const MapConstructor=longLived?WeakMap:Map;const seen=new MapConstructor;const tag=r=>{if(seen.has(r)){return seen.get(r)}numSeen+=1;seen.set(r,numSeen);return numSeen};const compareRemotables=(x,y)=>compareRank(tag(x),tag(y));return makeComparatorKit(compareRemotables)};harden(makeFullOrderComparatorKit);var checkNoDuplicates=(elements,fullCompare,check)=>{fullCompare=fullCompare||makeFullOrderComparatorKit().antiComparator;elements=sortByRank(elements,fullCompare);const{length}=elements;for(let i=1;i<length;i+=1){const k0=elements[i-1];const k1=elements[i];if(fullCompare(k0,k1)===0){return check(false,redacted`value has duplicate keys: ${k0}`)}}return true};var assertNoDuplicates=(elements,fullCompare=void 0)=>{checkNoDuplicates(elements,fullCompare,assertChecker)};var checkElements=(elements,check)=>{if(passStyleOf(elements)!=="copyArray"){return check(false,redacted`The keys of a copySet or copyMap must be a copyArray: ${elements}`)}if(!isRankSorted(elements,compareAntiRank)){return check(false,redacted`The keys of a copySet or copyMap must be sorted in reverse rank order: ${elements}`)}return checkNoDuplicates(elements,void 0,check)};harden(checkElements);var assertElements=elements=>{checkElements(elements,assertChecker)};harden(assertElements);var coerceToElements=elementsList=>{const elements=sortByRank(elementsList,compareAntiRank);assertElements(elements);return elements};harden(coerceToElements);var makeSetOfElements=elementIter=>makeTagged("copySet",coerceToElements(elementIter));harden(makeSetOfElements);var checkNoDuplicateKeys=(bagEntries,fullCompare,check)=>{fullCompare=fullCompare||makeFullOrderComparatorKit().antiComparator;bagEntries=sortByRank(bagEntries,fullCompare);const{length}=bagEntries;for(let i=1;i<length;i+=1){const k0=bagEntries[i-1][0];const k1=bagEntries[i][0];if(fullCompare(k0,k1)===0){return check(false,redacted`value has duplicate keys: ${k0}`)}}return true};var assertNoDuplicateKeys=(bagEntries,fullCompare=void 0)=>{checkNoDuplicateKeys(bagEntries,fullCompare,assertChecker)};var checkBagEntries=(bagEntries,check)=>{if(passStyleOf(bagEntries)!=="copyArray"){return check(false,redacted`The entries of a copyBag must be a copyArray: ${bagEntries}`)}if(!isRankSorted(bagEntries,compareAntiRank)){return check(false,redacted`The entries of a copyBag must be sorted in reverse rank order: ${bagEntries}`)}for(const entry of bagEntries){if(passStyleOf(entry)!=="copyArray"||entry.length!==2||typeof entry[1]!=="bigint"){return check(false,redacted`Each entry of a copyBag must be pair of a key and a bigint representing a count: ${entry}`)}if(entry[1]<1){return check(false,redacted`Each entry of a copyBag must have a positive count: ${entry}`)}}return checkNoDuplicateKeys(bagEntries,void 0,check)};harden(checkBagEntries);var assertBagEntries=bagEntries=>{checkBagEntries(bagEntries,assertChecker)};harden(assertBagEntries);var coerceToBagEntries=bagEntriesList=>{const bagEntries=sortByRank(bagEntriesList,compareAntiRank);assertBagEntries(bagEntries);return bagEntries};harden(coerceToBagEntries);var makeBagOfEntries=bagEntryIter=>makeTagged("copyBag",coerceToBagEntries(bagEntryIter));harden(makeBagOfEntries);var{ownKeys:ownKeys16}=Reflect;var checkScalarKey=(val,check)=>{if(isAtom(val)){return true}const passStyle=passStyleOf(val);if(passStyle==="remotable"){return true}return check(false,redacted`A ${quote(passStyle)} cannot be a scalar key: ${val}`)};var isScalarKey=val=>checkScalarKey(val,identChecker);harden(isScalarKey);var assertScalarKey=val=>{checkScalarKey(val,assertChecker)};harden(assertScalarKey);var keyMemo=new WeakSet;var checkKey=(val,check)=>{if(isAtom(val)){return true}if(keyMemo.has(val)){return true}const result=checkKeyInternal(val,check);if(result){keyMemo.add(val)}return result};harden(checkKey);var isKey=val=>checkKey(val,identChecker);harden(isKey);var assertKey=val=>{checkKey(val,assertChecker)};harden(assertKey);var copySetMemo=new WeakSet;var checkCopySet=(s,check)=>{if(copySetMemo.has(s)){return true}const result=(passStyleOf(s)==="tagged"&&getTag(s)==="copySet"||check(false,redacted`Not a copySet: ${s}`))&&checkElements(s.payload,check)&&checkKey(s.payload,check);if(result){copySetMemo.add(s)}return result};harden(checkCopySet);var isCopySet=s=>checkCopySet(s,identChecker);harden(isCopySet);var assertCopySet=s=>{checkCopySet(s,assertChecker)};harden(assertCopySet);var getCopySetKeys=s=>{assertCopySet(s);return s.payload};harden(getCopySetKeys);var everyCopySetKey=(s,fn)=>getCopySetKeys(s).every((key,index)=>fn(key,index));harden(everyCopySetKey);var makeCopySet=elementIter=>{const result=makeSetOfElements(elementIter);assertCopySet(result);return result};harden(makeCopySet);var copyBagMemo=new WeakSet;var checkCopyBag=(b,check)=>{if(copyBagMemo.has(b)){return true}const result=(passStyleOf(b)==="tagged"&&getTag(b)==="copyBag"||check(false,redacted`Not a copyBag: ${b}`))&&checkBagEntries(b.payload,check)&&checkKey(b.payload,check);if(result){copyBagMemo.add(b)}return result};harden(checkCopyBag);var isCopyBag=b=>checkCopyBag(b,identChecker);harden(isCopyBag);var assertCopyBag=b=>{checkCopyBag(b,assertChecker)};harden(assertCopyBag);var getCopyBagEntries=b=>{assertCopyBag(b);return b.payload};harden(getCopyBagEntries);var everyCopyBagEntry=(b,fn)=>getCopyBagEntries(b).every((entry,index)=>fn(entry,index));harden(everyCopyBagEntry);var makeCopyBag=bagEntryIter=>{const result=makeBagOfEntries(bagEntryIter);assertCopyBag(result);return result};harden(makeCopyBag);var makeCopyBagFromElements=elementIter=>{const fullCompare=makeFullOrderComparatorKit().antiComparator;const sorted=sortByRank(elementIter,fullCompare);const entries8=[];for(let i=0;i<sorted.length;){const k=sorted[i];let j=i+1;while(j<sorted.length&&fullCompare(k,sorted[j])===0){j+=1}entries8.push([k,BigInt(j-i)]);i=j}return makeCopyBag(entries8)};harden(makeCopyBagFromElements);var copyMapMemo=new WeakSet;var checkCopyMap=(m,check)=>{if(copyMapMemo.has(m)){return true}if(!(passStyleOf(m)==="tagged"&&getTag(m)==="copyMap")){return check(false,redacted`Not a copyMap: ${m}`)}const{payload}=m;if(passStyleOf(payload)!=="copyRecord"){return check(false,redacted`A copyMap's payload must be a record: ${m}`)}const{keys:keys2,values:values5,...rest}=payload;const result=(ownKeys16(rest).length===0||check(false,redacted`A copyMap's payload must only have .keys and .values: ${m}`))&&checkElements(keys2,check)&&checkKey(keys2,check)&&(passStyleOf(values5)==="copyArray"||check(false,redacted`A copyMap's .values must be a copyArray: ${m}`))&&(keys2.length===values5.length||check(false,redacted`A copyMap must have the same number of keys and values: ${m}`));if(result){copyMapMemo.add(m)}return result};harden(checkCopyMap);var isCopyMap=m=>checkCopyMap(m,identChecker);harden(isCopyMap);var assertCopyMap=m=>{checkCopyMap(m,assertChecker)};harden(assertCopyMap);var getCopyMapKeys=m=>{assertCopyMap(m);return m.payload.keys};harden(getCopyMapKeys);var getCopyMapValues=m=>{assertCopyMap(m);return m.payload.values};harden(getCopyMapValues);var getCopyMapEntryArray=m=>{assertCopyMap(m);const{payload:{keys:keys2,values:values5}}=m;return harden(keys2.map((key,i)=>[key,values5[i]]))};harden(getCopyMapEntryArray);var getCopyMapEntries=m=>{assertCopyMap(m);const{payload:{keys:keys2,values:values5}}=m;const{length}=keys2;return Far("CopyMap entries iterable",{[Symbol.iterator]:()=>{let i=0;return Far("CopyMap entries iterator",{next:()=>{let result;if(i<length){result=harden({done:false,value:[keys2[i],values5[i]]});i+=1;return result}else{result=harden({done:true,value:void 0})}return result}})}})};harden(getCopyMapEntries);var everyCopyMapKey=(m,fn)=>getCopyMapKeys(m).every((key,index)=>fn(key,index));harden(everyCopyMapKey);var everyCopyMapValue=(m,fn)=>getCopyMapValues(m).every((value,index)=>fn(value,index));harden(everyCopyMapValue);var copyMapKeySet=m=>makeTagged("copySet",m.payload.keys);harden(copyMapKeySet);var makeCopyMap=entries8=>{const sortedEntries=sortByRank(entries8,compareAntiRank);const keys2=sortedEntries.map(([k,_v])=>k);const values5=sortedEntries.map(([_k,v])=>v);const result=makeTagged("copyMap",{keys:keys2,values:values5});assertCopyMap(result);return result};harden(makeCopyMap);var checkKeyInternal=(val,check)=>{const checkIt=child=>checkKey(child,check);const passStyle=passStyleOf(val);switch(passStyle){case"remotable":{return true}case"copyRecord":{return Object.values(val).every(checkIt)}case"copyArray":{return val.every(checkIt)}case"tagged":{const tag=getTag(val);switch(tag){case"copySet":{return checkCopySet(val,check)}case"copyBag":{return checkCopyBag(val,check)}case"copyMap":{return checkCopyMap(val,check)&&everyCopyMapValue(val,checkIt)}default:{return check!==identChecker&&check(false,redacted`A passable tagged ${quote(tag)} is not a key: ${val}`)}}}case"error":case"promise":{return check(false,redacted`A ${quote(passStyle)} cannot be a key`)}default:{throw throwRedacted`unexpected passStyle ${quote(passStyle)}: ${val}`}}};var makeIterator=next=>{const iter=harden({[Symbol.iterator]:()=>iter,next});return iter};harden(makeIterator);var makeArrayIterator=arr=>{const{length}=arr;let i=0;return makeIterator(()=>{let value;if(i<length){value=arr[i];i+=1;return harden({done:false,value})}return harden({done:true,value})})};harden(makeArrayIterator);var generateFullSortedEntries=(entries8,rankCompare,fullCompare)=>{assertRankSorted(entries8,rankCompare);const{length}=entries8;let i=0;let sameRankIterator;return makeIterator(()=>{if(sameRankIterator){const result=sameRankIterator.next();if(!result.done){return result}sameRankIterator=void 0}if(i<length){const entry=entries8[i];let j=i+1;while(j<length&&rankCompare(entry[0],entries8[j][0])===0){j+=1}if(j===i+1){i=j;return harden({done:false,value:entry})}const ties=entries8.slice(i,j);i=j;const sortedTies=sortByRank(ties,fullCompare);for(let k=1;k<sortedTies.length;k+=1){const[key0]=sortedTies[k-1];const[key1]=sortedTies[k];Math.sign(fullCompare(key0,key1))||throwRedacted`Duplicate entry key: ${key0}`}sameRankIterator=makeArrayIterator(sortedTies);return sameRankIterator.next()}return harden({done:true,value:void 0})})};harden(generateFullSortedEntries);var generateCollectionPairEntries=(c1,c2,getEntries,absentValue)=>{const e1=getEntries(c1);const e2=getEntries(c2);const fullCompare=makeFullOrderComparatorKit().antiComparator;const x=generateFullSortedEntries(e1,compareAntiRank,fullCompare);const y=generateFullSortedEntries(e2,compareAntiRank,fullCompare);let xDone;let xKey;let xValue;let yDone;let yKey;let yValue;const nonEntry=[void 0,void 0];const nextX=()=>{!xDone||throwRedacted`Internal: nextX must not be called once done`;const result=xValue;({done:xDone,value:[xKey,xValue]=nonEntry}=x.next());return result};nextX();const nextY=()=>{!yDone||throwRedacted`Internal: nextY must not be called once done`;const result=yValue;({done:yDone,value:[yKey,yValue]=nonEntry}=y.next());return result};nextY();return makeIterator(()=>{let done=false;let value;if(xDone&&yDone){done=true;value=[void 0,absentValue,absentValue]}else if(xDone){value=[yKey,absentValue,nextY()]}else if(yDone){value=[xKey,nextX(),absentValue]}else{const comp=fullCompare(xKey,yKey);if(comp===0){value=[xKey,nextX(),nextY()]}else if(comp<0){value=[xKey,nextX(),absentValue]}else if(comp>0){value=[yKey,absentValue,nextY()]}else{throw throwRedacted`Unexpected key comparison ${quote(comp)} for ${xKey} vs ${yKey}`}}return harden({done,value})})};harden(generateCollectionPairEntries);var makeCompareCollection=(getEntries,absentValue,compareValues2)=>harden((left,right)=>{const merged=generateCollectionPairEntries(left,right,getEntries,absentValue);let leftIsBigger=false;let rightIsBigger=false;for(const[_key,leftValue,rightValue]of merged){const comp=compareValues2(leftValue,rightValue);if(comp===0){continue}else if(comp<0){rightIsBigger=true}else if(comp>0){leftIsBigger=true}else{Number.isNaN(comp)||throwRedacted`Unexpected value comparison ${quote(comp)} for ${leftValue} vs ${rightValue}`;return NaN}if(leftIsBigger&&rightIsBigger){return NaN}}return leftIsBigger?1:rightIsBigger?-1:0});harden(makeCompareCollection);var setCompare=makeCompareCollection((s=>harden(getCopySetKeys(s).map(key=>[key,1]))),0,compareNumerics);harden(setCompare);var bagCompare=makeCompareCollection(getCopyBagEntries,0n,compareNumerics);harden(bagCompare);var ABSENT=Symbol("absent");var _mapCompare=makeCompareCollection(getCopyMapEntryArray,ABSENT,(leftValue,rightValue)=>{if(leftValue===ABSENT&&rightValue===ABSENT){throw throwRedacted`Internal: Unexpected absent entry pair`}else if(leftValue===ABSENT){return-1}else if(rightValue===ABSENT){return 1}else{return compareKeys(leftValue,rightValue)}});harden(_mapCompare);var compareKeys=(left,right)=>{assertKey(left);assertKey(right);const leftStyle=passStyleOf(left);const rightStyle=passStyleOf(right);if(leftStyle!==rightStyle){return NaN}switch(leftStyle){case"undefined":case"null":case"boolean":case"bigint":case"string":case"byteArray":case"symbol":{return compareRank(left,right)}case"number":{const rankComp=compareRank(left,right);if(rankComp===0){return 0}if(Number.isNaN(left)||Number.isNaN(right)){assert(!Number.isNaN(left)||!Number.isNaN(right));return NaN}return rankComp}case"remotable":{if(left===right){return 0}return NaN}case"copyArray":{const len=Math.min(left.length,right.length);for(let i=0;i<len;i+=1){const result=compareKeys(left[i],right[i]);if(result!==0){return result}}return compareRank(left.length,right.length)}case"copyRecord":{const leftNames=recordNames(left);const rightNames=recordNames(right);if(!keyEQ(leftNames,rightNames)){return NaN}const leftValues=recordValues(left,leftNames);const rightValues=recordValues(right,rightNames);let result=0;for(let i=0;i<leftValues.length;i+=1){const comp=compareKeys(leftValues[i],rightValues[i]);if(Number.isNaN(comp)){return NaN}if(result!==comp&&comp!==0){if(result===0){result=comp}else{assert(result===-1&&comp===1||result===1&&comp===-1);return NaN}}}return result}case"tagged":{const leftTag=getTag(left);const rightTag=getTag(right);if(leftTag!==rightTag){return NaN}switch(leftTag){case"copySet":{return setCompare(left,right)}case"copyBag":{return bagCompare(left,right)}case"copyMap":{throw throwRedacted`Map comparison not yet implemented: ${left} vs ${right}`}default:{throw throwRedacted`unexpected tag ${quote(leftTag)}: ${left}`}}}default:{throw throwRedacted`unexpected passStyle ${quote(leftStyle)}: ${left}`}}};harden(compareKeys);var keyLT=(left,right)=>compareKeys(left,right)<0;harden(keyLT);var keyLTE=(left,right)=>compareKeys(left,right)<=0;harden(keyLTE);var keyEQ=(left,right)=>compareKeys(left,right)===0;harden(keyEQ);var keyGTE=(left,right)=>compareKeys(left,right)>=0;harden(keyGTE);var keyGT=(left,right)=>compareKeys(left,right)>0;harden(keyGT);var windowResort=(elements,rankCompare,fullCompare)=>{assertRankSorted(elements,rankCompare);const{length}=elements;let i=0;let optInnerIterator;return harden({[Symbol.iterator]:()=>harden({next:()=>{if(optInnerIterator){const result=optInnerIterator.next();if(result.done){optInnerIterator=void 0}else{return result}}if(i<length){const value=elements[i];let j=i+1;while(j<length&&rankCompare(value,elements[j])===0){j+=1}if(j===i+1){i=j;return harden({done:false,value})}const similarRun=elements.slice(i,j);i=j;const resorted=sortByRank(similarRun,fullCompare);assertNoDuplicates(resorted,fullCompare);optInnerIterator=resorted[Symbol.iterator]();return optInnerIterator.next()}else{return harden({done:true,value:null})}}})})};var merge=(xelements,yelements)=>{const fullCompare=makeFullOrderComparatorKit().antiComparator;const xs=windowResort(xelements,compareAntiRank,fullCompare);const ys=windowResort(yelements,compareAntiRank,fullCompare);return harden({[Symbol.iterator]:()=>{let x;let xDone;let y;let yDone;const xi=xs[Symbol.iterator]();const nextX=()=>{!xDone||throwRedacted`Internal: nextX should not be called once done`;({done:xDone,value:x}=xi.next())};nextX();const yi=ys[Symbol.iterator]();const nextY=()=>{!yDone||throwRedacted`Internal: nextY should not be called once done`;({done:yDone,value:y}=yi.next())};nextY();return harden({next:()=>{let done=false;let value;if(xDone&&yDone){done=true;value=[null,0n,0n]}else if(xDone){value=[y,0n,1n];nextY()}else if(yDone){value=[x,1n,0n];nextX()}else{const comp=fullCompare(x,y);if(comp===0){value=[x,1n,1n];nextX();nextY()}else if(comp<0){value=[x,1n,0n];nextX()}else{comp>0||throwRedacted`Internal: Unexpected comp ${quote(comp)}`;value=[y,0n,1n];nextY()}}return harden({done,value})}})}})};harden(merge);var iterIsSuperset=xyi=>{for(const[_m,xc,_yc]of xyi){if(xc===0n){return false}}return true};var iterIsDisjoint=xyi=>{for(const[_m,xc,yc]of xyi){if(xc>=1n&&yc>=1n){return false}}return true};var iterCompare=xyi=>{let loneY=false;let loneX=false;for(const[_m,xc,yc]of xyi){if(xc===0n){loneY=true}if(yc===0n){loneX=true}if(loneX&&loneY){return NaN}}if(loneX){return 1}else if(loneY){return-1}else{!loneX&&!loneY||throwRedacted`Internal: Unexpected lone pair ${quote([loneX,loneY])}`;return 0}};var iterUnion=xyi=>{const result=[];for(const[m,xc,yc]of xyi){if(xc>=0n){result.push(m)}else{yc>=0n||throwRedacted`Internal: Unexpected count ${quote(yc)}`;result.push(m)}}return result};var iterDisjointUnion=xyi=>{const result=[];for(const[m,xc,yc]of xyi){xc===0n||yc===0n||throwRedacted`Sets must not have common elements: ${m}`;if(xc>=1n){result.push(m)}else{yc>=1n||throwRedacted`Internal: Unexpected count ${quote(yc)}`;result.push(m)}}return result};var iterIntersection=xyi=>{const result=[];for(const[m,xc,yc]of xyi){if(xc>=1n&&yc>=1n){result.push(m)}}return result};var iterDisjointSubtract=xyi=>{const result=[];for(const[m,xc,yc]of xyi){xc>=1n||throwRedacted`right element ${m} was not in left`;if(yc===0n){result.push(m)}}return result};var mergeify=iterOp=>(xelements,yelements)=>iterOp(merge(xelements,yelements));var elementsIsSuperset=mergeify(iterIsSuperset);var elementsIsDisjoint=mergeify(iterIsDisjoint);var elementsCompare=mergeify(iterCompare);var elementsUnion=mergeify(iterUnion);var elementsDisjointUnion=mergeify(iterDisjointUnion);var elementsIntersection=mergeify(iterIntersection);var elementsDisjointSubtract=mergeify(iterDisjointSubtract);var rawSetify=elementsOp=>(xset,yset)=>elementsOp(xset.payload,yset.payload);var setify=elementsOp=>(xset,yset)=>makeSetOfElements(elementsOp(xset.payload,yset.payload));var setIsSuperset=rawSetify(elementsIsSuperset);var setIsDisjoint=rawSetify(elementsIsDisjoint);var setUnion=setify(elementsUnion);var setDisjointUnion=setify(elementsDisjointUnion);var setIntersection=setify(elementsIntersection);var setDisjointSubtract=setify(elementsDisjointSubtract);var bagWindowResort=(bagEntries,rankCompare,fullCompare)=>{assertRankSorted(bagEntries,rankCompare);const{length}=bagEntries;let i=0;let optInnerIterator;return harden({[Symbol.iterator]:()=>harden({next:()=>{if(optInnerIterator){const result=optInnerIterator.next();if(result.done){optInnerIterator=void 0}else{return result}}if(i<length){const entry=bagEntries[i];let j=i+1;while(j<length&&rankCompare(entry[0],bagEntries[j][0])===0){j+=1}if(j===i+1){i=j;return harden({done:false,value:entry})}const similarRun=bagEntries.slice(i,j);i=j;const resorted=sortByRank(similarRun,fullCompare);assertNoDuplicateKeys(resorted,fullCompare);optInnerIterator=resorted[Symbol.iterator]();return optInnerIterator.next()}else{return harden({done:true,value:[null,0n]})}}})})};var merge2=(xbagEntries,ybagEntries)=>{const fullCompare=makeFullOrderComparatorKit().antiComparator;const xs=bagWindowResort(xbagEntries,compareAntiRank,fullCompare);const ys=bagWindowResort(ybagEntries,compareAntiRank,fullCompare);return harden({[Symbol.iterator]:()=>{let x;let xc;let xDone;let y;let yc;let yDone;const xi=xs[Symbol.iterator]();const nextX=()=>{!xDone||throwRedacted`Internal: nextX should not be called once done`;({done:xDone,value:[x,xc]}=xi.next())};nextX();const yi=ys[Symbol.iterator]();const nextY=()=>{!yDone||throwRedacted`Internal: nextY should not be called once done`;({done:yDone,value:[y,yc]}=yi.next())};nextY();return harden({next:()=>{let done=false;let value;if(xDone&&yDone){done=true;value=[null,0n,0n]}else if(xDone){value=[y,0n,yc];nextY()}else if(yDone){value=[x,xc,0n];nextX()}else{const comp=fullCompare(x,y);if(comp===0){value=[x,xc,yc];nextX();nextY()}else if(comp<0){value=[x,xc,0n];nextX()}else{comp>0||throwRedacted`Internal: Unexpected comp ${quote(comp)}`;value=[y,0n,yc];nextY()}}return harden({done,value})}})}})};harden(merge2);var bagIterIsSuperbag=xyi=>{for(const[_m,xc,yc]of xyi){if(xc<yc){return false}}return true};var bagIterIsDisjoint=xyi=>{for(const[_m,xc,yc]of xyi){if(xc>=1n&&yc>=1n){return false}}return true};var bagIterUnion=xyi=>{const result=[];for(const[m,xc,yc]of xyi){result.push([m,xc+yc])}return result};var bagIterIntersection=xyi=>{const result=[];for(const[m,xc,yc]of xyi){const mc=xc<=yc?xc:yc;result.push([m,mc])}return result};var bagIterDisjointSubtract=xyi=>{const result=[];for(const[m,xc,yc]of xyi){const mc=xc-yc;mc>=0n||throwRedacted`right element ${m} was not in left`;if(mc>=1n){result.push([m,mc])}}return result};var mergeify2=bagIterOp=>(xbagEntries,ybagEntries)=>bagIterOp(merge2(xbagEntries,ybagEntries));var bagEntriesIsSuperbag=mergeify2(bagIterIsSuperbag);var bagEntriesIsDisjoint=mergeify2(bagIterIsDisjoint);var bagEntriesUnion=mergeify2(bagIterUnion);var bagEntriesIntersection=mergeify2(bagIterIntersection);var bagEntriesDisjointSubtract=mergeify2(bagIterDisjointSubtract);var rawBagify=bagEntriesOp=>(xbag,ybag)=>bagEntriesOp(xbag.payload,ybag.payload);var bagify=bagEntriesOp=>(xbag,ybag)=>makeBagOfEntries(bagEntriesOp(xbag.payload,ybag.payload));var bagIsSuperbag=rawBagify(bagEntriesIsSuperbag);var bagIsDisjoint=rawBagify(bagEntriesIsDisjoint);var bagUnion=bagify(bagEntriesUnion);var bagIntersection=bagify(bagEntriesIntersection);var bagDisjointSubtract=bagify(bagEntriesDisjointSubtract);var throwLabeled=(innerErr,label,errConstructor=void 0,options=void 0)=>{if(typeof label==="number"){label=`[${label}]`}const outerErr=makeError(`${label}: ${innerErr.message}`,errConstructor,options);note(outerErr,redacted`Caused by ${innerErr}`);throw outerErr};harden(throwLabeled);var applyLabelingError=(func,args,label=void 0)=>{if(label===void 0){return func(...args)}let result;try{result=func(...args)}catch(err){throwLabeled(err,label)}if(isPromise(result)){return E.when(result,void 0,reason=>throwLabeled(reason,label))}else{return result}};harden(applyLabelingError);var{fromEntries:fromEntries7}=Object;var{ownKeys:ownKeys17}=Reflect;var fromUniqueEntries=allEntries=>{const entriesArray=[...allEntries];const result=harden(fromEntries7(entriesArray));if(ownKeys17(result).length===entriesArray.length){return result}const names=new Set;for(const[name,_]of entriesArray){if(names.has(name)){throwRedacted`collision on property name ${quote(name)}: ${entriesArray}`}names.add(name)}throw throwRedacted`internal: failed to create object from unique entries`};harden(fromUniqueEntries);var listDifference=(leftList,rightList)=>{const rightSet=new Set(rightList);return leftList.filter(element=>!rightSet.has(element))};harden(listDifference);var{entries:entries7,values:values2,hasOwn:hasOwn9}=Object;var{ownKeys:ownKeys18}=Reflect;var patternMemo=new WeakSet;var MM;var defaultLimits=harden({decimalDigitsLimit:100,stringLengthLimit:1e5,symbolNameLengthLimit:100,numPropertiesLimit:80,propertyNameLengthLimit:100,arrayLengthLimit:1e4,byteLengthLimit:1e5,numSetElementsLimit:1e4,numUniqueBagElementsLimit:1e4,numMapEntriesLimit:5e3});var limit=(limits={})=>harden({__proto__:defaultLimits,...limits});var checkIsWellFormedWithLimit=(payload,mainPayloadShape,check,label)=>{assert(Array.isArray(mainPayloadShape));if(!Array.isArray(payload)){return check(false,redacted`${quote(label)} payload must be an array: ${payload}`)}const mainLength=mainPayloadShape.length;if(!(payload.length===mainLength||payload.length===mainLength+1)){return check(false,redacted`${quote(label)} payload unexpected size: ${payload}`)}const limits=payload[mainLength];payload=harden(payload.slice(0,mainLength));if(!checkMatches(payload,mainPayloadShape,check,label)){return false}if(limits===void 0){return true}return(passStyleOf(limits)==="copyRecord"||check(false,redacted`Limits must be a record: ${quote(limits)}`))&&entries7(limits).every(([key,value])=>passStyleOf(value)==="number"||check(false,redacted`Value of limit ${quote(key)} but be a number: ${quote(value)}`))};var checkDecimalDigitsLimit=(specimen,decimalDigitsLimit,check)=>{if(Math.floor(Math.log10(Math.abs(Number(specimen))))+1<=decimalDigitsLimit){return true}return check(false,redacted`bigint ${specimen} must not have more than ${decimalDigitsLimit} digits`)};var makePatternKit=()=>{const maybeMatchHelper=tag=>HelpersByMatchTag[tag];const maybePayloadShape=tag=>GuardPayloadShapes[tag];const singletonKinds=new Map([["null",null],["undefined",void 0]]);const tagMemo=new WeakMap;const checkTagged=(tagged,tag,check)=>{const matchHelper=maybeMatchHelper(tag);if(matchHelper){return matchHelper.checkIsWellFormed(tagged.payload,check)}else{const payloadShape=maybePayloadShape(tag);if(payloadShape!==void 0){return checkMatches2(tagged.payload,payloadShape,check,tag)}}switch(tag){case"copySet":{return checkCopySet(tagged,check)}case"copyBag":{return checkCopyBag(tagged,check)}case"copyMap":{return checkCopyMap(tagged,check)}default:{return check(false,redacted`cannot check unrecognized tag ${quote(tag)}: ${tagged}`)}}};const kindOf2=(specimen,check=identChecker)=>{const passStyle=passStyleOf(specimen);if(passStyle!=="tagged"){return passStyle}if(tagMemo.has(specimen)){return tagMemo.get(specimen)}const tag=getTag(specimen);if(checkTagged(specimen,tag,check)){tagMemo.set(specimen,tag);return tag}if(check!==identChecker){check(false,redacted`cannot check unrecognized tag ${quote(tag)}`)}return void 0};harden(kindOf2);const checkKind=(specimen,kind2,check)=>{if(singletonKinds.has(kind2)){return checkAsKeyPatt(specimen,singletonKinds.get(kind2),check)}const realKind=kindOf2(specimen,check);if(kind2===realKind){return true}if(check!==identChecker){check(false,redacted`${bareOrQuote(realKind)} ${specimen} - Must be a ${bareOrQuote(kind2)}`)}return false};const isKind=(specimen,kind2)=>checkKind(specimen,kind2,identChecker);const isUndefinedPatt=patt=>patt===void 0||isKind(patt,"match:kind")&&patt.payload==="undefined";const checkAsKeyPatt=(specimen,keyAsPattern,check)=>{if(isKey(specimen)&&keyEQ(specimen,keyAsPattern)){return true}return check!==identChecker&&check(false,redacted`${specimen} - Must be: ${keyAsPattern}`)};const checkPattern=(patt,check)=>{if(isKey(patt)){return true}if(patternMemo.has(patt)){return true}const result=checkPatternInternal(patt,check);if(result){patternMemo.add(patt)}return result};const checkPatternInternal=(patt,check)=>{const checkIt=child=>checkPattern(child,check);const kind2=kindOf2(patt,check);switch(kind2){case void 0:{return false}case"copyRecord":{return values2(patt).every(checkIt)}case"copyArray":{return patt.every(checkIt)}case"copyMap":{return checkPattern(patt.values,check)}case"error":case"promise":{return check(false,redacted`A ${quote(kind2)} cannot be a pattern`)}default:{if(maybeMatchHelper(kind2)!==void 0){return true}return check(false,redacted`A passable of kind ${quote(kind2)} is not a pattern: ${patt}`)}}};const isPattern2=patt=>checkPattern(patt,identChecker);const assertPattern2=patt=>{checkPattern(patt,assertChecker)};const checkMatches2=(specimen,pattern,check,label=void 0)=>applyLabelingError(checkMatchesInternal,[specimen,pattern,check],label);const checkMatchesInternal=(specimen,patt,check)=>{const patternKind=kindOf2(patt,check);const specimenKind=kindOf2(specimen);switch(patternKind){case void 0:{return throwRedacted`pattern expected: ${patt}`}case"promise":{return throwRedacted`promises cannot be patterns: ${patt}`}case"error":{return throwRedacted`errors cannot be patterns: ${patt}`}case"undefined":case"null":case"boolean":case"number":case"bigint":case"string":case"symbol":case"byteArray":case"copySet":case"copyBag":case"remotable":{return checkAsKeyPatt(specimen,patt,check)}case"copyArray":{if(isKey(patt)){return checkAsKeyPatt(specimen,patt,check)}if(specimenKind!=="copyArray"){return check(false,redacted`${specimen} - Must be a copyArray to match a copyArray pattern: ${qp(patt)}`)}const{length}=patt;if(specimen.length!==length){return check(false,redacted`Array ${specimen} - Must be as long as copyArray pattern: ${qp(patt)}`)}return patt.every((p,i)=>checkMatches2(specimen[i],p,check,i))}case"copyRecord":{if(isKey(patt)){return checkAsKeyPatt(specimen,patt,check)}if(specimenKind!=="copyRecord"){return check(false,redacted`${specimen} - Must be a copyRecord to match a copyRecord pattern: ${qp(patt)}`)}const specimenNames=recordNames(specimen);const pattNames=recordNames(patt);const missing2=listDifference(pattNames,specimenNames);if(missing2.length>=1){return check(false,redacted`${specimen} - Must have missing properties ${quote(missing2)}`)}const unexpected=listDifference(specimenNames,pattNames);if(unexpected.length>=1){return check(false,redacted`${specimen} - Must not have unexpected properties: ${quote(unexpected)}`)}const specimenValues=recordValues(specimen,specimenNames);const pattValues=recordValues(patt,pattNames);return pattNames.every((label,i)=>checkMatches2(specimenValues[i],pattValues[i],check,label))}case"copyMap":{if(isKey(patt)){return checkAsKeyPatt(specimen,patt,check)}if(specimenKind!=="copyMap"){return check(false,redacted`${specimen} - Must be a copyMap to match a copyMap pattern: ${qp(patt)}`)}const pattKeySet=copyMapKeySet(patt);const specimenKeySet=copyMapKeySet(specimen);if(!checkMatches2(specimenKeySet,pattKeySet,check)){return false}const pattValues=[];const specimenValues=[];const entryPairs=generateCollectionPairEntries(patt,specimen,getCopyMapEntryArray,void 0);for(const[_key,pattValue,specimenValue]of entryPairs){pattValues.push(pattValue);specimenValues.push(specimenValue)}return checkMatches2(harden(specimenValues),harden(pattValues),check)}default:{const matchHelper=maybeMatchHelper(patternKind);if(matchHelper){return matchHelper.checkMatches(specimen,patt.payload,check)}throw throwRedacted`internal: should have recognized ${quote(patternKind)} `}}};const matches2=(specimen,patt)=>checkMatches2(specimen,patt,identChecker);const mustMatch3=(specimen,patt,label=void 0)=>{let innerError;try{if(checkMatches2(specimen,patt,identChecker,void 0)){return}}catch(er){innerError=er}checkMatches2(specimen,patt,assertChecker,label);const outerError=makeError(redacted`internal: ${label}: inconsistent pattern match: ${qp(patt)}`);if(innerError!==void 0){note(outerError,redacted`caused by ${innerError}`)}throw outerError};const getRankCover2=(patt,encodePassable)=>{if(isKey(patt)){const encoded=encodePassable(patt);if(encoded!==void 0){return[encoded,`${encoded}~`]}}const passStyle=passStyleOf(patt);switch(passStyle){case"copyArray":{break}case"copyRecord":{break}case"tagged":{const tag=getTag(patt);const matchHelper=maybeMatchHelper(tag);if(matchHelper){return matchHelper.getRankCover(patt.payload,encodePassable)}switch(tag){case"copySet":{break}case"copyMap":{break}default:{break}}break}default:{break}}return getPassStyleCover(passStyle)};const arrayEveryMatchPattern=(array,patt,check,labelPrefix="")=>{if(isKind(patt,"match:any")){return true}return array.every((el,i)=>checkMatches2(el,patt,check,`${labelPrefix}[${i}]`))};const matchAnyHelper=Far("match:any helper",{checkMatches:(_specimen,_matcherPayload,_check)=>true,checkIsWellFormed:(matcherPayload,check)=>matcherPayload===void 0||check(false,redacted`match:any payload: ${matcherPayload} - Must be undefined`),getRankCover:(_matchPayload,_encodePassable)=>["","{"]});const matchAndHelper=Far("match:and helper",{checkMatches:(specimen,patts,check)=>{return patts.every(patt=>checkMatches2(specimen,patt,check))},checkIsWellFormed:(allegedPatts,check)=>{const checkIt=patt=>checkPattern(patt,check);return(passStyleOf(allegedPatts)==="copyArray"||check(false,redacted`Needs array of sub-patterns: ${qp(allegedPatts)}`))&&allegedPatts.every(checkIt)},getRankCover:(patts,encodePassable)=>intersectRankCovers(compareRank,patts.map(p=>getRankCover2(p,encodePassable)))});const matchOrHelper=Far("match:or helper",{checkMatches:(specimen,patts,check)=>{const{length}=patts;if(length===0){return check(false,redacted`${specimen} - no pattern disjuncts to match: ${qp(patts)}`)}const binaryUndefPattIdx=patts.length===2?patts.findIndex(patt=>isUndefinedPatt(patt)):-1;if(binaryUndefPattIdx!==-1){return specimen===void 0||checkMatches2(specimen,patts[1-binaryUndefPattIdx],check)}if(patts.some(patt=>matches2(specimen,patt))){return true}return check(false,redacted`${specimen} - Must match one of ${qp(patts)}`)},checkIsWellFormed:matchAndHelper.checkIsWellFormed,getRankCover:(patts,encodePassable)=>unionRankCovers(compareRank,patts.map(p=>getRankCover2(p,encodePassable)))});const matchNotHelper=Far("match:not helper",{checkMatches:(specimen,patt,check)=>{if(matches2(specimen,patt)){return check(false,redacted`${specimen} - Must fail negated pattern: ${qp(patt)}`)}else{return true}},checkIsWellFormed:checkPattern,getRankCover:(_patt,_encodePassable)=>["","{"]});const matchScalarHelper=Far("match:scalar helper",{checkMatches:(specimen,_matcherPayload,check)=>checkScalarKey(specimen,check),checkIsWellFormed:matchAnyHelper.checkIsWellFormed,getRankCover:(_matchPayload,_encodePassable)=>["a","z~"]});const matchKeyHelper=Far("match:key helper",{checkMatches:(specimen,_matcherPayload,check)=>checkKey(specimen,check),checkIsWellFormed:matchAnyHelper.checkIsWellFormed,getRankCover:(_matchPayload,_encodePassable)=>["a","z~"]});const matchPatternHelper=Far("match:pattern helper",{checkMatches:(specimen,_matcherPayload,check)=>checkPattern(specimen,check),checkIsWellFormed:matchAnyHelper.checkIsWellFormed,getRankCover:(_matchPayload,_encodePassable)=>["a","z~"]});const matchKindHelper=Far("match:kind helper",{checkMatches:checkKind,checkIsWellFormed:(allegedKeyKind,check)=>typeof allegedKeyKind==="string"||check(false,redacted`match:kind: payload: ${allegedKeyKind} - A kind name must be a string`),getRankCover:(kind2,_encodePassable)=>{let style;switch(kind2){case"copySet":case"copyMap":{style="tagged";break}default:{style=kind2;break}}return getPassStyleCover(style)}});const matchTaggedHelper=Far("match:tagged helper",{checkMatches:(specimen,[tagPatt,payloadPatt],check)=>{if(passStyleOf(specimen)!=="tagged"){return check(false,redacted`Expected tagged object, not ${quote(passStyleOf(specimen))}: ${specimen}`)}return checkMatches2(getTag(specimen),tagPatt,check,"tag")&&checkMatches2(specimen.payload,payloadPatt,check,"payload")},checkIsWellFormed:(payload,check)=>checkMatches2(payload,harden([MM.pattern(),MM.pattern()]),check,"match:tagged payload"),getRankCover:(_kind,_encodePassable)=>getPassStyleCover("tagged")});const matchBigintHelper=Far("match:bigint helper",{checkMatches:(specimen,[limits=void 0],check)=>{const{decimalDigitsLimit}=limit(limits);return checkKind(specimen,"bigint",check)&&checkDecimalDigitsLimit(specimen,decimalDigitsLimit,check)},checkIsWellFormed:(payload,check)=>checkIsWellFormedWithLimit(payload,harden([]),check,"match:bigint payload"),getRankCover:(_matchPayload,_encodePassable)=>getPassStyleCover("bigint")});const matchNatHelper=Far("match:nat helper",{checkMatches:(specimen,[limits=void 0],check)=>{const{decimalDigitsLimit}=limit(limits);return checkKind(specimen,"bigint",check)&&check(specimen>=0n,redacted`${specimen} - Must be non-negative`)&&checkDecimalDigitsLimit(specimen,decimalDigitsLimit,check)},checkIsWellFormed:(payload,check)=>checkIsWellFormedWithLimit(payload,harden([]),check,"match:nat payload"),getRankCover:(_matchPayload,_encodePassable)=>getPassStyleCover("bigint")});const matchStringHelper=Far("match:string helper",{checkMatches:(specimen,[limits=void 0],check)=>{const{stringLengthLimit}=limit(limits);return checkKind(specimen,"string",check)&&(specimen.length<=stringLengthLimit||check(false,redacted`string ${specimen} must not be bigger than ${stringLengthLimit}`))},checkIsWellFormed:(payload,check)=>checkIsWellFormedWithLimit(payload,harden([]),check,"match:string payload"),getRankCover:(_matchPayload,_encodePassable)=>getPassStyleCover("string")});const matchSymbolHelper=Far("match:symbol helper",{checkMatches:(specimen,[limits=void 0],check)=>{const{symbolNameLengthLimit}=limit(limits);if(!checkKind(specimen,"symbol",check)){return false}const symbolName=nameForPassableSymbol(specimen);if(typeof symbolName!=="string"){throw throwRedacted`internal: Passable symbol ${specimen} must have a passable name`}return check(symbolName.length<=symbolNameLengthLimit,redacted`Symbol name ${quote(symbolName)} must not be bigger than ${symbolNameLengthLimit}`)},checkIsWellFormed:(payload,check)=>checkIsWellFormedWithLimit(payload,harden([]),check,"match:symbol payload"),getRankCover:(_matchPayload,_encodePassable)=>getPassStyleCover("symbol")});const matchRemotableHelper=Far("match:remotable helper",{checkMatches:(specimen,remotableDesc,check)=>{if(isKind(specimen,"remotable")){return true}if(check===identChecker){return false}const{label}=remotableDesc;const passStyle=passStyleOf(specimen);const kindDetails=passStyle!=="tagged"?bareOrQuote(passStyle):quote(getTag(specimen));return check(false,redacted`${specimen} - Must be a remotable ${bareOrQuote(label)}, not ${kindDetails}`)},checkIsWellFormed:(allegedRemotableDesc,check)=>checkMatches2(allegedRemotableDesc,harden({label:MM.string()}),check,"match:remotable payload"),getRankCover:(_remotableDesc,_encodePassable)=>getPassStyleCover("remotable")});const matchLTEHelper=Far("match:lte helper",{checkMatches:(specimen,rightOperand,check)=>keyLTE(specimen,rightOperand)||check(false,redacted`${specimen} - Must be <= ${rightOperand}`),checkIsWellFormed:checkKey,getRankCover:(rightOperand,encodePassable)=>{const passStyle=passStyleOf(rightOperand);let[leftBound,rightBound]=getPassStyleCover(passStyle);const newRightBound=`${encodePassable(rightOperand)}~`;if(newRightBound!==void 0){rightBound=newRightBound}return[leftBound,rightBound]}});const matchLTHelper=Far("match:lt helper",{checkMatches:(specimen,rightOperand,check)=>keyLT(specimen,rightOperand)||check(false,redacted`${specimen} - Must be < ${rightOperand}`),checkIsWellFormed:checkKey,getRankCover:matchLTEHelper.getRankCover});const matchGTEHelper=Far("match:gte helper",{checkMatches:(specimen,rightOperand,check)=>keyGTE(specimen,rightOperand)||check(false,redacted`${specimen} - Must be >= ${rightOperand}`),checkIsWellFormed:checkKey,getRankCover:(rightOperand,encodePassable)=>{const passStyle=passStyleOf(rightOperand);let[leftBound,rightBound]=getPassStyleCover(passStyle);const newLeftBound=encodePassable(rightOperand);if(newLeftBound!==void 0){leftBound=newLeftBound}return[leftBound,rightBound]}});const matchGTHelper=Far("match:gt helper",{checkMatches:(specimen,rightOperand,check)=>keyGT(specimen,rightOperand)||check(false,redacted`${specimen} - Must be > ${rightOperand}`),checkIsWellFormed:checkKey,getRankCover:matchGTEHelper.getRankCover});const matchRecordOfHelper=Far("match:recordOf helper",{checkMatches:(specimen,[keyPatt,valuePatt,limits=void 0],check)=>{const{numPropertiesLimit,propertyNameLengthLimit}=limit(limits);return checkKind(specimen,"copyRecord",check)&&check(ownKeys18(specimen).length<=numPropertiesLimit,redacted`Must not have more than ${quote(numPropertiesLimit)} properties: ${specimen}`)&&entries7(specimen).every(([key,value])=>applyLabelingError(check,[key.length<=propertyNameLengthLimit,redacted`Property name must not be longer than ${quote(propertyNameLengthLimit)}`],key)&&checkMatches2(harden([key,value]),harden([keyPatt,valuePatt]),check,key))},checkIsWellFormed:(payload,check)=>checkIsWellFormedWithLimit(payload,harden([MM.pattern(),MM.pattern()]),check,"match:recordOf payload"),getRankCover:_entryPatt=>getPassStyleCover("copyRecord")});const matchArrayOfHelper=Far("match:arrayOf helper",{checkMatches:(specimen,[subPatt,limits=void 0],check)=>{const{arrayLengthLimit}=limit(limits);return checkKind(specimen,"copyArray",check)&&(specimen.length<=arrayLengthLimit||check(false,redacted`Array length ${specimen.length} must be <= limit ${arrayLengthLimit}`))&&arrayEveryMatchPattern(specimen,subPatt,check)},checkIsWellFormed:(payload,check)=>checkIsWellFormedWithLimit(payload,harden([MM.pattern()]),check,"match:arrayOf payload"),getRankCover:()=>getPassStyleCover("copyArray")});const matchByteArrayHelper=Far("match:byteArray helper",{checkMatches:(specimen,[limits=void 0],check)=>{const{byteLengthLimit}=limit(limits);return checkKind(specimen,"byteArray",check)&&(specimen.byteLength<=byteLengthLimit||check(false,redacted`byteArray ${specimen} must not be bigger than ${byteLengthLimit}`))},checkIsWellFormed:(payload,check)=>checkIsWellFormedWithLimit(payload,harden([]),check,"match:byteArray payload"),getRankCover:(_matchPayload,_encodePassable)=>getPassStyleCover("byteArray")});const matchSetOfHelper=Far("match:setOf helper",{checkMatches:(specimen,[keyPatt,limits=void 0],check)=>{const{numSetElementsLimit}=limit(limits);return checkKind(specimen,"copySet",check)&&check(specimen.payload.length<numSetElementsLimit,redacted`Set must not have more than ${quote(numSetElementsLimit)} elements: ${specimen.payload.length}`)&&arrayEveryMatchPattern(specimen.payload,keyPatt,check,"set elements")},checkIsWellFormed:(payload,check)=>checkIsWellFormedWithLimit(payload,harden([MM.pattern()]),check,"match:setOf payload"),getRankCover:()=>getPassStyleCover("tagged")});const matchBagOfHelper=Far("match:bagOf helper",{checkMatches:(specimen,[keyPatt,countPatt,limits=void 0],check)=>{const{numUniqueBagElementsLimit,decimalDigitsLimit}=limit(limits);return checkKind(specimen,"copyBag",check)&&check(specimen.payload.length<=numUniqueBagElementsLimit,redacted`Bag must not have more than ${quote(numUniqueBagElementsLimit)} unique elements: ${specimen}`)&&specimen.payload.every(([key,count],i)=>checkMatches2(key,keyPatt,check,`bag keys[${i}]`)&&applyLabelingError(checkDecimalDigitsLimit,[count,decimalDigitsLimit,check],`bag counts[${i}]`)&&checkMatches2(count,countPatt,check,`bag counts[${i}]`))},checkIsWellFormed:(payload,check)=>checkIsWellFormedWithLimit(payload,harden([MM.pattern(),MM.pattern()]),check,"match:bagOf payload"),getRankCover:()=>getPassStyleCover("tagged")});const elementsHasSplit=(elements,elementPatt,bound,inResults=void 0,outResults=void 0,check=identChecker)=>{let count=0n;for(let i=elements.length-1;i>=0;i-=1){const element=elements[i];if(count<bound){if(matches2(element,elementPatt)){count+=1n;if(inResults)inResults.push(element)}else if(outResults){outResults.push(element)}}else if(outResults===void 0){break}else{outResults.push(element)}}return check(count>=bound,redacted`Has only ${quote(count)} matches, but needs ${quote(bound)}`)};const pairsHasSplit=(pairs,elementPatt,bound,inResults=void 0,outResults=void 0,check=identChecker)=>{let count=0n;for(let i=pairs.length-1;i>=0;i-=1){const[element,num]=pairs[i];const numRest=bound-count;if(numRest>=1n){if(matches2(element,elementPatt)){if(num<=numRest){count+=num;if(inResults)inResults.push([element,num])}else{const numIn=numRest;count+=numIn;if(inResults)inResults.push([element,numRest]);if(outResults)outResults.push([element,num-numRest])}}else if(outResults){outResults.push([element,num])}}else if(outResults===void 0){break}else{outResults.push([element,num])}}return check(count>=bound,redacted`Has only ${quote(count)} matches, but needs ${quote(bound)}`)};const containerHasSplit2=(specimen,elementPatt,bound,needInResults=false,needOutResults=false,check=identChecker)=>{const inResults=needInResults?[]:void 0;const outResults=needOutResults?[]:void 0;const kind2=kindOf2(specimen);switch(kind2){case"copyArray":{if(!elementsHasSplit(specimen,elementPatt,bound,inResults,outResults,check)){return false}return[inResults,outResults]}case"copySet":{if(!elementsHasSplit(specimen.payload,elementPatt,bound,inResults,outResults,check)){return false}return[inResults&&makeCopySet(inResults),outResults&&makeCopySet(outResults)]}case"copyBag":{if(!pairsHasSplit(specimen.payload,elementPatt,bound,inResults,outResults,check)){return false}return[inResults&&makeCopyBag(inResults),outResults&&makeCopyBag(outResults)]}default:{return check(false,redacted`unexpected ${quote(kind2)}`)}}};const matchContainerHasHelper=Far("M.containerHas helper",{checkMatches:(specimen,[elementPatt,bound,limits=void 0],check)=>{const kind2=kindOf2(specimen,check);const{decimalDigitsLimit}=limit(limits);if(!applyLabelingError(checkDecimalDigitsLimit,[bound,decimalDigitsLimit,check],`${kind2} matches`)){return false}return!!containerHasSplit2(specimen,elementPatt,bound,false,false,check)},checkIsWellFormed:(payload,check)=>checkIsWellFormedWithLimit(payload,harden([MM.pattern(),MM.gte(1n)]),check,"M.containerHas payload"),getRankCover:()=>getPassStyleCover("tagged")});const matchMapOfHelper=Far("match:mapOf helper",{checkMatches:(specimen,[keyPatt,valuePatt,limits=void 0],check)=>{const{numMapEntriesLimit}=limit(limits);return checkKind(specimen,"copyMap",check)&&check(specimen.payload.keys.length<=numMapEntriesLimit,redacted`CopyMap must have no more than ${quote(numMapEntriesLimit)} entries: ${specimen}`)&&arrayEveryMatchPattern(specimen.payload.keys,keyPatt,check,"map keys")&&arrayEveryMatchPattern(specimen.payload.values,valuePatt,check,"map values")},checkIsWellFormed:(payload,check)=>checkIsWellFormedWithLimit(payload,harden([MM.pattern(),MM.pattern()]),check,"match:mapOf payload"),getRankCover:_entryPatt=>getPassStyleCover("tagged")});const splitArrayParts=(specimen,requiredPatt,optionalPatt)=>{const numRequired=requiredPatt.length;const numOptional=optionalPatt.length;const requiredSpecimen=specimen.slice(0,numRequired);const optionalSpecimen=specimen.slice(numRequired,numRequired+numOptional);const restSpecimen=specimen.slice(numRequired+numOptional);return harden({requiredSpecimen,optionalSpecimen,restSpecimen})};const adaptArrayPattern=(optionalPatt,length)=>harden(optionalPatt.slice(0,length).map(patt=>MM.opt(patt)));const matchSplitArrayHelper=Far("match:splitArray helper",{checkMatches:(specimen,[requiredPatt,optionalPatt=[],restPatt=MM.any()],check)=>{if(!checkKind(specimen,"copyArray",check)){return false}const{requiredSpecimen,optionalSpecimen,restSpecimen}=splitArrayParts(specimen,requiredPatt,optionalPatt);const partialPatt=adaptArrayPattern(optionalPatt,optionalSpecimen.length);let argNum=0;return(requiredSpecimen.length===requiredPatt.length||check(false,redacted`Expected at least ${quote(requiredPatt.length)} arguments: ${specimen}`))&&requiredPatt.every((p,i)=>checkMatches2(requiredSpecimen[i],p,check,`arg ${argNum++}`))&&partialPatt.every((p,i)=>checkMatches2(optionalSpecimen[i],p,check,`arg ${argNum++}?`))&&checkMatches2(restSpecimen,restPatt,check,"...rest")},checkIsWellFormed:(splitArray,check)=>{if(passStyleOf(splitArray)==="copyArray"&&(splitArray.length>=1||splitArray.length<=3)){const[requiredPatt,optionalPatt=void 0,restPatt=void 0]=splitArray;if(isPattern2(requiredPatt)&&passStyleOf(requiredPatt)==="copyArray"&&(optionalPatt===void 0||isPattern2(optionalPatt)&&passStyleOf(optionalPatt)==="copyArray")&&(restPatt===void 0||isPattern2(restPatt))){return true}}return check(false,redacted`Must be an array of a requiredPatt array, an optional optionalPatt array, and an optional restPatt: ${quote(splitArray)}`)},getRankCover:([_requiredPatt,_optionalPatt=void 0,_restPatt=void 0])=>getPassStyleCover("copyArray")});const splitRecordParts=(specimen,requiredPatt,optionalPatt)=>{const requiredEntries=[];const optionalEntries=[];const restEntries=[];for(const[name,value]of entries7(specimen)){if(hasOwn9(requiredPatt,name)){requiredEntries.push([name,value])}else if(hasOwn9(optionalPatt,name)){optionalEntries.push([name,value])}else{restEntries.push([name,value])}}return harden({requiredSpecimen:fromUniqueEntries(requiredEntries),optionalSpecimen:fromUniqueEntries(optionalEntries),restSpecimen:fromUniqueEntries(restEntries)})};const adaptRecordPattern=(optionalPatt,names)=>fromUniqueEntries(names.map(name=>[name,MM.opt(optionalPatt[name])]));const matchSplitRecordHelper=Far("match:splitRecord helper",{checkMatches:(specimen,[requiredPatt,optionalPatt={},restPatt=MM.any()],check)=>{if(!checkKind(specimen,"copyRecord",check)){return false}const{requiredSpecimen,optionalSpecimen,restSpecimen}=splitRecordParts(specimen,requiredPatt,optionalPatt);const partialNames=ownKeys18(optionalSpecimen);const partialPatt=adaptRecordPattern(optionalPatt,partialNames);return checkMatches2(requiredSpecimen,requiredPatt,check)&&partialNames.every(name=>checkMatches2(optionalSpecimen[name],partialPatt[name],check,`${name}?`))&&checkMatches2(restSpecimen,restPatt,check,"...rest")},checkIsWellFormed:(splitArray,check)=>{if(passStyleOf(splitArray)==="copyArray"&&(splitArray.length>=1||splitArray.length<=3)){const[requiredPatt,optionalPatt=void 0,restPatt=void 0]=splitArray;if(isPattern2(requiredPatt)&&passStyleOf(requiredPatt)==="copyRecord"&&(optionalPatt===void 0||isPattern2(optionalPatt)&&passStyleOf(optionalPatt)==="copyRecord")&&(restPatt===void 0||isPattern2(restPatt))){return true}}return check(false,redacted`Must be an array of a requiredPatt record, an optional optionalPatt record, and an optional restPatt: ${quote(splitArray)}`)},getRankCover:([requiredPatt,_optionalPatt=void 0,_restPatt=void 0])=>getPassStyleCover(passStyleOf(requiredPatt))});const HelpersByMatchTag=harden({"match:any":matchAnyHelper,"match:and":matchAndHelper,"match:or":matchOrHelper,"match:not":matchNotHelper,"match:scalar":matchScalarHelper,"match:key":matchKeyHelper,"match:pattern":matchPatternHelper,"match:kind":matchKindHelper,"match:tagged":matchTaggedHelper,"match:bigint":matchBigintHelper,"match:nat":matchNatHelper,"match:string":matchStringHelper,"match:symbol":matchSymbolHelper,"match:remotable":matchRemotableHelper,"match:lt":matchLTHelper,"match:lte":matchLTEHelper,"match:gte":matchGTEHelper,"match:gt":matchGTHelper,"match:arrayOf":matchArrayOfHelper,"match:byteArray":matchByteArrayHelper,"match:recordOf":matchRecordOfHelper,"match:setOf":matchSetOfHelper,"match:bagOf":matchBagOfHelper,"match:containerHas":matchContainerHasHelper,"match:mapOf":matchMapOfHelper,"match:splitArray":matchSplitArrayHelper,"match:splitRecord":matchSplitRecordHelper});const makeMatcher=(tag,payload)=>{const matcher=makeTagged(tag,payload);assertPattern2(matcher);return matcher};const makeKindMatcher=kind2=>makeMatcher("match:kind",kind2);const AnyShape=makeMatcher("match:any",void 0);const ScalarShape=makeMatcher("match:scalar",void 0);const KeyShape=makeMatcher("match:key",void 0);const PatternShape=makeMatcher("match:pattern",void 0);const BooleanShape=makeKindMatcher("boolean");const NumberShape=makeKindMatcher("number");const BigIntShape=makeTagged("match:bigint",[]);const NatShape=makeTagged("match:nat",[]);const StringShape=makeTagged("match:string",[]);const SymbolShape=makeTagged("match:symbol",[]);const RecordShape=makeTagged("match:recordOf",[AnyShape,AnyShape]);const ArrayShape=makeTagged("match:arrayOf",[AnyShape]);const ByteArrayShape=makeTagged("match:byteArray",[]);const SetShape=makeTagged("match:setOf",[AnyShape]);const BagShape=makeTagged("match:bagOf",[AnyShape,AnyShape]);const MapShape=makeTagged("match:mapOf",[AnyShape,AnyShape]);const RemotableShape=makeKindMatcher("remotable");const ErrorShape=makeKindMatcher("error");const PromiseShape=makeKindMatcher("promise");const UndefinedShape=makeKindMatcher("undefined");const makeLimitsMatcher=(tag,payload)=>{if(payload[payload.length-1]===void 0){payload=harden(payload.slice(0,payload.length-1))}return makeMatcher(tag,payload)};const makeRemotableMatcher=(label=void 0)=>label===void 0?RemotableShape:makeMatcher("match:remotable",harden({label}));const makeSplitPayload=(empty5,base,optional=void 0,rest=void 0)=>{if(rest){return[base,optional||empty5,rest]}if(optional){return[base,optional]}return[base]};const M2=harden({any:()=>AnyShape,and:(...patts)=>makeMatcher("match:and",patts),or:(...patts)=>makeMatcher("match:or",patts),not:subPatt=>makeMatcher("match:not",subPatt),scalar:()=>ScalarShape,key:()=>KeyShape,pattern:()=>PatternShape,kind:makeKindMatcher,tagged:(tagPatt=M2.string(),payloadPatt=M2.any())=>makeMatcher("match:tagged",harden([tagPatt,payloadPatt])),boolean:()=>BooleanShape,number:()=>NumberShape,bigint:(limits=void 0)=>limits?makeLimitsMatcher("match:bigint",[limits]):BigIntShape,nat:(limits=void 0)=>limits?makeLimitsMatcher("match:nat",[limits]):NatShape,string:(limits=void 0)=>limits?makeLimitsMatcher("match:string",[limits]):StringShape,symbol:(limits=void 0)=>limits?makeLimitsMatcher("match:symbol",[limits]):SymbolShape,record:(limits=void 0)=>limits?M2.recordOf(M2.any(),M2.any(),limits):RecordShape,array:(limits=void 0)=>limits?M2.arrayOf(M2.any(),limits):ArrayShape,byteArray:(limits=void 0)=>limits?makeLimitsMatcher("match:byteArray",[limits]):ByteArrayShape,set:(limits=void 0)=>limits?M2.setOf(M2.any(),limits):SetShape,bag:(limits=void 0)=>limits?M2.bagOf(M2.any(),M2.any(),limits):BagShape,map:(limits=void 0)=>limits?M2.mapOf(M2.any(),M2.any(),limits):MapShape,remotable:makeRemotableMatcher,error:()=>ErrorShape,promise:()=>PromiseShape,undefined:()=>UndefinedShape,null:()=>null,lt:rightOperand=>makeMatcher("match:lt",rightOperand),lte:rightOperand=>makeMatcher("match:lte",rightOperand),eq:key=>{assertKey(key);return key===void 0?M2.undefined():key},neq:key=>M2.not(M2.eq(key)),gte:rightOperand=>makeMatcher("match:gte",rightOperand),gt:rightOperand=>makeMatcher("match:gt",rightOperand),recordOf:(keyPatt=M2.any(),valuePatt=M2.any(),limits=void 0)=>makeLimitsMatcher("match:recordOf",[keyPatt,valuePatt,limits]),arrayOf:(subPatt=M2.any(),limits=void 0)=>makeLimitsMatcher("match:arrayOf",[subPatt,limits]),setOf:(keyPatt=M2.any(),limits=void 0)=>makeLimitsMatcher("match:setOf",[keyPatt,limits]),bagOf:(keyPatt=M2.any(),countPatt=M2.any(),limits=void 0)=>makeLimitsMatcher("match:bagOf",[keyPatt,countPatt,limits]),containerHas:(elementPatt=M2.any(),countPatt=1n,limits=void 0)=>makeLimitsMatcher("match:containerHas",[elementPatt,countPatt,limits]),mapOf:(keyPatt=M2.any(),valuePatt=M2.any(),limits=void 0)=>makeLimitsMatcher("match:mapOf",[keyPatt,valuePatt,limits]),splitArray:(base,optional=void 0,rest=void 0)=>makeMatcher("match:splitArray",makeSplitPayload([],base,optional,rest)),splitRecord:(base,optional=void 0,rest=void 0)=>makeMatcher("match:splitRecord",makeSplitPayload({},base,optional,rest)),split:(base,rest=void 0)=>{if(passStyleOf(harden(base))==="copyArray"){return M2.splitArray(base,rest&&[],rest)}else{return M2.splitRecord(base,rest&&{},rest)}},partial:(base,rest=void 0)=>{if(passStyleOf(harden(base))==="copyArray"){return M2.splitArray([],base,rest)}else{return M2.splitRecord({},base,rest)}},eref:t=>M2.or(t,M2.promise()),opt:t=>M2.or(M2.undefined(),t),interface:(interfaceName,methodGuards,options)=>makeInterfaceGuard(interfaceName,methodGuards,options),call:(...argPatterns)=>makeMethodGuardMaker("sync",argPatterns),callWhen:(...argGuards)=>makeMethodGuardMaker("async",argGuards),await:argPattern=>makeAwaitArgGuard(argPattern),raw:()=>makeRawGuard()});return harden({checkMatches:checkMatches2,matches:matches2,mustMatch:mustMatch3,assertPattern:assertPattern2,isPattern:isPattern2,getRankCover:getRankCover2,M:M2,kindOf:kindOf2,containerHasSplit:containerHasSplit2})};var{checkMatches,matches,mustMatch,assertPattern,isPattern,getRankCover,M,kindOf,containerHasSplit}=makePatternKit();MM=M;var AwaitArgGuardPayloadShape=harden({argGuard:M.pattern()});var AwaitArgGuardShape=M.kind("guard:awaitArgGuard");var isAwaitArgGuard=specimen=>matches(specimen,AwaitArgGuardShape);harden(isAwaitArgGuard);var assertAwaitArgGuard=specimen=>{mustMatch(specimen,AwaitArgGuardShape,"awaitArgGuard")};harden(assertAwaitArgGuard);var makeAwaitArgGuard=argPattern=>{const result=makeTagged("guard:awaitArgGuard",{argGuard:argPattern});assertAwaitArgGuard(result);return result};var RawGuardPayloadShape=M.record();var RawGuardShape=M.kind("guard:rawGuard");var isRawGuard=specimen=>matches(specimen,RawGuardShape);var makeRawGuard=()=>makeTagged("guard:rawGuard",{});var SyncValueGuardShape=M.or(RawGuardShape,M.pattern());var SyncValueGuardListShape=M.arrayOf(SyncValueGuardShape);var ArgGuardShape=M.or(RawGuardShape,AwaitArgGuardShape,M.pattern());var ArgGuardListShape=M.arrayOf(ArgGuardShape);var SyncMethodGuardPayloadShape=harden({callKind:"sync",argGuards:SyncValueGuardListShape,optionalArgGuards:M.opt(SyncValueGuardListShape),restArgGuard:M.opt(SyncValueGuardShape),returnGuard:SyncValueGuardShape});var AsyncMethodGuardPayloadShape=harden({callKind:"async",argGuards:ArgGuardListShape,optionalArgGuards:M.opt(ArgGuardListShape),restArgGuard:M.opt(SyncValueGuardShape),returnGuard:SyncValueGuardShape});var MethodGuardPayloadShape=M.or(SyncMethodGuardPayloadShape,AsyncMethodGuardPayloadShape);var MethodGuardShape=M.kind("guard:methodGuard");var assertMethodGuard=specimen=>{mustMatch(specimen,MethodGuardShape,"methodGuard")};harden(assertMethodGuard);var makeMethodGuardMaker=(callKind,argGuards,optionalArgGuards=void 0,restArgGuard=void 0)=>harden({optional:(...optArgGuards)=>{optionalArgGuards===void 0||throwRedacted`Can only have one set of optional guards`;restArgGuard===void 0||throwRedacted`optional arg guards must come before rest arg`;return makeMethodGuardMaker(callKind,argGuards,optArgGuards)},rest:rArgGuard=>{restArgGuard===void 0||throwRedacted`Can only have one rest arg`;return makeMethodGuardMaker(callKind,argGuards,optionalArgGuards,rArgGuard)},returns:(returnGuard=M.undefined())=>{const result=makeTagged("guard:methodGuard",{callKind,argGuards,optionalArgGuards,restArgGuard,returnGuard});assertMethodGuard(result);return result}});var InterfaceGuardPayloadShape=M.splitRecord({interfaceName:M.string(),methodGuards:M.recordOf(M.string(),MethodGuardShape)},{defaultGuards:M.or(M.undefined(),"passable","raw"),sloppy:M.boolean(),symbolMethodGuards:M.mapOf(M.symbol(),MethodGuardShape)});var InterfaceGuardShape=M.kind("guard:interfaceGuard");var assertInterfaceGuard=specimen=>{mustMatch(specimen,InterfaceGuardShape,"interfaceGuard")};harden(assertInterfaceGuard);var makeInterfaceGuard=(interfaceName,methodGuards,options={})=>{const{sloppy=false,defaultGuards=sloppy?"passable":void 0}=options;const stringMethodGuards={};const symbolMethodGuardsEntries=[];for(const key of ownKeys18(methodGuards)){const value=methodGuards[key];if(typeof key==="symbol"){symbolMethodGuardsEntries.push([key,value])}else{stringMethodGuards[key]=value}}const result=makeTagged("guard:interfaceGuard",{interfaceName,methodGuards:stringMethodGuards,...symbolMethodGuardsEntries.length?{symbolMethodGuards:makeCopyMap(symbolMethodGuardsEntries)}:{},defaultGuards});assertInterfaceGuard(result);return result};var GuardPayloadShapes=harden({"guard:awaitArgGuard":AwaitArgGuardPayloadShape,"guard:rawGuard":RawGuardPayloadShape,"guard:methodGuard":MethodGuardPayloadShape,"guard:interfaceGuard":InterfaceGuardPayloadShape});var LegacyAwaitArgGuardShape=harden({klass:"awaitArg",argGuard:M.pattern()});var getAwaitArgGuardPayload=awaitArgGuard=>{if(matches(awaitArgGuard,LegacyAwaitArgGuardShape)){const{klass:_,...payload}=awaitArgGuard;return payload}assertAwaitArgGuard(awaitArgGuard);return awaitArgGuard.payload};harden(getAwaitArgGuardPayload);var LegacySyncMethodGuardShape=M.splitRecord({klass:"methodGuard",callKind:"sync",argGuards:SyncValueGuardListShape,returnGuard:SyncValueGuardShape},{optionalArgGuards:SyncValueGuardListShape,restArgGuard:SyncValueGuardShape});var LegacyArgGuardShape=M.or(RawGuardShape,AwaitArgGuardShape,LegacyAwaitArgGuardShape,M.pattern());var LegacyArgGuardListShape=M.arrayOf(LegacyArgGuardShape);var LegacyAsyncMethodGuardShape=M.splitRecord({klass:"methodGuard",callKind:"async",argGuards:LegacyArgGuardListShape,returnGuard:SyncValueGuardShape},{optionalArgGuards:ArgGuardListShape,restArgGuard:SyncValueGuardShape});var LegacyMethodGuardShape=M.or(LegacySyncMethodGuardShape,LegacyAsyncMethodGuardShape);var adaptLegacyArgGuard=argGuard=>matches(argGuard,LegacyAwaitArgGuardShape)?M.await(getAwaitArgGuardPayload(argGuard).argGuard):argGuard;var getMethodGuardPayload=methodGuard=>{if(matches(methodGuard,MethodGuardShape)){return methodGuard.payload}mustMatch(methodGuard,LegacyMethodGuardShape,"legacyMethodGuard");const{klass:_,callKind,returnGuard,restArgGuard}=methodGuard;let{argGuards,optionalArgGuards}=methodGuard;if(callKind==="async"){argGuards=argGuards.map(adaptLegacyArgGuard);optionalArgGuards=optionalArgGuards&&optionalArgGuards.map(adaptLegacyArgGuard)}const payload=harden({callKind,argGuards,optionalArgGuards,restArgGuard,returnGuard});mustMatch(payload,MethodGuardPayloadShape,"internalMethodGuardAdaptor");return payload};harden(getMethodGuardPayload);var LegacyInterfaceGuardShape=M.splitRecord({klass:"Interface",interfaceName:M.string(),methodGuards:M.recordOf(M.string(),M.or(MethodGuardShape,LegacyMethodGuardShape))},{defaultGuards:M.or(M.undefined(),"passable","raw"),sloppy:M.boolean(),symbolMethodGuards:M.mapOf(M.symbol(),MethodGuardShape)});var adaptMethodGuard=methodGuard=>{if(matches(methodGuard,LegacyMethodGuardShape)){const{callKind,argGuards,optionalArgGuards=[],restArgGuard=M.any(),returnGuard}=getMethodGuardPayload(methodGuard);const mCall=callKind==="sync"?M.call:M.callWhen;return mCall(...argGuards).optional(...optionalArgGuards).rest(restArgGuard).returns(returnGuard)}return methodGuard};var getInterfaceGuardPayload=interfaceGuard=>{if(matches(interfaceGuard,InterfaceGuardShape)){return interfaceGuard.payload}mustMatch(interfaceGuard,LegacyInterfaceGuardShape,"legacyInterfaceGuard");let{klass:_,interfaceName,methodGuards,...rest}=interfaceGuard;methodGuards=objectMap(methodGuards,adaptMethodGuard);const payload=harden({interfaceName,methodGuards,...rest});mustMatch(payload,InterfaceGuardPayloadShape,"internalInterfaceGuardAdaptor");return payload};harden(getInterfaceGuardPayload);var emptyCopyMap=makeCopyMap([]);var getInterfaceMethodKeys=interfaceGuard=>{const{methodGuards,symbolMethodGuards=emptyCopyMap}=getInterfaceGuardPayload(interfaceGuard);return harden([...Reflect.ownKeys(methodGuards),...getCopyMapKeys(symbolMethodGuards)])};harden(getInterfaceMethodKeys);var makeWeakSetStoreMethods=(jsset,assertKeyOkToAdd,assertKeyOkToDelete=void 0,keyName="key")=>{const assertKeyExists=key=>jsset.has(key)||throwRedacted`${quote(keyName)} not found: ${key}`;return harden({has:key=>{return jsset.has(key)},add:key=>{assertKeyOkToAdd(key);jsset.add(key)},delete:key=>{assertKeyExists(key);if(assertKeyOkToDelete!==void 0){assertKeyOkToDelete(key)}jsset.delete(key)},addAll:keys2=>{if(typeof keys2[Symbol.iterator]!=="function"){if(Object.isFrozen(keys2)&&isCopySet(keys2)){keys2=getCopySetKeys(keys2)}else{throwRedacted`provided data source is not iterable: ${keys2}`}}for(const key of keys2){assertKeyOkToAdd(key);jsset.add(key)}}})};var makeScalarWeakSetStore=(tag="key",{longLived=true,keyShape=void 0}={})=>{const jsset=new(longLived?WeakSet:Set);if(keyShape!==void 0){assertPattern(keyShape)}const assertKeyOkToAdd=key=>{harden(key);passStyleOf(key)==="remotable"||throwRedacted`Only remotables can be keys of scalar WeakStores: ${key}`;if(keyShape!==void 0){mustMatch(key,keyShape,"weakSetStore key")}};return Far(`scalar WeakSetStore of ${quote(tag)}`,{...makeWeakSetStoreMethods(jsset,assertKeyOkToAdd,void 0,tag)})};harden(makeScalarWeakSetStore);var makeCurrentKeysKit=(getRawKeys,checkHas,compare,assertOkToAdd,assertOkToDelete=void 0,keyName="key")=>{let updateCount=0;let sortedKeysMemo;const assertUpdateOnAdd=(k,v=void 0)=>{assertOkToAdd(k,v);updateCount+=1;sortedKeysMemo=void 0};const assertUpdateOnDelete=k=>assertOkToDelete&&assertOkToDelete(k);const getSortedKeys=()=>{if(sortedKeysMemo===void 0){sortedKeysMemo=harden([...getRawKeys()].sort(compare))}return sortedKeysMemo};const iterableKeys=Far("Iterable of keys",{[Symbol.iterator]:()=>{const generation=updateCount;getSortedKeys();const len=sortedKeysMemo.length;let i=0;return Far("Iterator of keys",{next:()=>{generation===updateCount||throwRedacted`Store ${quote(keyName)} cursor stale`;for(;;){if(i<len){const value=sortedKeysMemo[i];i+=1;if(checkHas(value)){return harden({done:false,value})}}else{return harden({done:true,value:void 0})}}}})}});return harden({assertUpdateOnAdd,assertUpdateOnDelete,iterableKeys})};harden(makeCurrentKeysKit);var provideLazy=(mapStore,key,makeValue)=>{if(!mapStore.has(key)){mapStore.init(key,makeValue(key))}return mapStore.get(key)};harden(provideLazy);var makeAtomicProvider=store=>{const pending=new Map;const provideAsync=(key,makeValue,finishValue)=>{if(store.has(key)){return Promise.resolve(store.get(key))}if(!pending.has(key)){const valP2=makeValue(key).then(v=>{store.init(key,v);return v}).then(v=>{if(finishValue){return finishValue(key,v).then(()=>v)}return v}).finally(()=>{pending.delete(key)});pending.set(key,valP2)}const valP=pending.get(key);assert(valP);return valP};return harden({provideAsync})};harden(makeAtomicProvider);var appendToStoredArray=(mapStore,key,item)=>{if(mapStore.has(key)){const extant=mapStore.get(key);mapStore.set(key,harden([...extant,item]))}else{mapStore.init(key,harden([item]))}};harden(appendToStoredArray);var makeSetStoreMethods=(jsset,assertKeyOkToAdd,assertKeyOkToDelete=void 0,keyName="key")=>{const{assertUpdateOnAdd,assertUpdateOnDelete,iterableKeys}=makeCurrentKeysKit(()=>jsset.keys(),k=>jsset.has(k),compareRank,assertKeyOkToAdd,assertKeyOkToDelete,keyName);const keys2=(keyPatt=void 0)=>keyPatt===void 0?iterableKeys:filterIterable(iterableKeys,k=>matches(k,keyPatt));return harden({...makeWeakSetStoreMethods(jsset,assertUpdateOnAdd,assertUpdateOnDelete,keyName),keys:keys2,values:keys2,snapshot:(keyPatt=void 0)=>makeCopySet(keys2(keyPatt)),getSize:(keyPatt=void 0)=>keyPatt===void 0?jsset.size:[...keys2(keyPatt)].length,clear:(keyPatt=void 0)=>{if(keyPatt===void 0){jsset.clear()}for(const key of keys2(keyPatt)){jsset.delete(key)}}})};var makeScalarSetStore=(tag="key",{keyShape=void 0}={})=>{const jsset=new Set;if(keyShape!==void 0){assertPattern(keyShape)}const assertKeyOkToAdd=key=>{harden(key);assertScalarKey(key);if(keyShape!==void 0){mustMatch(key,keyShape,"setStore key")}};return Far(`scalar SetStore of ${quote(tag)}`,{...makeSetStoreMethods(jsset,assertKeyOkToAdd,void 0,tag)})};harden(makeScalarSetStore);var makeWeakMapStoreMethods=(jsmap,assertKVOkToAdd,assertKVOkToSet,assertKeyOkToDelete=void 0,keyName="key")=>{const assertKeyDoesNotExist=key=>!jsmap.has(key)||throwRedacted`${quote(keyName)} already registered: ${key}`;const assertKeyExists=key=>jsmap.has(key)||throwRedacted`${quote(keyName)} not found: ${key}`;return harden({has:key=>{return jsmap.has(key)},get:key=>{assertKeyExists(key);return jsmap.get(key)},init:(key,value)=>{assertKeyDoesNotExist(key);assertKVOkToAdd(key,value);jsmap.set(key,value)},set:(key,value)=>{assertKeyExists(key);assertKVOkToSet(key,value);jsmap.set(key,value)},delete:key=>{assertKeyExists(key);if(assertKeyOkToDelete!==void 0){assertKeyOkToDelete(key)}jsmap.delete(key)},addAll:entries8=>{if(typeof entries8[Symbol.iterator]!=="function"){if(Object.isFrozen(entries8)&&isCopyMap(entries8)){entries8=getCopyMapEntries(entries8)}else{throwRedacted`provided data source is not iterable: ${entries8}`}}for(const[key,value]of entries8){assertKVOkToAdd(key,value);jsmap.set(key,value)}}})};var makeScalarWeakMapStore=(tag="key",{longLived=true,keyShape=void 0,valueShape=void 0}={})=>{const jsmap=new(longLived?WeakMap:Map);if(keyShape!==void 0){assertPattern(keyShape)}if(valueShape!==void 0){assertPattern(valueShape)}const assertKVOkToSet=(_key,value)=>{harden(value);assertPassable(value);if(valueShape!==void 0){mustMatch(value,valueShape,"weakMapStore value")}};const assertKVOkToAdd=(key,value)=>{harden(key);passStyleOf(key)==="remotable"||throwRedacted`Only remotables can be keys of scalar WeakMapStores: ${key}`;if(keyShape!==void 0){mustMatch(key,keyShape,"weakMapStore key")}assertKVOkToSet(key,value)};return Far(`scalar WeakMapStore of ${quote(tag)}`,{...makeWeakMapStoreMethods(jsmap,assertKVOkToAdd,assertKVOkToSet,void 0,tag)})};harden(makeScalarWeakMapStore);var makeMapStoreMethods=(jsmap,assertKVOkToAdd,assertKVOkToSet,assertKeyOkToDelete=void 0,tag="key")=>{const{assertUpdateOnAdd,assertUpdateOnDelete,iterableKeys}=makeCurrentKeysKit(()=>jsmap.keys(),k=>jsmap.has(k),compareRank,assertKVOkToAdd,assertKeyOkToDelete,tag);const keys2=(keyPatt=void 0,valuePatt=void 0)=>{if(keyPatt===void 0&&valuePatt===void 0){return iterableKeys}const filter=k=>{if(keyPatt!==void 0&&!matches(k,keyPatt)){return false}if(valuePatt!==void 0&&!matches(jsmap.get(k),valuePatt)){return false}return true};return filterIterable(iterableKeys,filter)};const values5=(keyPatt=void 0,valuePatt=void 0)=>mapIterable(keys2(keyPatt,valuePatt),k=>jsmap.get(k));const entries8=(keyPatt=void 0,valuePatt=void 0)=>mapIterable(keys2(keyPatt,valuePatt),k=>[k,jsmap.get(k)]);return harden({...makeWeakMapStoreMethods(jsmap,assertUpdateOnAdd,assertKVOkToSet,assertUpdateOnDelete,tag),keys:keys2,values:values5,entries:entries8,snapshot:(keyPatt=void 0,valuePatt=void 0)=>makeCopyMap(entries8(keyPatt,valuePatt)),getSize:(keyPatt=void 0,valuePatt=void 0)=>keyPatt===void 0&&valuePatt===void 0?jsmap.size:[...keys2(keyPatt,valuePatt)].length,clear:(keyPatt=void 0,valuePatt=void 0)=>{if(keyPatt===void 0&&valuePatt===void 0){jsmap.clear()}for(const key of keys2(keyPatt,valuePatt)){jsmap.delete(key)}}})};var makeScalarMapStore=(tag="key",{keyShape=void 0,valueShape=void 0}={})=>{const jsmap=new Map;if(keyShape!==void 0){assertPattern(keyShape)}if(valueShape!==void 0){assertPattern(valueShape)}const assertKVOkToSet=(_key,value)=>{harden(value);assertPassable(value);if(valueShape!==void 0){mustMatch(value,valueShape,"mapStore value")}};const assertKVOkToAdd=(key,value)=>{harden(key);assertScalarKey(key);if(keyShape!==void 0){mustMatch(key,keyShape,"mapStore key")}assertKVOkToSet(key,value)};return Far(`scalar MapStore of ${quote(tag)}`,{...makeMapStoreMethods(jsmap,assertKVOkToAdd,assertKVOkToSet,void 0,tag)})};harden(makeScalarMapStore);var GET_INTERFACE_GUARD="__getInterfaceGuard__";var{apply:apply5,ownKeys:ownKeys19}=Reflect;var{defineProperties:defineProperties3,fromEntries:fromEntries8,hasOwn:hasOwn10}=Object;var RawMethodGuard=M.call().rest(M.raw()).returns(M.raw());var REDACTED_RAW_ARG="<redacted raw arg>";var PassableMethodGuard=M.call().rest(M.any()).returns(M.any());var defendSyncArgs=(syncArgs,matchConfig,label=void 0)=>{const{declaredLen,hasRestArgGuard,restArgGuardIsRaw,paramsPattern,redactedIndices}=matchConfig;let matchableArgs=syncArgs;if(restArgGuardIsRaw&&syncArgs.length>declaredLen){const restLen=syncArgs.length-declaredLen;const redactedRest=Array(restLen).fill(REDACTED_RAW_ARG);matchableArgs=[...syncArgs.slice(0,declaredLen),...redactedRest]}else if(redactedIndices.length>0&&redactedIndices[0]<syncArgs.length){matchableArgs=[...syncArgs]}for(const i of redactedIndices){if(i>=matchableArgs.length){break}matchableArgs[i]=REDACTED_RAW_ARG}mustMatch(harden(matchableArgs),paramsPattern,label);if(hasRestArgGuard){return syncArgs}syncArgs.length<=declaredLen||throwRedacted`${quote(label)} accepts at most ${quote(declaredLen)} arguments, not ${quote(syncArgs.length)}: ${syncArgs}`;return syncArgs};var buildMatchConfig=methodGuardPayload=>{const{argGuards,optionalArgGuards=[],restArgGuard}=methodGuardPayload;const matchableArgGuards=[...argGuards,...optionalArgGuards];const redactedIndices=[];for(let i=0;i<matchableArgGuards.length;i+=1){if(isRawGuard(matchableArgGuards[i])){matchableArgGuards[i]=REDACTED_RAW_ARG;redactedIndices.push(i)}}let matchableRestArgGuard=restArgGuard;if(isRawGuard(matchableRestArgGuard)){matchableRestArgGuard=M.arrayOf(REDACTED_RAW_ARG)}const matchableMethodGuardPayload=harden({...methodGuardPayload,argGuards:matchableArgGuards.slice(0,argGuards.length),optionalArgGuards:matchableArgGuards.slice(argGuards.length),restArgGuard:matchableRestArgGuard});const paramsPattern=M.splitArray(matchableMethodGuardPayload.argGuards,matchableMethodGuardPayload.optionalArgGuards,matchableMethodGuardPayload.restArgGuard);return harden({declaredLen:matchableArgGuards.length,hasRestArgGuard:restArgGuard!==void 0,restArgGuardIsRaw:restArgGuard!==matchableRestArgGuard,paramsPattern,redactedIndices,matchableMethodGuardPayload})};var defendSyncMethod=(getContext,behaviorMethod,methodGuardPayload,label)=>{const{returnGuard}=methodGuardPayload;const isRawReturn=isRawGuard(returnGuard);const matchConfig=buildMatchConfig(methodGuardPayload);const{syncMethod}={syncMethod(...syncArgs){try{const context=getContext(this);const realArgs=defendSyncArgs(syncArgs,matchConfig,label);const result=apply5(behaviorMethod,context,realArgs);if(!isRawReturn){mustMatch(harden(result),returnGuard,`${label}: result`)}return result}catch(thrownThing){throw toThrowable(thrownThing)}}};return syncMethod};var desync=methodGuardPayload=>{const{argGuards,optionalArgGuards=[],restArgGuard}=methodGuardPayload;!isAwaitArgGuard(restArgGuard)||throwRedacted`Rest args may not be awaited: ${restArgGuard}`;const rawArgGuards=[...argGuards,...optionalArgGuards];const awaitIndexes=[];for(let i=0;i<rawArgGuards.length;i+=1){const argGuard=rawArgGuards[i];if(isAwaitArgGuard(argGuard)){rawArgGuards[i]=getAwaitArgGuardPayload(argGuard).argGuard;awaitIndexes.push(i)}}return{awaitIndexes,rawMethodGuardPayload:{...methodGuardPayload,argGuards:rawArgGuards.slice(0,argGuards.length),optionalArgGuards:rawArgGuards.slice(argGuards.length)}}};var defendAsyncMethod=(getContext,behaviorMethod,methodGuardPayload,label)=>{const{returnGuard}=methodGuardPayload;const isRawReturn=isRawGuard(returnGuard);const{awaitIndexes,rawMethodGuardPayload}=desync(methodGuardPayload);const matchConfig=buildMatchConfig(rawMethodGuardPayload);const{asyncMethod}={asyncMethod(...args){const awaitList=[];for(const i of awaitIndexes){if(i>=args.length){break}awaitList.push(args[i])}const p=Promise.all(awaitList);const syncArgs=[...args];const resultP=E.when(p,awaitedArgs=>{for(let j=0;j<awaitedArgs.length;j+=1){syncArgs[awaitIndexes[j]]=awaitedArgs[j]}const context=getContext(this);const realArgs=defendSyncArgs(syncArgs,matchConfig,label);return apply5(behaviorMethod,context,realArgs)});return E.when(resultP,fulfillment=>{if(!isRawReturn){mustMatch(harden(fulfillment),returnGuard,`${label}: result`)}return fulfillment}).catch(reason=>Promise.reject(toThrowable(reason)))}};return asyncMethod};var defendMethod=(getContext,behaviorMethod,methodGuard,label)=>{const methodGuardPayload=getMethodGuardPayload(methodGuard);const{callKind}=methodGuardPayload;if(callKind==="sync"){return defendSyncMethod(getContext,behaviorMethod,methodGuardPayload,label)}else{assert(callKind==="async");return defendAsyncMethod(getContext,behaviorMethod,methodGuardPayload,label)}};var bindMethod=(methodTag,contextProvider,behaviorMethod,methodGuard)=>{assert.typeof(behaviorMethod,"function");const getContext=representative=>{representative||throwRedacted`Method ${methodTag} called without 'this' object`;const context=contextProvider(representative);if(context===void 0){throw throwRedacted`${quote(methodTag)} may only be applied to a valid instance: ${representative}`}return context};const method=defendMethod(getContext,behaviorMethod,methodGuard,methodTag);defineProperties3(method,{name:{value:methodTag},length:{value:behaviorMethod.length}});return method};var defendPrototype=(tag,contextProvider,behaviorMethods,thisfulMethods=false,interfaceGuard=void 0)=>{const prototype={};const methodNames=getRemotableMethodNames(behaviorMethods).filter(key=>{if(key!=="constructor"){return true}const constructor=behaviorMethods.constructor;return!(constructor.prototype&&constructor.prototype.constructor===constructor)});let methodGuards;let defaultGuards;if(interfaceGuard){const{interfaceName,methodGuards:mg,symbolMethodGuards,sloppy,defaultGuards:dg=sloppy?"passable":defaultGuards}=getInterfaceGuardPayload(interfaceGuard);methodGuards=harden({...mg,...symbolMethodGuards&&fromEntries8(getCopyMapEntries(symbolMethodGuards))});defaultGuards=dg;{const methodGuardNames=ownKeys19(methodGuards);const unimplemented=listDifference(methodGuardNames,methodNames);unimplemented.length===0||throwRedacted`methods ${quote(unimplemented)} not implemented by ${quote(tag)}`;if(defaultGuards===void 0){const unguarded=listDifference(methodNames,methodGuardNames);unguarded.length===0||throwRedacted`methods ${quote(unguarded)} not guarded by ${quote(interfaceName)}`}}}for(const prop of methodNames){const originalMethod=behaviorMethods[prop];const{shiftedMethod}={shiftedMethod(...args){return originalMethod(this,...args)}};const behaviorMethod=thisfulMethods?originalMethod:shiftedMethod;let methodGuard=methodGuards&&methodGuards[prop];if(!methodGuard){switch(defaultGuards){case void 0:{if(thisfulMethods){methodGuard=PassableMethodGuard}else{methodGuard=RawMethodGuard}break}case"passable":{methodGuard=PassableMethodGuard;break}case"raw":{methodGuard=RawMethodGuard;break}default:{throw throwRedacted`Unrecognized defaultGuards ${quote(defaultGuards)}`}}}prototype[prop]=bindMethod(`In ${quote(prop)} method of (${tag})`,contextProvider,behaviorMethod,methodGuard)}if(!hasOwn10(prototype,GET_INTERFACE_GUARD)){const getInterfaceGuardMethod={[GET_INTERFACE_GUARD](){return interfaceGuard}}[GET_INTERFACE_GUARD];prototype[GET_INTERFACE_GUARD]=bindMethod(`In ${quote(GET_INTERFACE_GUARD)} method of (${tag})`,contextProvider,getInterfaceGuardMethod,PassableMethodGuard)}return Far(tag,prototype)};harden(defendPrototype);var defendPrototypeKit=(tag,contextProviderKit,behaviorMethodsKit,thisfulMethods=false,interfaceGuardKit=void 0)=>{const facetNames=ownKeys19(behaviorMethodsKit).sort();facetNames.length>1||throwRedacted`A multi-facet object must have multiple facets`;if(interfaceGuardKit){const interfaceNames=ownKeys19(interfaceGuardKit);const extraInterfaceNames=listDifference(facetNames,interfaceNames);extraInterfaceNames.length===0||throwRedacted`Interfaces ${quote(extraInterfaceNames)} not implemented by ${quote(tag)}`;const extraFacetNames2=listDifference(interfaceNames,facetNames);extraFacetNames2.length===0||throwRedacted`Facets ${quote(extraFacetNames2)} of ${quote(tag)} not guarded by interfaces`}const contextMapNames=ownKeys19(contextProviderKit);const extraContextNames=listDifference(facetNames,contextMapNames);extraContextNames.length===0||throwRedacted`Contexts ${quote(extraContextNames)} not implemented by ${quote(tag)}`;const extraFacetNames=listDifference(contextMapNames,facetNames);extraFacetNames.length===0||throwRedacted`Facets ${quote(extraFacetNames)} of ${quote(tag)} missing contexts`;const protoKit=objectMap(behaviorMethodsKit,(behaviorMethods,facetName)=>defendPrototype(`${tag} ${String(facetName)}`,contextProviderKit[facetName],behaviorMethods,thisfulMethods,interfaceGuardKit&&interfaceGuardKit[facetName]));return protoKit};var{create:create3,seal,freeze:freeze7,defineProperty,values:values3}=Object;var LABEL_INSTANCES=environmentOptionsListHas("DEBUG","label-instances");var makeSelf=(proto,instanceCount)=>{const self=create3(proto);if(LABEL_INSTANCES){defineProperty(self,Symbol.toStringTag,{value:`${proto[Symbol.toStringTag]}#${instanceCount}`,writable:false,enumerable:false,configurable:false})}return harden(self)};var emptyRecord=harden({});var initEmpty=()=>emptyRecord;var defineExoClass=(tag,interfaceGuard,init,methods,options={})=>{harden(methods);const{finish=void 0,receiveAmplifier=void 0,receiveInstanceTester=void 0}=options;receiveAmplifier===void 0||throwRedacted`Only facets of an exo class kit can be amplified ${quote(tag)}`;const contextMap=new WeakMap;const proto=defendPrototype(tag,self=>contextMap.get(self),methods,true,interfaceGuard);let instanceCount=0;const makeInstance=(...args)=>{const state=seal(init(...args));instanceCount+=1;const self=makeSelf(proto,instanceCount);const context=freeze7({state,self});contextMap.set(self,context);if(finish){finish(context)}return self};if(receiveInstanceTester){const isInstance=(exo,facetName=void 0)=>{facetName===void 0||throwRedacted`facetName can only be used with an exo class kit: ${quote(tag)} has no facet ${quote(facetName)}`;return contextMap.has(exo)};harden(isInstance);receiveInstanceTester(isInstance)}return harden(makeInstance)};harden(defineExoClass);var defineExoClassKit=(tag,interfaceGuardKit,init,methodsKit,options={})=>{harden(methodsKit);const{finish=void 0,receiveAmplifier=void 0,receiveInstanceTester=void 0}=options;const contextMapKit=objectMap(methodsKit,()=>new WeakMap);const getContextKit=objectMap(contextMapKit,contextMap=>facet=>contextMap.get(facet));const prototypeKit=defendPrototypeKit(tag,getContextKit,methodsKit,true,interfaceGuardKit);let instanceCount=0;const makeInstanceKit=(...args)=>{const state=seal(init(...args));const context={state,facets:null};instanceCount+=1;const facets=objectMap(prototypeKit,(proto,facetName)=>{const self=makeSelf(proto,instanceCount);contextMapKit[facetName].set(self,context);return self});context.facets=facets;freeze7(context);if(finish){finish(context)}return context.facets};if(receiveAmplifier){const amplify=exoFacet=>{for(const contextMap of values3(contextMapKit)){if(contextMap.has(exoFacet)){const{facets}=contextMap.get(exoFacet);return facets}}throw throwRedacted`Must be a facet of ${quote(tag)}: ${exoFacet}`};harden(amplify);receiveAmplifier(amplify)}if(receiveInstanceTester){const isInstance=(exoFacet,facetName=void 0)=>{if(facetName===void 0){return values3(contextMapKit).some(contextMap2=>contextMap2.has(exoFacet))}assert.typeof(facetName,"string");const contextMap=contextMapKit[facetName];contextMap!==void 0||throwRedacted`exo class kit ${quote(tag)} has no facet named ${quote(facetName)}`;return contextMap.has(exoFacet)};harden(isInstance);receiveInstanceTester(isInstance)}return harden(makeInstanceKit)};harden(defineExoClassKit);var makeExo=(tag,interfaceGuard,methods,options=void 0)=>{const makeInstance=defineExoClass(tag,interfaceGuard,initEmpty,methods,options);return makeInstance()};harden(makeExo);var makeLegacyMap=(tag="key")=>{const m=new Map;const assertKeyDoesNotExist=key=>!m.has(key)||throwRedacted`${quote(tag)} already registered: ${key}`;const assertKeyExists=key=>m.has(key)||throwRedacted`${quote(tag)} not found: ${key}`;return harden({has:key=>{return m.has(key)},init:(key,value)=>{assertKeyDoesNotExist(key);m.set(key,value)},get:key=>{assertKeyExists(key);return m.get(key)},set:(key,value)=>{assertKeyExists(key);m.set(key,value)},delete:key=>{assertKeyExists(key);m.delete(key)},keys:()=>m.keys(),values:()=>m.values(),entries:()=>m.entries(),getSize:()=>m.size,clear:()=>m.clear()})};harden(makeLegacyMap);var makeLegacyWeakMap=(tag="key")=>{const wm=new WeakMap;const assertKeyDoesNotExist=key=>!wm.has(key)||throwRedacted`${quote(tag)} already registered: ${key}`;const assertKeyExists=key=>wm.has(key)||throwRedacted`${quote(tag)} not found: ${key}`;return harden({has:key=>{return wm.has(key)},init:(key,value)=>{assertKeyDoesNotExist(key);wm.set(key,value)},get:key=>{assertKeyExists(key);return wm.get(key)},set:(key,value)=>{assertKeyExists(key);wm.set(key,value)},delete:key=>{assertKeyExists(key);wm.delete(key)}})};harden(makeLegacyWeakMap);var mustMatch2=mustMatch;var empty=0n;var natMathHelpers=harden({doCoerce:nat=>{assert.typeof(nat,"bigint");isNat(nat)||throwRedacted`value ${nat} must be a natural number`;return Nat(nat)},doMakeEmpty:()=>empty,doIsEmpty:nat=>nat===empty,doIsGTE:(left,right)=>left>=right,doIsEqual:(left,right)=>left===right,doAdd:(left,right)=>left+right,doSubtract:(left,right)=>Nat(left-right)});var empty2=harden([]);var setMathHelpers=harden({doCoerce:list=>{list=coerceToElements(list);assertKey(list);return list},doMakeEmpty:()=>empty2,doIsEmpty:list=>passStyleOf(list)==="copyArray"&&list.length===0,doIsGTE:elementsIsSuperset,doIsEqual:(x,y)=>elementsCompare(x,y)===0,doAdd:elementsDisjointUnion,doSubtract:elementsDisjointSubtract});var empty3=makeCopySet([]);var copySetMathHelpers=harden({doCoerce:set=>{mustMatch2(set,M.set(),"set of amount");return set},doMakeEmpty:()=>empty3,doIsEmpty:set=>getCopySetKeys(set).length===0,doIsGTE:setIsSuperset,doIsEqual:keyEQ,doAdd:setDisjointUnion,doSubtract:setDisjointSubtract});var empty4=makeCopyBag([]);var copyBagMathHelpers=harden({doCoerce:bag=>{mustMatch2(bag,M.bag(),"bag of amount");return bag},doMakeEmpty:()=>empty4,doIsEmpty:bag=>getCopyBagEntries(bag).length===0,doIsGTE:bagIsSuperbag,doIsEqual:keyEQ,doAdd:bagUnion,doSubtract:bagDisjointSubtract});var AssetKind={NAT:"nat",SET:"set",COPY_SET:"copySet",COPY_BAG:"copyBag"};harden(AssetKind);var assetKindNames=harden(Object.values(AssetKind).sort());var assertAssetKind=allegedAK=>{assetKindNames.includes(allegedAK)||throwRedacted`The assetKind ${allegedAK} must be one of ${quote(assetKindNames)}`};harden(assertAssetKind);var helpers={nat:natMathHelpers,set:setMathHelpers,copySet:copySetMathHelpers,copyBag:copyBagMathHelpers};var assertValueGetAssetKind=value=>{const passStyle=passStyleOf(value);if(passStyle==="bigint"){return"nat"}if(passStyle==="copyArray"){return"set"}if(matches(value,M.set())){return"copySet"}if(matches(value,M.bag())){return"copyBag"}throw throwRedacted`value ${value} must be a bigint, copySet, copyBag, or an array, not ${quote(passStyle)}`};var assertValueGetHelpers=value=>helpers[assertValueGetAssetKind(value)];var optionalBrandCheck=(allegedBrand,brand)=>{if(brand!==void 0){assertRemotable(brand,"brand");allegedBrand===brand||throwRedacted`amount's brand ${quote(allegedBrand)} did not match expected brand ${quote(brand)}`}};var checkLRAndGetHelpers=(leftAmount,rightAmount,brand=void 0)=>{assertRecord(leftAmount,"leftAmount");assertRecord(rightAmount,"rightAmount");const{value:leftValue,brand:leftBrand}=leftAmount;const{value:rightValue,brand:rightBrand}=rightAmount;assertRemotable(leftBrand,"leftBrand");assertRemotable(rightBrand,"rightBrand");optionalBrandCheck(leftBrand,brand);optionalBrandCheck(rightBrand,brand);leftBrand===rightBrand||throwRedacted`Brands in left ${quote(leftBrand)} and right ${quote(rightBrand)} should match but do not`;const leftHelpers=assertValueGetHelpers(leftValue);const rightHelpers=assertValueGetHelpers(rightValue);leftHelpers===rightHelpers||throwRedacted`The left ${leftAmount} and right amount ${rightAmount} had different assetKinds`;return leftHelpers};var coerceLR=(h,leftAmount,rightAmount)=>{return[h.doCoerce(leftAmount.value),h.doCoerce(rightAmount.value)]};var isGTE=(leftAmount,rightAmount,brand=void 0)=>{const h=checkLRAndGetHelpers(leftAmount,rightAmount,brand);return h.doIsGTE(...coerceLR(h,leftAmount,rightAmount))};var AmountMath={make:(brand,allegedValue)=>{assertRemotable(brand,"brand");const h=assertValueGetHelpers(allegedValue);const value=h.doCoerce(allegedValue);return harden({brand,value})},coerce:(brand,allegedAmount)=>{assertRemotable(brand,"brand");assertRecord(allegedAmount,"amount");const{brand:allegedBrand,value:allegedValue}=allegedAmount;brand===allegedBrand||throwRedacted`The brand in the allegedAmount ${allegedAmount} in 'coerce' didn't match the specified brand ${brand}.`;return AmountMath.make(brand,allegedValue)},getValue:(brand,amount)=>AmountMath.coerce(brand,amount).value,makeEmpty:(brand,assetKind="nat")=>{assertRemotable(brand,"brand");assertAssetKind(assetKind);const value=helpers[assetKind].doMakeEmpty();return harden({brand,value})},makeEmptyFromAmount:amount=>{assertRecord(amount,"amount");const{brand,value}=amount;const assetKind=assertValueGetAssetKind(value);return AmountMath.makeEmpty(brand,assetKind)},isEmpty:(amount,brand=void 0)=>{assertRecord(amount,"amount");const{brand:allegedBrand,value}=amount;assertRemotable(allegedBrand,"brand");optionalBrandCheck(allegedBrand,brand);const h=assertValueGetHelpers(value);return h.doIsEmpty(h.doCoerce(value))},isGTE,isEqual:(leftAmount,rightAmount,brand=void 0)=>{const h=checkLRAndGetHelpers(leftAmount,rightAmount,brand);return h.doIsEqual(...coerceLR(h,leftAmount,rightAmount))},add:(leftAmount,rightAmount,brand=void 0)=>{const h=checkLRAndGetHelpers(leftAmount,rightAmount,brand);const value=h.doAdd(...coerceLR(h,leftAmount,rightAmount));return harden({brand:leftAmount.brand,value})},subtract:(leftAmount,rightAmount,brand=void 0)=>{const h=checkLRAndGetHelpers(leftAmount,rightAmount,brand);const value=h.doSubtract(...coerceLR(h,leftAmount,rightAmount));return harden({brand:leftAmount.brand,value})},min:(x,y,brand=void 0)=>isGTE(x,y,brand)?y:isGTE(y,x,brand)?x:throwRedacted`${x} and ${y} are incomparable`,max:(x,y,brand=void 0)=>isGTE(x,y,brand)?x:isGTE(y,x)?y:throwRedacted`${x} and ${y} are incomparable`};harden(AmountMath);var getAssetKind=amount=>{assertRecord(amount,"amount");const{value}=amount;return assertValueGetAssetKind(value)};harden(getAssetKind);var VatDataGlobal;if("VatData"in globalThis){globalThis.VatData||throwRedacted`VatData defined in global as null or undefined`;VatDataGlobal=globalThis.VatData}else{const unavailable=()=>throwRedacted`VatData unavailable`;VatDataGlobal={defineKind:unavailable,defineKindMulti:unavailable,defineDurableKind:unavailable,defineDurableKindMulti:unavailable,makeKindHandle:unavailable,providePromiseWatcher:unavailable,watchPromise:unavailable,makeScalarBigMapStore:unavailable,makeScalarBigWeakMapStore:unavailable,makeScalarBigSetStore:unavailable,makeScalarBigWeakSetStore:unavailable,canBeDurable:unavailable}}var VatDataExport=VatDataGlobal;var{defineKind,defineKindMulti,defineDurableKind,defineDurableKindMulti}=VatDataGlobal;var{makeKindHandle,providePromiseWatcher,watchPromise,makeScalarBigMapStore,makeScalarBigWeakMapStore,makeScalarBigSetStore,makeScalarBigWeakSetStore,canBeDurable}=VatDataGlobal;var pickFacet=(maker,facetName)=>(...args)=>maker(...args)[facetName];harden(pickFacet);var partialAssign=(target,source)=>{Object.assign(target,source)};harden(partialAssign);var provide=provideLazy;var makeStoreUtils=VatData=>{const{makeScalarBigMapStore:makeScalarBigMapStore2,makeScalarBigWeakMapStore:makeScalarBigWeakMapStore2,makeScalarBigSetStore:makeScalarBigSetStore2,makeScalarBigWeakSetStore:makeScalarBigWeakSetStore2}=VatData;const provideDurableMapStore2=(baggage,name,options={})=>provide(baggage,name,()=>makeScalarBigMapStore2(name,{durable:true,...options}));harden(provideDurableMapStore2);const provideDurableWeakMapStore2=(baggage,name,options={})=>provide(baggage,name,()=>makeScalarBigWeakMapStore2(name,{durable:true,...options}));harden(provideDurableWeakMapStore2);const provideDurableSetStore2=(baggage,name,options={})=>provide(baggage,name,()=>makeScalarBigSetStore2(name,{durable:true,...options}));harden(provideDurableSetStore2);const provideDurableWeakSetStore2=(baggage,name,options={})=>provide(baggage,name,()=>makeScalarBigWeakSetStore2(name,{durable:true,...options}));harden(provideDurableWeakSetStore2);return harden({provideDurableMapStore:provideDurableMapStore2,provideDurableWeakMapStore:provideDurableWeakMapStore2,provideDurableSetStore:provideDurableSetStore2,provideDurableWeakSetStore:provideDurableWeakSetStore2})};var globalStoreUtils=makeStoreUtils(VatDataGlobal);var{provideDurableMapStore,provideDurableWeakMapStore,provideDurableSetStore,provideDurableWeakSetStore}=globalStoreUtils;var ignoreContext=fn=>(_context,...args)=>fn(...args);harden(ignoreContext);var makeExoUtils=VatData=>{const{defineKind:defineKind2,defineKindMulti:defineKindMulti2,defineDurableKind:defineDurableKind2,defineDurableKindMulti:defineDurableKindMulti2,makeKindHandle:makeKindHandle2}=VatData;const provideKindHandle2=(baggage,kindName)=>provide(baggage,`${kindName}_kindHandle`,()=>makeKindHandle2(kindName));harden(provideKindHandle2);const prepareKind2=(baggage,kindName,init,behavior,options=void 0)=>defineDurableKind2(provideKindHandle2(baggage,kindName),init,behavior,options);harden(prepareKind2);const prepareKindMulti2=(baggage,kindName,init,behavior,options=void 0)=>defineDurableKindMulti2(provideKindHandle2(baggage,kindName),init,behavior,options);harden(prepareKindMulti2);const defineVirtualExoClass2=(tag,interfaceGuard,init,methods,options)=>defineKind2(tag,init,methods,{...options,thisfulMethods:true,interfaceGuard});harden(defineVirtualExoClass2);const defineVirtualExoClassKit2=(tag,interfaceGuardKit,init,facets,options)=>defineKindMulti2(tag,init,facets,{...options,thisfulMethods:true,interfaceGuardKit});harden(defineVirtualExoClassKit2);const defineDurableExoClass2=(kindHandle,interfaceGuard,init,methods,options)=>defineDurableKind2(kindHandle,init,methods,{...options,thisfulMethods:true,interfaceGuard});harden(defineDurableExoClass2);const defineDurableExoClassKit2=(kindHandle,interfaceGuardKit,init,facets,options)=>defineDurableKindMulti2(kindHandle,init,facets,{...options,thisfulMethods:true,interfaceGuardKit});harden(defineDurableExoClassKit2);const prepareExoClass2=(baggage,kindName,interfaceGuard,init,methods,options=void 0)=>defineDurableExoClass2(provideKindHandle2(baggage,kindName),interfaceGuard,init,methods,options);harden(prepareExoClass2);const prepareExoClassKit2=(baggage,kindName,interfaceGuardKit,init,facets,options=void 0)=>defineDurableExoClassKit2(provideKindHandle2(baggage,kindName),interfaceGuardKit,init,facets,options);harden(prepareExoClassKit2);const prepareExo2=(baggage,kindName,interfaceGuard,methods,options=void 0)=>{const makeSingleton=prepareExoClass2(baggage,kindName,interfaceGuard,initEmpty,methods,options);return provide(baggage,`${kindName}_singleton`,()=>makeSingleton())};harden(prepareExo2);const prepareSingleton2=(baggage,kindName,methods,options=void 0)=>prepareExo2(baggage,kindName,void 0,methods,options);harden(prepareSingleton2);return harden({defineVirtualExoClass:defineVirtualExoClass2,defineVirtualExoClassKit:defineVirtualExoClassKit2,defineDurableExoClass:defineDurableExoClass2,defineDurableExoClassKit:defineDurableExoClassKit2,prepareExoClass:prepareExoClass2,prepareExoClassKit:prepareExoClassKit2,prepareExo:prepareExo2,prepareSingleton:prepareSingleton2,provideKindHandle:provideKindHandle2,prepareKind:prepareKind2,prepareKindMulti:prepareKindMulti2})};var globalExoUtils=makeExoUtils(VatDataExport);var{defineVirtualExoClass,defineVirtualExoClassKit,defineDurableExoClass,defineDurableExoClassKit,prepareExoClass,prepareExoClassKit,prepareExo,prepareSingleton}=globalExoUtils;var{provideKindHandle,prepareKind,prepareKindMulti}=globalExoUtils;var defaultLabelToKeys=label=>harden([label]);harden(defaultLabelToKeys);var makeOnceKit=(debugName,stores,backingStore=void 0)=>{const usedKeys=stores.detached().setStore(`${debugName} used keys`);const assertOnlyOnce=key=>{typeof key==="string"||throwRedacted`key ${key} must be a string`;!usedKeys.has(key)||throwRedacted`key ${key} has already been used in this zone and incarnation`;usedKeys.add(key)};const wrapProvider=(provider,labelToKeys=defaultLabelToKeys)=>{const wrapper=(label,...rest)=>{for(const key of labelToKeys(label)){assertOnlyOnce(key)}return provider(label,...rest)};return wrapper};const makeOnce=(key,maker)=>{assertOnlyOnce(key);if(backingStore&&backingStore.has(key)){return backingStore.get(key)}const value=maker(key);stores.isStorable(value)||throwRedacted`maker return value ${value} is not storable`;backingStore&&backingStore.init(key,value);return value};return harden({makeOnce,wrapProvider})};harden(makeOnceKit);var kind=label=>`${label}_kindHandle`;var singleton=label=>`${label}_singleton`;var agoricVatDataKeys={exoClass:label=>harden([kind(label)]),exoClassKit:label=>harden([kind(label)]),exo:label=>harden([kind(label),singleton(label)]),store:label=>harden([label]),zone:label=>harden([label])};harden(agoricVatDataKeys);var{apply:apply6}=Reflect;var PromiseWatcherHandler=M.call(M.raw()).rest(M.raw()).returns();var PromiseWatcherI=M.interface("PromiseWatcher",{onFulfilled:PromiseWatcherHandler,onRejected:PromiseWatcherHandler});var PromiseWatcherFulfilledI=M.interface("PromiseWatcherFulfilled",{onFulfilled:PromiseWatcherHandler});var PromiseWatcherRejectedI=M.interface("PromiseWatcherRejected",{onRejected:PromiseWatcherHandler});var callMeMaybe=(that,prop,postArgs)=>{const fn=that[prop];if(!fn){return void 0}assert.typeof(fn,"function");const wrapped=arg=>{apply6(fn,that,[arg,...postArgs])};return wrapped};var watchPromise2=(p,watcher,...watcherArgs)=>{Promise.resolve(p)===p||throwRedacted`watchPromise only watches promises`;const onFulfilled=callMeMaybe(watcher,"onFulfilled",watcherArgs);const onRejected=callMeMaybe(watcher,"onRejected",watcherArgs);onFulfilled||onRejected||throwRedacted`promise watcher must implement at least one handler method`;void E.when(p,onFulfilled,onRejected)};harden(watchPromise2);var isStorable=specimen=>isPassable(specimen)&&canBeDurable(specimen);harden(isStorable);var attachDurableStores=getBaggage=>{const mapStore=(label,options)=>{const baggage=getBaggage();const ret=provideDurableMapStore(baggage,label,options);return ret};const setStore=(label,options)=>provideDurableSetStore(getBaggage(),label,options);const weakSetStore=(label,options)=>provideDurableWeakSetStore(getBaggage(),label,options);const weakMapStore=(label,options)=>provideDurableWeakMapStore(getBaggage(),label,options);return Far("durableStores",{detached:()=>detachedDurableStores,isStorable,mapStore,setStore,weakMapStore,weakSetStore})};var detachedDurableStores=attachDurableStores(()=>makeScalarMapStore("detached"));var makeDurableZone=(baggage,baseLabel="durableZone")=>{baggage||throwRedacted`baggage required`;const attachedStores=attachDurableStores(()=>baggage);const{makeOnce,wrapProvider}=makeOnceKit(baseLabel,attachedStores,baggage);const exoClass=(...args)=>prepareExoClass(baggage,...args);const exoClassKit=(...args)=>prepareExoClassKit(baggage,...args);const exo=(...args)=>prepareExo(baggage,...args);const subZoneStore=wrapProvider(attachedStores.mapStore,agoricVatDataKeys.zone);const subZone=(label,options={})=>{const subBaggage=subZoneStore(label,options);return makeDurableZone(subBaggage,`${baseLabel}.${label}`)};return Far("durableZone",{exo:wrapProvider(exo,agoricVatDataKeys.exo),exoClass:wrapProvider(exoClass,agoricVatDataKeys.exoClass),exoClassKit:wrapProvider(exoClassKit,agoricVatDataKeys.exoClassKit),subZone,makeOnce,watchPromise,detached:attachedStores.detached,isStorable:attachedStores.isStorable,mapStore:wrapProvider(attachedStores.mapStore,agoricVatDataKeys.store),setStore:wrapProvider(attachedStores.setStore,agoricVatDataKeys.store),weakMapStore:wrapProvider(attachedStores.weakMapStore,agoricVatDataKeys.store),weakSetStore:wrapProvider(attachedStores.weakSetStore,agoricVatDataKeys.store)})};harden(makeDurableZone);var BrandShape=M.remotable("Brand");var IssuerShape=M.remotable("Issuer");var PaymentShape=M.remotable("Payment");var PurseShape=M.remotable("Purse");var DepositFacetShape=M.remotable("DepositFacet");var NotifierShape=M.remotable("Notifier");var MintShape=M.remotable("Mint");var NatValueShape=M.nat();var CopySetValueShape=M.set();var SetValueShape=M.arrayOf(M.key());var CopyBagValueShape=M.bag();var AmountValueShape=M.or(NatValueShape,CopySetValueShape,SetValueShape,CopyBagValueShape);var AmountShape={brand:BrandShape,value:AmountValueShape};harden(AmountShape);var AmountPatternShape=M.pattern();var RatioShape={numerator:AmountShape,denominator:AmountShape};harden(RatioShape);var isNatValue=value=>matches(value,NatValueShape);harden(isNatValue);var isCopySetValue=value=>matches(value,CopySetValueShape);harden(isCopySetValue);var isSetValue=value=>matches(value,SetValueShape);harden(isSetValue);var isCopyBagValue=value=>matches(value,CopyBagValueShape);harden(isCopyBagValue);var MAX_ABSOLUTE_DECIMAL_PLACES=100;var AssetKindShape=M.or("nat","set","copySet","copyBag");var DisplayInfoShape=M.splitRecord({},{decimalPlaces:M.and(M.gte(-MAX_ABSOLUTE_DECIMAL_PLACES),M.lte(MAX_ABSOLUTE_DECIMAL_PLACES)),assetKind:AssetKindShape},{});var IssuerKitShape={brand:BrandShape,mint:MintShape,mintRecoveryPurse:PurseShape,issuer:IssuerShape,displayInfo:DisplayInfoShape};harden(IssuerKitShape);var BrandI=M.interface("Brand",{isMyIssuer:M.callWhen(M.await(IssuerShape)).returns(M.boolean()),getAllegedName:M.call().returns(M.string()),getDisplayInfo:M.call().returns(DisplayInfoShape),getAmountShape:M.call().returns(M.pattern())});var makeIssuerInterfaces=(brandShape=BrandShape,assetKindShape=AssetKindShape,amountShape=AmountShape)=>{const IssuerI=M.interface("Issuer",{getBrand:M.call().returns(brandShape),getAllegedName:M.call().returns(M.string()),getAssetKind:M.call().returns(assetKindShape),getDisplayInfo:M.call().returns(DisplayInfoShape),makeEmptyPurse:M.call().returns(PurseShape),isLive:M.callWhen(M.await(PaymentShape)).returns(M.boolean()),getAmountOf:M.callWhen(M.await(PaymentShape)).returns(amountShape),burn:M.callWhen(M.await(PaymentShape)).optional(AmountPatternShape).returns(amountShape)});const MintI=M.interface("Mint",{getIssuer:M.call().returns(IssuerShape),mintPayment:M.call(amountShape).returns(PaymentShape)});const PaymentI=M.interface("Payment",{getAllegedBrand:M.call().returns(brandShape)});const PurseI=M.interface("Purse",{getAllegedBrand:M.call().returns(brandShape),getCurrentAmount:M.call().returns(amountShape),getCurrentAmountNotifier:M.call().returns(NotifierShape),deposit:M.call(PaymentShape).optional(AmountPatternShape).returns(amountShape),getDepositFacet:M.call().returns(DepositFacetShape),withdraw:M.call(amountShape).returns(PaymentShape),getRecoverySet:M.call().returns(M.setOf(PaymentShape)),recoverAll:M.call().returns(amountShape)});const DepositFacetI=M.interface("DepositFacet",{receive:getInterfaceGuardPayload(PurseI).methodGuards.deposit});const PurseIKit={purse:PurseI,depositFacet:DepositFacetI};harden(PurseIKit);return harden({IssuerI,MintI,PaymentI,PurseIKit})};harden(makeIssuerInterfaces);var coerceDisplayInfo=(allegedDisplayInfo,assetKind)=>{mustMatch2(allegedDisplayInfo,DisplayInfoShape,"displayInfo");if(allegedDisplayInfo.assetKind!==void 0){allegedDisplayInfo.assetKind===assetKind||throwRedacted`displayInfo.assetKind was present (${allegedDisplayInfo.assetKind}) and did not match the assetKind argument (${assetKind})`}const displayInfo=harden({...allegedDisplayInfo,assetKind});if(displayInfo.decimalPlaces!==void 0){Number.isSafeInteger(displayInfo.decimalPlaces)||throwRedacted`decimalPlaces ${displayInfo.decimalPlaces} is not a safe integer`}return displayInfo};var preparePaymentKind=(issuerZone,name,brand,PaymentI)=>{const makePayment=issuerZone.exoClass(`${name} payment`,PaymentI,initEmpty,{getAllegedBrand(){return brand}});return makePayment};harden(preparePaymentKind);var sink=()=>{};var makeQuietRejection=reason=>{const rejection=harden(Promise.reject(reason));void E.when(rejection,sink,sink);return rejection};var tooFarRejection=makeQuietRejection(harden(Error("Cannot read past end of iteration.")));var PublisherI=M.interface("Publisher",{publish:M.call(M.any()).returns(),finish:M.call(M.any()).returns(),fail:M.call(M.any()).returns()});var UpdateCountShape=M.or(M.bigint(),M.number());var SubscriberI=M.interface("Subscriber",{subscribeAfter:M.call().optional(M.bigint()).returns(M.promise()),getUpdateSince:M.call().optional(UpdateCountShape).returns(M.promise())});var publishKitIKit=harden({publisher:PublisherI,subscriber:SubscriberI});var ForkableAsyncIterableIteratorShape=M.interface("ForkableAsyncIterableIterator",{fork:M.call().returns(M.any()),[Symbol.asyncIterator]:M.call().returns(M.any()),next:M.callWhen().returns(M.any())});var IterableEachTopicI=M.interface("IterableEachTopic",{subscribeAfter:getInterfaceGuardPayload(SubscriberI).methodGuards.subscribeAfter,[Symbol.asyncIterator]:M.call().returns(M.remotable("ForkableAsyncIterableIterator"))});var IterableLatestTopicI=M.interface("IterableLatestTopic",{getUpdateSince:getInterfaceGuardPayload(SubscriberI).methodGuards.getUpdateSince,[Symbol.asyncIterator]:M.call().returns(M.remotable("ForkableAsyncIterableIterator"))});var weakMemoizeUnary=fn=>{const cache=new WeakMap;return arg=>{const oarg=arg;if(cache.has(oarg)){return cache.get(oarg)}const result=fn(arg);cache.set(oarg,result);return result}};var makeUpdateRecordFromPublicationRecord=record=>{const{head:{value,done},publishCount}=record;if(done){return harden({value,updateCount:void 0})}return harden({value,updateCount:publishCount})};var makePublishKit=()=>{let tailP;let tailR;({promise:tailP,resolve:tailR}=makePromiseKit());let currentPublishCount=0n;let currentP=tailP;const advanceCurrent=(done,value,rejection)=>{if(tailR===void 0){throw Error("Cannot update state after termination.")}currentPublishCount+=1n;currentP=tailP;const resolveCurrent=tailR;if(done){tailP=tooFarRejection;tailR=void 0}else{({promise:tailP,resolve:tailR}=makePromiseKit())}if(rejection){resolveCurrent(rejection)}else{resolveCurrent(harden({head:{value,done},publishCount:currentPublishCount,tail:tailP}))}};const makeMemoizedUpdateRecord=weakMemoizeUnary(makeUpdateRecordFromPublicationRecord);const subscriber=Far("Subscriber",{subscribeAfter:(publishCount=-1n)=>{assert.typeof(publishCount,"bigint");if(publishCount===currentPublishCount){return tailP}else if(publishCount<currentPublishCount){return currentP}else{throw Error("subscribeAfter argument must be a previously-issued publishCount.")}},getUpdateSince:updateCount=>{if(updateCount===void 0){return subscriber.subscribeAfter().then(makeMemoizedUpdateRecord)}updateCount=BigInt(updateCount);return subscriber.subscribeAfter(updateCount).then(()=>subscriber.getUpdateSince())}});const publisher=Far("Publisher",{publish:value=>{advanceCurrent(false,value)},finish:finalValue=>{advanceCurrent(true,finalValue)},fail:reason=>{advanceCurrent(true,void 0,makeQuietRejection(reason))}});return harden({publisher,subscriber})};harden(makePublishKit);var DurablePublishKitStateShape=harden({valueDurability:M.any(),publishCount:M.any(),status:M.any(),hasValue:M.any(),value:M.any()});var initDurablePublishKitState=(options={})=>{const{valueDurability="mandatory"}=options;assert.equal(valueDurability,"mandatory");return{valueDurability,publishCount:0n,status:"live",hasValue:false,value:void 0}};var getEphemeralKey=facets=>facets.publisher;var durablePublishKitEphemeralData=new WeakMap;var provideCurrentP=(state,facets,tail)=>{const ephemeralKey=getEphemeralKey(facets);const foundData=durablePublishKitEphemeralData.get(ephemeralKey);const currentP=foundData&&foundData.currentP;if(currentP){return currentP}const{publishCount,status,hasValue,value}=state;if(!hasValue){assert(status==="live");return tail}if(status==="live"||status==="finished"){const cell=harden({head:{value,done:status!=="live"},publishCount,tail});return E.resolve(cell)}else if(status==="failed"){return makeQuietRejection(value)}else{throw throwRedacted`Invalid durable promise kit status: ${quote(status)}`}};var provideDurablePublishKitEphemeralData=(state,facets)=>{const ephemeralKey=getEphemeralKey(facets);const foundData=durablePublishKitEphemeralData.get(ephemeralKey);if(foundData){return foundData}const{status}=state;let tailP;let tailR;if(status==="live"){({promise:tailP,resolve:tailR}=makePromiseKit());void E.when(tailP,sink,sink)}else if(status==="finished"||status==="failed"){tailP=tooFarRejection}else{throw throwRedacted`Invalid durable promise kit status: ${quote(status)}`}const obj=harden({currentP:void 0,tailP,tailR});durablePublishKitEphemeralData.set(ephemeralKey,obj);return obj};var advanceDurablePublishKit=(context,value,targetStatus="live")=>{const{state,facets}=context;const{valueDurability,status}=state;if(status!=="live"){throw Error("Cannot update state after termination.")}const done=targetStatus!=="live";if(done||valueDurability==="mandatory"){canBeDurable(value)||throwRedacted`Cannot accept non-durable value: ${value}`}const{tailP:oldTailP,tailR:resolveOldTail}=provideDurablePublishKitEphemeralData(state,facets);assert.typeof(resolveOldTail,"function");const publishCount=state.publishCount+1n;state.publishCount=publishCount;let tailP;let tailR;if(done){state.status=targetStatus;tailP=tooFarRejection;tailR=void 0}else{({promise:tailP,resolve:tailR}=makePromiseKit());void E.when(tailP,sink,sink)}let currentP;if(targetStatus==="failed"){state.hasValue=true;state.value=value;const rejection=makeQuietRejection(value);resolveOldTail(rejection)}else{if(done||valueDurability!=="ignored"&&canBeDurable(value)){state.hasValue=true;state.value=value}else{state.hasValue=false;state.value=void 0;currentP=oldTailP}resolveOldTail(harden({head:{value,done},publishCount,tail:tailP}))}durablePublishKitEphemeralData.set(getEphemeralKey(facets),harden({currentP,tailP,tailR}))};var prepareDurablePublishKit=(baggage,kindName)=>{const makeMemoizedUpdateRecord=makeUpdateRecordFromPublicationRecord;return prepareExoClassKit(baggage,kindName,publishKitIKit,initDurablePublishKitState,{publisher:{publish(value){advanceDurablePublishKit(this,value)},finish(finalValue){advanceDurablePublishKit(this,finalValue,"finished")},fail(reason){advanceDurablePublishKit(this,reason,"failed")}},subscriber:{subscribeAfter(publishCount=-1n){const{state,facets}=this;const{publishCount:currentPublishCount}=state;const{currentP,tailP}=provideDurablePublishKitEphemeralData(state,facets);if(publishCount===currentPublishCount){return tailP}else if(publishCount<currentPublishCount){return currentP||provideCurrentP(state,facets,tailP)}else{throw Error("subscribeAfter argument must be a previously-issued publishCount.")}},getUpdateSince(updateCount){const{facets:{subscriber}}=this;if(updateCount===void 0){return subscriber.subscribeAfter().then(makeMemoizedUpdateRecord)}updateCount=BigInt(updateCount);return subscriber.subscribeAfter(updateCount).then(()=>subscriber.getUpdateSince())}}},{stateShape:DurablePublishKitStateShape})};harden(prepareDurablePublishKit);var SubscriberShape=M.remotable("Subscriber");var{isFrozen:isFrozen6}=Object;var UpgradeDisconnectionShape=harden({name:"vatUpgraded",upgradeMessage:M.string(),incarnationNumber:M.number()});var makeUpgradeDisconnection=(upgradeMessage,toIncarnationNumber)=>harden({name:"vatUpgraded",upgradeMessage,incarnationNumber:toIncarnationNumber});harden(makeUpgradeDisconnection);var isUpgradeDisconnection=reason=>reason!=null&&isFrozen6(reason)&&matches(reason,UpgradeDisconnectionShape);harden(isUpgradeDisconnection);var isAbandonedError=reason=>reason!=null&&isFrozen6(reason)&&matches(reason,M.error())&&reason.message==="vat terminated";harden(isAbandonedError);var sink2=()=>{};var reconnectAsNeeded=async(getter,seed=[])=>{let disconnection;let lastVersion=-Infinity;await null;for(let i=0;;i+=1){try{const resultP=i<seed.length?seed[i]:getter();const result=await resultP;return result}catch(err){if(isUpgradeDisconnection(err)){if(!disconnection){disconnection=err}const{incarnationNumber:version}=err;if(version>lastVersion){lastVersion=version;continue}}if(!isPrimitive2(err)&&disconnection&&disconnection!==err){try{note(err,redacted`Attempting to recover from disconnection: ${disconnection}`)}catch(_err){}}throw err}}};var makeEachIterator=(topic,nextCellP)=>{const self=Far("EachIterator",{[Symbol.asyncIterator]:()=>self,next:()=>{const{head:resultP,publishCount:publishCountP,tail:tailP}=E.get(nextCellP);const getSuccessor=async()=>{const publishCount=await publishCountP;assert.typeof(publishCount,"bigint");const successor=await E(topic).subscribeAfter(publishCount);const newPublishCount=successor.publishCount;if(newPublishCount!==publishCount+1n){throwRedacted`eachIterator broken by gap from publishCount ${publishCount} to ${newPublishCount}`}return successor};nextCellP=reconnectAsNeeded(getSuccessor,[tailP]);void E.when(publishCountP,sink2,sink2);void E.when(nextCellP,sink2,sink2);return resultP},fork:()=>makeEachIterator(topic,nextCellP)});return self};var subscribeEach=topic=>{const iterable=Far("EachIterable",{[Symbol.asyncIterator]:()=>{const firstCellP=reconnectAsNeeded(()=>E(topic).subscribeAfter());return makeEachIterator(topic,firstCellP)}});return iterable};harden(subscribeEach);var cloneLatestIterator=(topic,localUpdateCount,terminalResult)=>{let mutex=Promise.resolve();const maybeRequestNextResult=async()=>{if(terminalResult){return terminalResult}const{value,updateCount}=await reconnectAsNeeded(()=>E(topic).getUpdateSince(localUpdateCount));localUpdateCount=updateCount;if(updateCount===void 0){terminalResult=harden({done:true,value});return terminalResult}return harden({done:false,value})};const self=Far("LatestIterator",{fork:()=>cloneLatestIterator(topic,localUpdateCount,terminalResult),[Symbol.asyncIterator]:()=>self,next:async()=>{if(terminalResult){return terminalResult}const nextResult=mutex.then(maybeRequestNextResult);mutex=nextResult.then(sink2,sink2);return nextResult}});return self};var makeLatestIterator=topic=>cloneLatestIterator(topic);var subscribeLatest=topic=>{const iterable=Far("LatestIterable",{[Symbol.asyncIterator]:()=>makeLatestIterator(topic)});return iterable};harden(subscribeLatest);var makeNotifier=sharableInternalsP=>{const notifier=Far("notifier",{...subscribeLatest(sharableInternalsP),getUpdateSince:async updateCount=>E(sharableInternalsP).getUpdateSince(updateCount),getSharableNotifierInternals:async()=>sharableInternalsP,getStoreKey:()=>harden({notifier})});return notifier};var makeNotifierFromSubscriber=subscriber=>{const baseNotifier=harden({getUpdateSince:(updateCount=void 0)=>E(subscriber).getUpdateSince(updateCount)});const notifier=Far("notifier",{...makeNotifier(baseNotifier),...baseNotifier});return notifier};harden(makeNotifierFromSubscriber);var makeNotifierKit=(...initialStateArr)=>{const{publisher,subscriber}=makePublishKit();const notifier=makeNotifierFromSubscriber(subscriber);const updater=Far("updater",{updateState:state=>publisher.publish(state),finish:completion=>publisher.finish(completion),fail:reason=>publisher.fail(reason)});assert2(initialStateArr.length<=1,"too many arguments");if(initialStateArr.length===1){updater.updateState(initialStateArr[0])}return harden({notifier,updater})};var makeNotifierFromAsyncIterable=asyncIterableP=>{const iteratorP=E(asyncIterableP)[Symbol.asyncIterator]();let optNextPromise;let currentUpdateCount=0n;let currentResponse;let final=false;const baseNotifier=Far("baseNotifier",{getUpdateSince(updateCount=-1n){if(updateCount<currentUpdateCount){if(currentResponse){return Promise.resolve(currentResponse)}}else if(updateCount!==currentUpdateCount){throw Error("getUpdateSince argument must be a previously-issued updateCount.")}if(final){assert2(currentResponse!==void 0);return Promise.resolve(currentResponse)}if(!optNextPromise){const nextIterResultP=E(iteratorP).next();optNextPromise=E.when(nextIterResultP,({done,value})=>{assert2(!final);if(done){final=true}currentUpdateCount+=1n;currentResponse=harden({value,updateCount:done?void 0:currentUpdateCount});optNextPromise=void 0;return currentResponse},_reason=>{final=true;currentResponse=nextIterResultP;optNextPromise=void 0;return currentResponse})}return optNextPromise}});const notifier=Far("notifier",{...makeNotifier(baseNotifier),...baseNotifier});return notifier};harden(makeNotifierFromAsyncIterable);var makePinnedHistoryTopic=topic=>{const pinnedPubList=topic.subscribeAfter();return Far("PinnedHistoryTopic",{subscribeAfter:async(publishCount=-1n)=>{if(publishCount===-1n){return pinnedPubList}return topic.subscribeAfter(publishCount)},getUpdateSince:async(updateCount=void 0)=>{return topic.getUpdateSince(updateCount)}})};harden(makePinnedHistoryTopic);var makeSubscription=topic=>{const subscription=Far("Subscription",{...subscribeEach(topic),subscribeAfter:async publishCount=>E(topic).subscribeAfter(publishCount),getSharableSubscriptionInternals:async()=>topic,getStoreKey:()=>harden({subscription})});return subscription};harden(makeSubscription);var makeSubscriptionKit=()=>{const{publisher,subscriber}=makePublishKit();const pinnedHistoryTopic=makePinnedHistoryTopic(subscriber);const subscription=makeSubscription(pinnedHistoryTopic);const publication=Far("publication",{updateState:nonFinalValue=>publisher.publish(nonFinalValue),finish:completion=>publisher.finish(completion),fail:reason=>publisher.fail(reason)});return harden({publication,subscription})};harden(makeSubscriptionKit);var observeIterator=(asyncIteratorP,iterationObserver)=>{return new Promise((ack,observerError)=>{const recur=()=>{E.when(E(asyncIteratorP).next(),({value,done})=>{if(done){iterationObserver.finish&&iterationObserver.finish(value);ack(void 0)}else{iterationObserver.updateState&&iterationObserver.updateState(value);recur()}},reason=>{iterationObserver.fail&&iterationObserver.fail(reason);ack(void 0)}).catch(observerError)};recur()})};var observeIteration=(asyncIterableP,iterationObserver)=>{const iteratorP=E(asyncIterableP)[Symbol.asyncIterator]();return observeIterator(iteratorP,iterationObserver)};var BridgeId={BANK:"bank",CORE:"core",DIBC:"dibc",STORAGE:"storage",PROVISION:"provision",PROVISION_SMART_WALLET:"provisionWallet",VLOCALCHAIN:"vlocalchain",VTRANSFER:"vtransfer",WALLET:"wallet"};harden(BridgeId);var CosmosInitKeyToBridgeId={vbankPort:"bank",vibcPort:"dibc"};harden(CosmosInitKeyToBridgeId);var WalletName={depositFacet:"depositFacet"};harden(WalletName);var VBankAccount={reserve:{module:"vbank/reserve",address:"agoric1ae0lmtzlgrcnla9xjkpaarq5d5dfez63h3nucl"},provision:{module:"vbank/provision",address:"agoric1megzytg65cyrgzs6fvzxgrcqvwwl7ugpt62346"}};harden(VBankAccount);var debugInstance=1;var makeTracer=(label,enable=true)=>{const sub=(subLabel,subEnable=enable)=>makeTracer(`${label}.${subLabel}`,subEnable);const key=`----- ${label},${debugInstance} `;debugInstance+=1;switch(enable){case false:{const logDisabled=(..._args)=>{};return harden(Object.assign(logDisabled,{sub}))}case"verbose":{const infoTick=(optLog,...args)=>{if(typeof optLog?.log==="function"){console.info(key,...args)}else{console.info(key,optLog,...args)}};return harden(Object.assign(infoTick,{sub}))}default:{const debugTick=(optLog,...args)=>{if(typeof optLog?.log==="function"){optLog.log(key,...args)}else{console.info(key,optLog,...args)}};return harden(Object.assign(debugTick,{sub}))}}};harden(makeTracer);var NonNullish=(val,optDetails=`unexpected ${quote(val)}`)=>{if(val!=null){return val}assert.fail(optDetails)};harden(NonNullish);var{defineProperty:defineProperty2}=Object;var typedMap=Function.prototype.call.bind(Array.prototype.map);var logLevels=["debug","log","info","warn","error"];Object.freeze(logLevels);var provideLazyMap=(map,key,makeValue)=>{const found=map.get(key);if(found!==void 0||map.has(key)){return found}const value=makeValue(key);map.set(key,value);return value};var rejectOCap=cap=>throwRedacted`${cap} is not pure data`;var pureDataMarshaller=makeMarshal(rejectOCap,rejectOCap,{serializeBodyFormat:"smallcaps"});harden(pureDataMarshaller);var{create:create4,fromEntries:fromEntries9}=Object;var{apply:apply7}=Reflect;var getMethodNames2=val=>getMethodNames(val);harden(getMethodNames2);var bindAllMethods=obj=>harden(create4(obj,fromEntries9(getMethodNames(obj).map(name=>[name,{value:(...args)=>apply7(obj[name],obj,args),enumerable:true}]))));harden(bindAllMethods);var HISTOGRAM_MS_LATENCY_BOUNDARIES=[5,10,25,50,100,250,500,1e3,2500,5e3,1e4,Infinity];var HISTOGRAM_SECONDS_LATENCY_BOUNDARIES=HISTOGRAM_MS_LATENCY_BOUNDARIES.map(ms=>ms/1e3);var HISTOGRAM_METRICS={swingset_crank_processing_time:{description:"Processing time per crank (ms)",unit:"ms",boundaries:Array.of(1,11,21,31,41,51,61,71,81,91,Infinity)},swingset_block_processing_seconds:{description:"Processing time per block",unit:"s",boundaries:HISTOGRAM_SECONDS_LATENCY_BOUNDARIES},swingset_vat_startup:{description:"Vat startup time (ms)",unit:"ms",boundaries:HISTOGRAM_MS_LATENCY_BOUNDARIES},swingset_vat_delivery:{description:"Vat delivery time (ms)",unit:"ms",boundaries:HISTOGRAM_MS_LATENCY_BOUNDARIES},swingset_meter_usage:{description:"Vat meter usage",unit:"ms",boundaries:HISTOGRAM_MS_LATENCY_BOUNDARIES}};var blockHistogramMetricDesc={unit:"s",advice:{explicitBucketBoundaries:[.1,.2,.3,.4,.5,1,2,3,4,5,6,7,10,15,30]}};var BLOCK_HISTOGRAM_METRICS={swingsetRunSeconds:{description:"Per-block time spent executing SwingSet",...blockHistogramMetricDesc},swingsetChainSaveSeconds:{description:"Per-block time spent propagating SwingSet state into cosmos",...blockHistogramMetricDesc},swingsetCommitSeconds:{description:"Per-block time spent committing SwingSet state to host storage",...blockHistogramMetricDesc},cosmosCommitSeconds:{description:"Per-block time spent committing cosmos state",...blockHistogramMetricDesc},fullCommitSeconds:{description:"Per-block time spent committing state, inclusive of COMMIT_BLOCK processing plus time spent [outside of cosmic-swingset] before and after it",...blockHistogramMetricDesc},interBlockSeconds:{description:"Time spent idle between blocks",...blockHistogramMetricDesc},afterCommitHangoverSeconds:{description:"Per-block time spent waiting for previous-block afterCommit work",...blockHistogramMetricDesc},blockLagSeconds:{description:"The delay of each block from its expected begin time",...blockHistogramMetricDesc,advice:{...blockHistogramMetricDesc.advice,explicitBucketBoundaries:[...blockHistogramMetricDesc.advice.explicitBucketBoundaries,...[60,120,180,240,300,600,3600]]}}};var MetricType={Counter:"counter",Gauge:"gauge"};var KERNEL_STATS_SUM_METRICS=[{key:"syscalls",name:"swingset_all_syscall_total",description:"Total number of SwingSet kernel calls"},{key:"syscallSend",name:"swingset_syscall_total",sub:{dimension:"syscall",value:"send"},description:"Total number of SwingSet message send kernel calls"},{key:"syscallCallNow",name:"swingset_syscall_total",sub:{dimension:"syscall",value:"callNow"},description:"Total number of SwingSet synchronous device kernel calls"},{key:"syscallSubscribe",name:"swingset_syscall_total",sub:{dimension:"syscall",value:"subscribe"},description:"Total number of SwingSet promise subscription kernel calls"},{key:"syscallResolve",name:"swingset_syscall_total",sub:{dimension:"syscall",value:"resolve"},description:"Total number of SwingSet promise resolution kernel calls"},{key:"syscallExit",name:"swingset_syscall_total",sub:{dimension:"syscall",value:"exit"},description:"Total number of SwingSet vat exit kernel calls"},{key:"syscallVatstoreGet",name:"swingset_syscall_total",sub:{dimension:"syscall",value:"vatstoreGet"},description:"Total number of SwingSet vatstore get kernel calls"},{key:"syscallVatstoreSet",name:"swingset_syscall_total",sub:{dimension:"syscall",value:"vatstoreSet"},description:"Total number of SwingSet vatstore set kernel calls"},{key:"syscallVatstoreGetNextKey",name:"swingset_syscall_total",sub:{dimension:"syscall",value:"vatstoreGetNext"},description:"Total number of SwingSet vatstore getNextKey kernel calls"},{key:"syscallVatstoreDelete",name:"swingset_syscall_total",sub:{dimension:"syscall",value:"vatstoreDelete"},description:"Total number of SwingSet vatstore delete kernel calls"},{key:"syscallDropImports",name:"swingset_syscall_total",sub:{dimension:"syscall",value:"dropImports"},description:"Total number of SwingSet drop imports kernel calls"},{key:"dispatches",name:"swingset_dispatch_total",description:"Total number of SwingSet vat calls"},{key:"dispatchDeliver",name:"swingset_dispatch_deliver_total",description:"Total number of SwingSet vat message deliveries"},{key:"dispatchNotify",name:"swingset_dispatch_notify_total",description:"Total number of SwingSet vat promise notifications"}];var KERNEL_STATS_UPDOWN_METRICS=[{key:"kernelObjects",name:"swingset_kernel_objects",description:"Active kernel objects"},{key:"kernelDevices",name:"swingset_kernel_devices",description:"Active kernel devices"},{key:"kernelPromises",name:"swingset_kernel_promises",description:"Active kernel promises"},{key:"kpUnresolved",name:"swingset_unresolved_kernel_promises",description:"Unresolved kernel promises"},{key:"kpFulfilled",name:"swingset_fulfilled_kernel_promises",description:"Fulfilled kernel promises"},{key:"kpRejected",name:"swingset_rejected_kernel_promises",description:"Rejected kernel promises"},{key:"runQueueLength",name:"swingset_run_queue_length",consensus:true,description:"Length of the kernel run queue"},{key:"acceptanceQueueLength",name:"swingset_acceptance_queue_length",consensus:true,description:"Length of the kernel acceptance queue"},{key:"promiseQueuesLength",name:"swingset_promise_queues_length",consensus:true,description:"Combined length of all kernel promise queues"},{key:"clistEntries",name:"swingset_clist_entries",description:"Number of entries in the kernel c-list"},{key:"vats",name:"swingset_vats",description:"Number of active vats"}];var{Counter,Gauge}=MetricType;var KERNEL_STATS_METRICS=harden([...KERNEL_STATS_SUM_METRICS.map(m=>({...m,metricType:Counter})),...KERNEL_STATS_UPDOWN_METRICS.map(m=>({...m,metricType:Gauge}))]);var kernelStatsKeys=new Map;for(const{key}of KERNEL_STATS_METRICS){kernelStatsKeys.set(key,(kernelStatsKeys.get(key)||0)+1)}var duplicateKernelStatsKeys=[...kernelStatsKeys.entries()].flatMap(([key,value])=>value>1?[key]:[]);if(duplicateKernelStatsKeys.length>0){const msg=`Duplicate kernel stats keys ${JSON.stringify(duplicateKernelStatsKeys)}`;throw Error(msg)}var compareNats=(a,b)=>{const diff=+a-+b;const finiteDiff=Number.isFinite(diff)&&diff||(a===b?0:Number(BigInt(a)-BigInt(b))||a.length-b.length);return Math.sign(finiteDiff)};var compareStrings=(a,b)=>a>b?1:a<b?-1:0;var rCaptureDigits=/([0-9]+)/;var partsCache=new Map;var naturalCompare=(a,b)=>{if(!partsCache.size)void Promise.resolve().then(()=>partsCache.clear());const aParts=provideLazyMap(partsCache,a,()=>a.split(rCaptureDigits));const bParts=provideLazyMap(partsCache,b,()=>b.split(rCaptureDigits));let i=0;for(;i+1<aParts.length;i+=2){if(i+1<bParts.length){const result=compareStrings(aParts[i],bParts[i])||compareNats(aParts[i+1],bParts[i+1]);if(result)return result}else{return compareStrings(`${aParts[i]}${aParts[i+1]}`,bParts[i])}}if(bParts.length>aParts.length){return compareStrings(aParts[i],`${bParts[i]}${bParts[i+1]}`)}return compareStrings(aParts[i],bParts[i])};harden(naturalCompare);var{getOwnPropertyDescriptors:getOwnPropertyDescriptors7,create:create5,fromEntries:fromEntries10}=Object;var{ownKeys:ownKeys20}=Reflect;var objectMetaMap=(original,metaMapFn,proto=Object.prototype)=>{const descs=getOwnPropertyDescriptors7(original);const keys2=ownKeys20(original);const descEntries=keys2.map(key=>[key,metaMapFn(descs[key],key)]).filter(([_key,optDesc])=>optDesc!==void 0);return harden(create5(proto,fromEntries10(descEntries)))};harden(objectMetaMap);var freeze8=Object.freeze;var makeQueue=()=>{let{promise:tailPromise,resolve:tailResolve}=makePromiseKit();return{put(value){const{resolve,promise}=makePromiseKit();tailResolve(freeze8({value,promise}));tailResolve=resolve},get(){const promise=tailPromise.then(next=>next.value);tailPromise=tailPromise.then(next=>next.promise);return harden(promise)}}};harden(makeQueue);var makeStream=(acks,data)=>{const stream=harden({next(value){data.put(freeze8({value,done:false}));return acks.get()},return(value){data.put(freeze8({value,done:true}));return acks.get()},throw(error){data.put(harden(Promise.reject(error)));return acks.get()},[Symbol.asyncIterator](){return stream}});return stream};harden(makeStream);var makePipe=()=>{const data=makeQueue();const acks=makeQueue();const reader=makeStream(acks,data);const writer=makeStream(data,acks);return harden([writer,reader])};harden(makePipe);var pump=async(writer,reader,primer)=>{const tick=promise=>E.when(promise,result=>{if(result.done){return writer.return(result.value)}else{return tock(writer.next(result.value))}},error=>{return writer.throw(error)});const tock=promise=>E.when(promise,result=>{if(result.done){return reader.return(result.value)}else{return tick(reader.next(result.value))}},error=>{return reader.throw(error)});await tick(reader.next(primer));return void 0};harden(pump);var prime=(generator,primer)=>{const first=generator.next(primer);let result;const primed=harden({async next(value){if(result===void 0){result=await first;if(result.done){return result}}return generator.next(value)},async return(value){if(result===void 0){result=await first;if(result.done){return result}}return generator.return(value)},async throw(error){if(result===void 0){result=await first;if(result.done){throw error}}return generator.throw(error)}});return primed};harden(prime);var mapReader=(reader,transform)=>{async function*transformGenerator(){for await(const value of reader){yield transform(value)}return void 0}harden(transformGenerator);return harden(transformGenerator())};harden(mapReader);var mapWriter=(writer,transform)=>{const transformedWriter=harden({async next(value){return writer.next(transform(value))},async throw(error){return writer.throw(error)},async return(value){return writer.return(value)},[Symbol.asyncIterator](){return transformedWriter}});return transformedWriter};harden(mapWriter);var makePromise=executor=>harden(new Promise(executor));harden(makePromise);var makeMap=entriesOrIterable=>harden(new Map(entriesOrIterable));harden(makeMap);var makeSet=values5=>harden(new Set(values5));harden(makeSet);var makeWeakMap=entries8=>harden(new WeakMap(entries8));harden(makeWeakMap);var makeWeakSet=values5=>harden(new WeakSet(values5));harden(makeWeakSet);var asyncGenerate=next=>{return harden({[Symbol.asyncIterator]:()=>{return harden({next:async()=>harden(next())})}})};harden(asyncGenerate);var asyncDoWhile=body=>{return makePromise((resolve,reject)=>{const loop=async()=>{const doContinue=await body();if(!doContinue){resolve(void 0);return}loop().catch(reject)};loop().catch(reject)})};harden(asyncDoWhile);var{fromEntries:fromEntries11,keys,values:values4}=Object;var makeLimitedConsole=makeLogger=>{const limitedConsole=fromEntries11(logLevels.map(level=>[level,makeLogger(level)]));return harden(limitedConsole)};harden(makeLimitedConsole);var assertAllDefined=obj=>{const missing2=[];for(const[key,val]of Object.entries(obj)){if(val===void 0){missing2.push(key)}}if(missing2.length>0){throwRedacted`missing ${quote(missing2)}`}};var notDone=harden({done:false,value:void 0});var alwaysDone=harden({done:true,value:void 0});var forever=asyncGenerate(()=>notDone);var zip=(xs,ys)=>harden(xs.map((x,i)=>[x,ys[+i]]));var allValues=async obj=>{const resolved=await Promise.all(values4(obj));return harden(fromEntries11(zip(keys(obj),resolved)))};var StorageNodeShape=M.remotable("StorageNode");var UnguardedHelperI=M.interface("helper",{},{sloppy:true});var BridgeBigIntShape=M.or(M.number(),M.string());var detachedHeapStores=Far("heapStores",{detached:()=>detachedHeapStores,isStorable:isPassable,setStore:makeScalarSetStore,mapStore:makeScalarMapStore,weakMapStore:makeScalarWeakMapStore,weakSetStore:makeScalarWeakSetStore});var makeHeapZone=(baseLabel="heapZone")=>{const{makeOnce,wrapProvider}=makeOnceKit(baseLabel,detachedHeapStores);const makeSubZone=(label,_options)=>makeHeapZone(`${baseLabel}.${label}`);return Far("heapZone",{exo:wrapProvider(makeExo,agoricVatDataKeys.exo),exoClass:wrapProvider(defineExoClass,agoricVatDataKeys.exoClass),exoClassKit:wrapProvider(defineExoClassKit,agoricVatDataKeys.exoClassKit),subZone:wrapProvider(makeSubZone),makeOnce,watchPromise:watchPromise2,detached:detachedHeapStores.detached,isStorable:detachedHeapStores.isStorable,mapStore:wrapProvider(detachedHeapStores.mapStore),setStore:wrapProvider(detachedHeapStores.setStore),weakMapStore:wrapProvider(detachedHeapStores.weakMapStore),weakSetStore:wrapProvider(detachedHeapStores.weakSetStore)})};harden(makeHeapZone);var{fromEntries:fromEntries12}=Object;var{ownKeys:rawOwnKeys}=Reflect;var ownKeys21=rawOwnKeys;var isPropertyKey=key=>{switch(typeof key){case"string":case"number":case"symbol":return true;default:return false}};var callSync=(callback,...args)=>{const{target,methodName,bound}=callback;if(methodName===void 0){return target(...bound,...args)}return target[methodName](...bound,...args)};harden(callSync);var callE=(callback,...args)=>{const{target,methodName,bound}=callback;if(methodName===void 0){return E(target)(...bound,...args)}return E(target)[methodName](...bound,...args)};harden(callE);var makeSyncFunctionCallback=(target,...bound)=>{typeof target==="function"||throwRedacted`sync function callback target must be a function: ${target}`;const cb=harden({target,bound,isSync:true});return cb};harden(makeSyncFunctionCallback);var makeFunctionCallback=(target,...bound)=>{!isPrimitive2(target)||throwRedacted`function callback target must be a function presence: ${target}`;const cb=harden({target,bound});return cb};harden(makeFunctionCallback);var makeSyncMethodCallback=(target,methodName,...bound)=>{!isPrimitive2(target)||throwRedacted`sync method callback target must be an object: ${target}`;typeof methodName==="string"||isPassableSymbol(methodName)||throwRedacted`method name must be a string or passable symbol: ${methodName}`;const cb=harden({target,methodName,bound,isSync:true});return cb};harden(makeSyncMethodCallback);var makeMethodCallback=(target,methodName,...bound)=>{!isPrimitive2(target)||throwRedacted`method callback target must be an object: ${target}`;typeof methodName==="string"||isPassableSymbol(methodName)||throwRedacted`method name must be a string or passable symbol: ${methodName}`;const cb=harden({target,methodName,bound});return cb};harden(makeMethodCallback);var isCallback=callback=>{if(isPrimitive2(callback)){return false}const{target,methodName,bound}=callback;return!isPrimitive2(target)&&(methodName===void 0||typeof methodName==="string"||isPassableSymbol(methodName))&&Array.isArray(bound)};harden(isCallback);var prepareAttenuator=(zone,methodNames,{interfaceGuard,tag="Attenuator"}={})=>{const methods=fromEntries12(methodNames.map(key=>{if(!isPropertyKey(key)){throw throwRedacted`key ${quote(key)} is not a PropertyKey`}const m={[key](...args){const cb=this.state.cbs[key];if(!cb){const err=makeError(`unimplemented ${quote(tag)} method ${quote(key)}`);if(this.state.isSync){throw err}return Promise.reject(err)}if(cb.isSync){return callSync(cb,...args)}return callE(cb,...args)}}[key];return[key,m]}));const makeAttenuator=zone.exoClass(tag,interfaceGuard,({target=null,isSync=false,overrides={}})=>{const cbs={};const remaining=new Set(methodNames);for(const key of ownKeys21(overrides)){remaining.has(key)||throwRedacted`${quote(tag)} overrides[${quote(key)}] not allowed by methodNames`;remaining.delete(key);const cb=overrides[key];cb==null||isCallback(cb)||throwRedacted`${quote(tag)} overrides[${quote(key)}] is not a callback; got ${cb}`;cbs[key]=cb}for(const key of remaining){if(isSync){cbs[key]=makeSyncMethodCallback(target,key)}else{cbs[key]=makeMethodCallback(target,key)}}return harden({cbs,isSync})},methods);return makeAttenuator};harden(prepareAttenuator);var prepareGuardedAttenuator=(zone,interfaceGuard,opts={})=>{const methodNames=getInterfaceMethodKeys(interfaceGuard);const makeAttenuator=prepareAttenuator(zone,methodNames,{...opts,interfaceGuard});return makeAttenuator};harden(prepareGuardedAttenuator);var StreamCellShape=harden({blockHeight:M.string(),values:M.array()});var ChainStorageNodeI=M.interface("StorageNode",{setValue:M.callWhen(M.string()).returns(),getPath:M.call().returns(M.string()),getStoreKey:M.callWhen().returns(M.record()),makeChildNode:M.call(M.string()).optional(M.splitRecord({},{sequence:M.boolean()},{})).returns(M.remotable("StorageNode"))});var isStreamCell=cell=>cell&&typeof cell==="object"&&Array.isArray(cell.values)&&typeof cell.blockHeight==="string"&&/^0$|^[1-9][0-9]*$/.test(cell.blockHeight);harden(isStreamCell);var pathSegmentPattern=/^[a-zA-Z0-9_-]{1,100}$/;var assertPathSegment=name=>{pathSegmentPattern.test(name)||throwRedacted`Path segment names must consist of 1 to 100 characters limited to ASCII alphanumerics, underscores, and/or dashes: ${name}`};harden(assertPathSegment);var prepareChainStorageNode=zone=>{const makeChainStorageNode=zone.exoClass("ChainStorageNode",ChainStorageNodeI,(messenger,path,{sequence=false}={})=>{assert.typeof(path,"string");assert.typeof(sequence,"boolean");return harden({path,messenger,sequence})},{getPath(){return this.state.path},async getStoreKey(){const{path,messenger}=this.state;return callE(messenger,{method:"getStoreKey",args:[path]})},makeChildNode(name,childNodeOptions={}){const{sequence,path,messenger}=this.state;assertPathSegment(name);const mergedOptions={sequence,...childNodeOptions};return makeChainStorageNode(messenger,`${path}.${name}`,mergedOptions)},async setValue(value){const{sequence,path,messenger}=this.state;assert.typeof(value,"string");let entry;if(!sequence&&!value){entry=[path]}else{entry=[path,value]}await callE(messenger,{method:sequence?"append":"set",args:[entry]})}});return makeChainStorageNode};var makeHeapChainStorageNode=prepareChainStorageNode(makeHeapZone());function makeChainStorageRoot(handleStorageMessage,rootPath,rootOptions={}){const messenger=makeFunctionCallback(handleStorageMessage);const rootNode=makeHeapChainStorageNode(messenger,rootPath,rootOptions);return rootNode}var makeNullStorageNode=()=>{return makeChainStorageRoot(Far("NullMessenger",()=>null),"null")};async function makeStorageNodeChild(storageNodeRef,childName){const existingStorageNode=await storageNodeRef;const storageNode=existingStorageNode||makeNullStorageNode();return E(storageNode).makeChildNode(childName)}harden(makeStorageNodeChild);var makeSerializeToStorage=(storageNode,marshaller)=>{return async value=>{const marshalled=await E(marshaller).toCapData(value);const serialized=JSON.stringify(marshalled);return E(storageNode).setValue(serialized)}};var forEachPublicationRecord=async(subscriber,consumeValue)=>{const iterator=subscribeEach(subscriber)[Symbol.asyncIterator]();let finished=false;await null;while(!finished){const{value,done}=await iterator.next();await consumeValue(value);finished=!!done}};var makeStoredSubscriber=(subscriber,storageNode,marshaller)=>{assertAllDefined({subscriber,storageNode,marshaller});const marshallToStorage=makeSerializeToStorage(storageNode,marshaller);forEachPublicationRecord(subscriber,marshallToStorage).catch(err=>{console.error("StoredSubscriber failed to iterate",err)});const unserializer=Far("unserializer",{fromCapData:data=>E(marshaller).fromCapData(data),unserialize:data=>E(marshaller).fromCapData(data)});const storesub=Far("StoredSubscriber",{subscribeAfter:publishCount=>subscriber.subscribeAfter(publishCount),getUpdateSince:updateCount=>subscriber.getUpdateSince(updateCount),getPath:()=>E(storageNode).getPath(),getStoreKey:()=>E(storageNode).getStoreKey(),getUnserializer:()=>unserializer});return storesub};var makeStoredSubscription=(subscription,storageNode,marshaller=makeMarshal(void 0,void 0,{marshalSaveError:()=>{},serializeBodyFormat:"smallcaps"}))=>{const unserializer=Far("unserializer",{fromCapData:data=>E(marshaller).fromCapData(data),unserialize:data=>E(marshaller).fromCapData(data)});let publishFailed=false;let publishException;const fail=err=>{publishFailed=true;publishException=err};const publishValue=obj=>{assert(storageNode);if(publishFailed){throw publishException}E(marshaller).toCapData(obj).then(serialized=>{const encoded=JSON.stringify(serialized);return E(storageNode).setValue(encoded)}).catch(fail)};if(storageNode){observeIteration(subscription,{updateState:publishValue,finish:publishValue}).catch(fail)}const storesub=Far("StoredSubscription",{getStoreKey:async()=>{if(!storageNode){return harden({subscription})}const storeKey=await E(storageNode).getStoreKey();return harden({...storeKey,subscription})},getUnserializer:()=>unserializer,getSharableSubscriptionInternals:()=>subscription.getSharableSubscriptionInternals(),[Symbol.asyncIterator]:()=>subscription[Symbol.asyncIterator](),subscribeAfter:publishCount=>subscription.subscribeAfter(publishCount)});return storesub};harden(makeStoredSubscription);var makeStoredPublishKit=(storageNode,marshaller)=>{const{publisher,subscriber}=makePublishKit();return{publisher,subscriber:makeStoredSubscriber(subscriber,storageNode,marshaller)}};harden(makeStoredPublishKit);var makeTransientNotifierKit=()=>{const transientNotiferKits=makeScalarBigWeakMapStore("transientNotiferKits");const provideNotifierKit=key=>provideLazy(transientNotiferKits,key,()=>makeNotifierKit(key.getCurrentAmount()));const provideNotifier=key=>provideNotifierKit(key).notifier;const update=(key,newValue)=>{if(transientNotiferKits.has(key)){const{updater}=transientNotiferKits.get(key);updater.updateState(newValue)}};return{provideNotifier,update}};harden(makeTransientNotifierKit);var makeAmountStore=(state,key)=>{return harden({getAmount:()=>state[key],increment:delta=>{state[key]=AmountMath.add(state[key],delta)},decrement:delta=>{if(AmountMath.isGTE(state[key],delta)){state[key]=AmountMath.subtract(state[key],delta);return true}return false}})};harden(makeAmountStore);var EMPTY_COPY_SET=makeCopySet([]);var preparePurseKind=(issuerZone,name,assetKind,brand,PurseIKit,purseMethods,recoverySetsState,paymentRecoverySets)=>{const amountShape=brand.getAmountShape();const{provideNotifier,update:updateBalance}=makeTransientNotifierKit();const maybeRecoverySet=state=>{const{recoverySet}=state;if(recoverySetsState==="hasRecoverySets"){return recoverySet}else{recoverySetsState==="noRecoverySets"||throwRedacted`recoverSetsState must be noRecoverySets if it isn't hasRecoverSets`;paymentRecoverySets!==void 0||throwRedacted`paymentRecoverySets must always be defined`;recoverySet.getSize()===0||throwRedacted`With noRecoverySets, recoverySet must be empty`;return void 0}};const{depositInternal,withdrawInternal}=purseMethods;const makePurseKit=issuerZone.exoClassKit(`${name} Purse`,PurseIKit,()=>{const currentBalance=AmountMath.makeEmpty(brand,assetKind);const recoverySet=issuerZone.detached().setStore("recovery set");return{currentBalance,recoverySet}},{purse:{deposit(srcPayment,optAmountShape=void 0){const{state}=this;const{purse}=this.facets;const balanceStore=makeAmountStore(state,"currentBalance");const srcPaymentBalance=depositInternal(balanceStore,srcPayment,optAmountShape);updateBalance(purse,balanceStore.getAmount());return srcPaymentBalance},withdraw(amount){const{state}=this;const{purse}=this.facets;const optRecoverySet=maybeRecoverySet(state);const balanceStore=makeAmountStore(state,"currentBalance");const payment=withdrawInternal(balanceStore,amount,optRecoverySet);updateBalance(purse,balanceStore.getAmount());return payment},getCurrentAmount(){const{state}=this;const balanceStore=makeAmountStore(state,"currentBalance");return balanceStore.getAmount()},getCurrentAmountNotifier(){return provideNotifier(this.facets.purse)},getAllegedBrand(){return brand},getDepositFacet(){return this.facets.depositFacet},getRecoverySet(){const{state}=this;const optRecoverySet=maybeRecoverySet(state);if(optRecoverySet===void 0){return EMPTY_COPY_SET}return optRecoverySet.snapshot()},recoverAll(){const{state,facets}=this;let amount=AmountMath.makeEmpty(brand,assetKind);const optRecoverySet=maybeRecoverySet(state);if(optRecoverySet===void 0){return amount}for(const payment of optRecoverySet.keys()){const delta=facets.purse.deposit(payment);amount=AmountMath.add(amount,delta,brand)}optRecoverySet.getSize()===0||throwRedacted`internal: Remaining unrecovered payments: ${facets.purse.getRecoverySet()}`;return amount}},depositFacet:{receive(...args){return this.facets.purse.deposit(...args)}}},{stateShape:{currentBalance:amountShape,recoverySet:M.remotable("recoverySet")}});return()=>makePurseKit().purse};harden(preparePurseKind);var amountShapeFromElementShape=(brand,assetKind,elementShape)=>{let valueShape;switch(assetKind){case"nat":{valueShape=M.nat();elementShape===void 0||throwRedacted`Fungible assets cannot have an elementShape: ${quote(elementShape)}`;break}case"set":{if(elementShape===void 0){valueShape=M.arrayOf(M.key())}else{valueShape=M.arrayOf(M.and(M.key(),elementShape))}break}case"copySet":{if(elementShape===void 0){valueShape=M.set()}else{valueShape=M.setOf(elementShape)}break}case"copyBag":{if(elementShape===void 0){valueShape=M.bag()}else{valueShape=M.bagOf(elementShape)}break}default:{throwRedacted`unexpected asset kind ${quote(assetKind)}`}}const amountShape=harden({brand,value:valueShape});return amountShape};var preparePaymentLedger=(issuerZone,name,assetKind,displayInfo,elementShape,recoverySetsState,optShutdownWithFailure=void 0)=>{const brand=issuerZone.exo(`${name} brand`,BrandI,{isMyIssuer(allegedIssuer){return allegedIssuer===issuer},getAllegedName(){return name},getDisplayInfo(){return displayInfo},getAmountShape(){return amountShape}});const amountShape=amountShapeFromElementShape(brand,assetKind,elementShape);const{IssuerI,MintI,PaymentI,PurseIKit}=makeIssuerInterfaces(brand,assetKind,amountShape);const makePayment=preparePaymentKind(issuerZone,name,brand,PaymentI);const shutdownLedgerWithFailure=reason=>{if(optShutdownWithFailure!==void 0){try{optShutdownWithFailure(reason)}catch(errInShutdown){note(errInShutdown,redacted`Caused by: ${reason}`);throw errInShutdown}}throw reason};const paymentLedger=issuerZone.weakMapStore("paymentLedger",{valueShape:amountShape});const paymentRecoverySets=issuerZone.weakMapStore("paymentRecoverySets");const initPayment=(payment,amount,optRecoverySet=void 0)=>{if(recoverySetsState==="noRecoverySets"){optRecoverySet===void 0||throwRedacted`when recoverSetsState === 'noRecoverySets', optRecoverySet must be empty`}if(optRecoverySet!==void 0&&!AmountMath.isEmpty(amount)){optRecoverySet.add(payment);paymentRecoverySets.init(payment,optRecoverySet)}paymentLedger.init(payment,amount)};const deletePayment=payment=>{paymentLedger.delete(payment);if(paymentRecoverySets.has(payment)){const recoverySet=paymentRecoverySets.get(payment);paymentRecoverySets.delete(payment);recoverySet.delete(payment)}};const coerce=allegedAmount=>AmountMath.coerce(brand,allegedAmount);const assertAmountConsistent=(paymentBalance,optAmountShape)=>{if(optAmountShape!==void 0){mustMatch(paymentBalance,optAmountShape,"amount")}};const assertLivePayment=payment=>{paymentLedger.has(payment)||throwRedacted`${payment} was not a live payment for brand ${quote(brand)}. It could be a used-up payment, a payment for another brand, or it might not be a payment at all.`};const depositInternal=(balanceStore,srcPayment,optAmountShape=void 0)=>{!isPromise(srcPayment)||assert.fail(`deposit does not accept promises as first argument. Instead of passing the promise (deposit(paymentPromise)), consider unwrapping the promise first: E.when(paymentPromise, (actualPayment => deposit(actualPayment))`,TypeError);assertLivePayment(srcPayment);const srcPaymentBalance=paymentLedger.get(srcPayment);assertAmountConsistent(srcPaymentBalance,optAmountShape);try{deletePayment(srcPayment);balanceStore.increment(srcPaymentBalance)}catch(err){shutdownLedgerWithFailure(err);throw err}return srcPaymentBalance};const withdrawInternal=(balanceStore,amount,recoverySet=void 0)=>{amount=coerce(amount);const payment=makePayment();balanceStore.decrement(amount)||throwRedacted`Withdrawal of ${amount} failed because the purse only contained ${balanceStore.getAmount()}`;try{initPayment(payment,amount,recoverySet)}catch(err){shutdownLedgerWithFailure(err);throw err}return payment};const makeEmptyPurse=preparePurseKind(issuerZone,name,assetKind,brand,PurseIKit,harden({depositInternal,withdrawInternal}),recoverySetsState,paymentRecoverySets);const issuer=issuerZone.exo(`${name} issuer`,IssuerI,{getBrand(){return brand},getAllegedName(){return name},getAssetKind(){return assetKind},getDisplayInfo(){return displayInfo},makeEmptyPurse(){return makeEmptyPurse()},isLive(payment){return paymentLedger.has(payment)},getAmountOf(payment){assertLivePayment(payment);return paymentLedger.get(payment)},burn(payment,optAmountShape=void 0){assertLivePayment(payment);const paymentBalance=paymentLedger.get(payment);assertAmountConsistent(paymentBalance,optAmountShape);try{deletePayment(payment)}catch(err){shutdownLedgerWithFailure(err);throw err}return paymentBalance}});const mintRecoveryPurse=issuerZone.makeOnce("mintRecoveryPurse",()=>makeEmptyPurse());const mint=issuerZone.exo(`${name} mint`,MintI,{getIssuer(){return issuer},mintPayment(newAmount){newAmount=coerce(newAmount);mustMatch(newAmount,amountShape,"minted amount");const rawPayment=makePayment();initPayment(rawPayment,newAmount,void 0);const mintRecoveryPurseBefore=mintRecoveryPurse.getCurrentAmount();mintRecoveryPurse.deposit(rawPayment,newAmount);const payment=mintRecoveryPurse.withdraw(newAmount);const mintRecoveryPurseAfter=mintRecoveryPurse.getCurrentAmount();assert(keyEQ(mintRecoveryPurseBefore,mintRecoveryPurseAfter));return payment}});const issuerKit=harden({issuer,mint,brand,mintRecoveryPurse});return issuerKit};harden(preparePaymentLedger);var setupIssuerKit=({name,assetKind,displayInfo,elementShape},issuerZone,recoverySetsState,optShutdownWithFailure=void 0)=>{assert2.typeof(name,"string");assertAssetKind(assetKind);const cleanDisplayInfo=coerceDisplayInfo(displayInfo,assetKind);if(optShutdownWithFailure!==void 0){assert2.typeof(optShutdownWithFailure,"function")}if(elementShape!==void 0){assertPattern(elementShape)}const{issuer,mint,brand,mintRecoveryPurse}=preparePaymentLedger(issuerZone,name,assetKind,cleanDisplayInfo,elementShape,recoverySetsState,optShutdownWithFailure);return harden({brand,issuer,mint,mintRecoveryPurse,displayInfo:cleanDisplayInfo})};harden(setupIssuerKit);var INSTANCE_KEY="issuer";var RECOVERY_SETS_STATE="recoverySetsState";var upgradeIssuerKit=(issuerBaggage,optShutdownWithFailure=void 0,recoverySetsOption=void 0)=>{const issuerRecord=issuerBaggage.get(INSTANCE_KEY);const issuerZone=makeDurableZone(issuerBaggage);const oldRecoverySetsState=issuerBaggage.has(RECOVERY_SETS_STATE)?issuerBaggage.get(RECOVERY_SETS_STATE):"hasRecoverySets";if(oldRecoverySetsState==="noRecoverySets"&&recoverySetsOption==="hasRecoverySets"){throwRedacted`Cannot (yet?) upgrade from 'noRecoverySets' to 'hasRecoverySets'`}const recoverySetsState=recoverySetsOption||oldRecoverySetsState;return setupIssuerKit(issuerRecord,issuerZone,recoverySetsState,optShutdownWithFailure)};harden(upgradeIssuerKit);var hasIssuer=baggage=>baggage.has(INSTANCE_KEY);var makeDurableIssuerKit=(issuerBaggage,name,assetKind=AssetKind.NAT,displayInfo=harden({}),optShutdownWithFailure=void 0,{elementShape=void 0,recoverySetsOption=void 0}={})=>{const issuerData=harden({name,assetKind,displayInfo,elementShape});issuerBaggage.init(INSTANCE_KEY,issuerData);const issuerZone=makeDurableZone(issuerBaggage);const recoverySetsState=recoverySetsOption||"hasRecoverySets";issuerBaggage.init(RECOVERY_SETS_STATE,recoverySetsState);return setupIssuerKit(issuerData,issuerZone,recoverySetsState,optShutdownWithFailure)};harden(makeDurableIssuerKit);var prepareIssuerKit=(issuerBaggage,name,assetKind=AssetKind.NAT,displayInfo=harden({}),optShutdownWithFailure=void 0,options={})=>{if(hasIssuer(issuerBaggage)){const{elementShape:_=void 0,recoverySetsOption=void 0}=options;const issuerKit=upgradeIssuerKit(issuerBaggage,optShutdownWithFailure,recoverySetsOption);return issuerKit}else{const issuerKit=makeDurableIssuerKit(issuerBaggage,name,assetKind,displayInfo,optShutdownWithFailure,options);return issuerKit}};harden(prepareIssuerKit);var makeIssuerKit=(name,assetKind=AssetKind.NAT,displayInfo=harden({}),optShutdownWithFailure=void 0,{elementShape=void 0,recoverySetsOption=void 0}={})=>makeDurableIssuerKit(makeScalarBigMapStore("dropped issuer kit",{durable:true}),name,assetKind,displayInfo,optShutdownWithFailure,{elementShape,recoverySetsOption});harden(makeIssuerKit);var natSafeMath=harden({add:(x,y)=>Nat(x)+Nat(y),subtract:(x,y)=>Nat(Nat(x)-Nat(y)),multiply:(x,y)=>Nat(x)*Nat(y),floorDivide:(x,y)=>Nat(x)/Nat(y),ceilDivide:(x,y)=>{y=Nat(y);return Nat(Nat(x)+y-1n)/y},bankersDivide:(a,b)=>{a=Nat(a);b=Nat(b);const div=a/b;const rem=a%b;if(rem*2n>b){return div+1n}else if(rem*2n===b){if(div%2n===1n)return div+1n}return div},isGTE:(x,y)=>Nat(x)>=Nat(y)});var{subtract,add,multiply,floorDivide}=natSafeMath;var makeStateMachine=(initialState,allowedTransitionsArray)=>{let state=initialState;const allowedTransitions=new Map(allowedTransitionsArray);return harden({canTransitionTo:nextState=>allowedTransitions.get(state).includes(nextState),transitionTo:nextState=>{assert2(allowedTransitions.get(state).includes(nextState));state=nextState},getStatus:_=>state})};harden(makeStateMachine);var TimerBrandShape=M.remotable("TimerBrand");var TimestampValueShape=M.nat();var RelativeTimeValueShape=M.nat();var TimestampRecordShape={timerBrand:TimerBrandShape,absValue:TimestampValueShape};harden(TimestampRecordShape);var RelativeTimeRecordShape={timerBrand:TimerBrandShape,relValue:RelativeTimeValueShape};harden(RelativeTimeRecordShape);var TimestampShape=M.or(TimestampRecordShape,TimestampValueShape);var RelativeTimeShape=M.or(RelativeTimeRecordShape,RelativeTimeValueShape);var TimerServiceShape=M.remotable("TimerService");var agreedTimerBrand=(leftBrand,rightBrand)=>{if(leftBrand===void 0){if(rightBrand===void 0){return void 0}else{return rightBrand}}else if(rightBrand===void 0){return leftBrand}else{leftBrand===rightBrand||throwRedacted`TimerBrands must match: ${quote(leftBrand)} vs ${quote(rightBrand)}`;return leftBrand}};var sharedTimerBrand=(left,right)=>{const leftBrand=typeof left==="bigint"?void 0:left.timerBrand;const rightBrand=typeof right==="bigint"?void 0:right.timerBrand;return agreedTimerBrand(leftBrand,rightBrand)};var absLike=(left,right,absValue2)=>{Nat(absValue2);const timerBrand=sharedTimerBrand(left,right);if(timerBrand){return harden({timerBrand,absValue:absValue2})}else{return absValue2}};var relLike=(left,right,relValue2)=>{Nat(relValue2);const timerBrand=sharedTimerBrand(left,right);if(timerBrand){return harden({timerBrand,relValue:relValue2})}else{return relValue2}};var absValue=abs=>{if(typeof abs==="bigint"){return Nat(abs)}mustMatch2(abs,TimestampRecordShape,"timestamp");return Nat(abs.absValue)};var relValue=rel=>{if(typeof rel==="bigint"){return Nat(rel)}mustMatch2(rel,RelativeTimeRecordShape,"relative");return Nat(rel.relValue)};var makeTimestampRecord=(abs,timerBrand)=>harden({absValue:abs,timerBrand});var makeRelativeTimeRecord=(rel,timerBrand)=>harden({relValue:rel,timerBrand});var coerceTimestampRecord=(ts,brand)=>{brand||throwRedacted`must have a brand`;if(typeof ts==="number"){ts=Nat(ts)}if(typeof ts==="bigint"){return makeTimestampRecord(ts,brand)}else{const{timerBrand}=ts;mustMatch2(ts,TimestampRecordShape,"timestamp");agreedTimerBrand(timerBrand,brand);return ts}};var coerceRelativeTimeRecord=(rt,brand)=>{brand||throwRedacted`must have a brand`;if(typeof rt==="number"){rt=Nat(rt)}if(typeof rt==="bigint"){return makeRelativeTimeRecord(rt,brand)}else{const{timerBrand}=rt;mustMatch2(rt,RelativeTimeRecordShape,"relativeTime");agreedTimerBrand(timerBrand,brand);return rt}};var addAbsRel=(abs,rel)=>absLike(abs,rel,absValue(abs)+relValue(rel));var addRelRel=(rel1,rel2)=>relLike(rel1,rel2,relValue(rel1)+relValue(rel2));var subtractAbsAbs=(abs1,abs2)=>relLike(abs1,abs2,absValue(abs1)-absValue(abs2));var clampedSubtractAbsAbs=(abs1,abs2)=>{const val1=absValue(abs1);const val2=absValue(abs2);return relLike(abs1,abs2,val1>val2?val1-val2:0n)};var subtractAbsRel=(abs,rel)=>absLike(abs,rel,absValue(abs)-relValue(rel));var subtractRelRel=(rel1,rel2)=>relLike(rel1,rel2,relValue(rel1)-relValue(rel2));var isRelZero=rel=>relValue(rel)===0n;var multiplyRelNat=(rel,nat)=>relLike(rel,nat,relValue(rel)*nat);var divideRelNat=(rel,nat)=>relLike(rel,nat,relValue(rel)/nat);var divideRelRel=(rel1,rel2)=>{sharedTimerBrand(rel1,rel2);return relValue(rel1)/relValue(rel2)};var modAbsRel=(abs,step)=>relLike(abs,step,absValue(abs)%relValue(step));var modRelRel=(rel,step)=>relLike(rel,step,relValue(rel)%relValue(step));var compareValues=(left,right,v1,v2)=>{sharedTimerBrand(left,right);if(v1<v2){return-1}else if(v1===v2){return 0}else{assert(v1>v2);return 1}};var TimeMath=harden({absValue,relValue,coerceTimestampRecord,coerceRelativeTimeRecord,addAbsRel,addRelRel,subtractAbsAbs,clampedSubtractAbsAbs,subtractAbsRel,subtractRelRel,isRelZero,multiplyRelNat,divideRelNat,divideRelRel,modAbsRel,modRelRel,compareAbs:(abs1,abs2)=>compareValues(abs1,abs2,absValue(abs1),absValue(abs2)),compareRel:(rel1,rel2)=>compareValues(rel1,rel2,relValue(rel1),relValue(rel2))});var KeywordShape=M.string();var InvitationHandleShape=M.remotable("InvitationHandle");var InvitationShape=M.remotable("Invitation");var InstanceHandleShape=M.remotable("InstanceHandle");var InstallationShape=M.remotable("Installation");var SeatShape=M.remotable("Seat");var AmountKeywordRecordShape=M.recordOf(KeywordShape,AmountShape);var AmountPatternKeywordRecordShape=M.recordOf(KeywordShape,M.pattern());var PaymentPKeywordRecordShape=M.recordOf(KeywordShape,M.eref(PaymentShape));var IssuerKeywordRecordShape=M.recordOf(KeywordShape,IssuerShape);var IssuerPKeywordRecordShape=M.recordOf(KeywordShape,M.eref(IssuerShape));var BrandKeywordRecordShape=M.recordOf(KeywordShape,BrandShape);var IssuerRecordShape=M.splitRecord({brand:BrandShape,issuer:IssuerShape,assetKind:AssetKindShape},{displayInfo:DisplayInfoShape});var TermsShape={issuers:IssuerKeywordRecordShape,brands:BrandKeywordRecordShape};harden(TermsShape);var InstanceRecordShape={installation:InstallationShape,instance:InstanceHandleShape,terms:M.splitRecord(TermsShape)};harden(InstanceRecordShape);var HandleI=M.interface("Handle",{});var makeHandleShape=name=>M.remotable(`${name}Handle`);var TimerShape=makeHandleShape("timer");var FullProposalShape={want:AmountPatternKeywordRecordShape,give:AmountKeywordRecordShape,exit:M.splitRecord({},{onDemand:null,waived:null,afterDeadline:{timer:M.eref(TimerShape),deadline:TimestampShape}},{})};harden(FullProposalShape);var ProposalShape=M.splitRecord({},FullProposalShape,{});var EmptyProposalShape=M.splitRecord({give:{},want:{},exit:{onDemand:null}});var isOnDemandExitRule=exit=>{const[exitKey]=Object.keys(exit);return exitKey==="onDemand"};harden(isOnDemandExitRule);var isWaivedExitRule=exit=>{const[exitKey]=Object.keys(exit);return exitKey==="waived"};harden(isWaivedExitRule);var isAfterDeadlineExitRule=exit=>{const[exitKey]=Object.keys(exit);return exitKey==="afterDeadline"};harden(isAfterDeadlineExitRule);var InvitationElementShape=M.splitRecord({description:M.string(),handle:InvitationHandleShape,instance:InstanceHandleShape,installation:InstallationShape});var OfferHandlerI=M.interface("OfferHandler",{handle:M.call(SeatShape).optional(M.any()).returns(M.any())});var SeatHandleAllocationsShape=M.arrayOf({seatHandle:SeatShape,allocation:AmountKeywordRecordShape});var ZoeMintShape=M.remotable("ZoeMint");var ZoeMintI=M.interface("ZoeMint",{getIssuerRecord:M.call().returns(IssuerRecordShape),mintAndEscrow:M.call(AmountShape).returns(),withdrawAndBurn:M.call(AmountShape).returns()});var FeeMintAccessShape=M.remotable("FeeMintAccess");var ExitObjectI=M.interface("Exit Object",{exit:M.call().returns()});var ExitObjectShape=M.remotable("ExitObj");var InstanceAdminShape=M.remotable("InstanceAdmin");var InstanceAdminI=M.interface("InstanceAdmin",{makeInvitation:M.call(InvitationHandleShape,M.string()).optional(M.record(),M.pattern()).returns(InvitationShape),saveIssuer:M.callWhen(M.await(IssuerShape),KeywordShape).returns(IssuerRecordShape),makeNoEscrowSeat:M.call(AmountKeywordRecordShape,ProposalShape,ExitObjectShape,SeatShape).returns(SeatShape),exitAllSeats:M.call(M.any()).returns(),failAllSeats:M.call(M.any()).returns(),exitSeat:M.call(SeatShape,M.any()).returns(),failSeat:M.call(SeatShape,M.any()).returns(),makeZoeMint:M.call(KeywordShape).optional(AssetKindShape,DisplayInfoShape,M.splitRecord({},{elementShape:M.pattern()})).returns(M.remotable("zoeMint")),registerFeeMint:M.call(KeywordShape,FeeMintAccessShape).returns(M.remotable("feeMint")),replaceAllocations:M.call(SeatHandleAllocationsShape).returns(),stopAcceptingOffers:M.call().returns(),setOfferFilter:M.call(M.arrayOf(M.string())).returns(),getOfferFilter:M.call().returns(M.arrayOf(M.string())),getExitSubscriber:M.call(SeatShape).returns(SubscriberShape),isBlocked:M.call(M.string()).returns(M.boolean()),repairContractCompletionWatcher:M.call().returns()});var InstanceStorageManagerIKit={instanceStorageManager:M.interface("InstanceStorageManager",{getTerms:M.call().returns(M.splitRecord(TermsShape)),getIssuers:M.call().returns(IssuerKeywordRecordShape),getBrands:M.call().returns(BrandKeywordRecordShape),getInstallation:M.call().returns(InstallationShape),getInvitationIssuer:M.call().returns(IssuerShape),saveIssuer:M.call(IssuerShape,KeywordShape).returns(M.promise()),makeZoeMint:M.call(KeywordShape).optional(AssetKindShape,DisplayInfoShape,M.splitRecord({},{elementShape:M.pattern()})).returns(M.eref(ZoeMintShape)),registerFeeMint:M.call(KeywordShape,FeeMintAccessShape).returns(M.remotable("feeMint")),getInstanceRecord:M.call().returns(InstanceRecordShape),getIssuerRecords:M.call().returns(M.arrayOf(IssuerRecordShape)),getWithdrawFacet:M.call().returns(M.remotable("WithdrawFacet")),initInstanceAdmin:M.call(InstanceHandleShape,M.remotable("instanceAdmin")).returns(M.promise()),deleteInstanceAdmin:M.call(InstanceAdminShape).returns(),makeInvitation:M.call(InvitationHandleShape,M.string()).optional(M.record(),M.pattern()).returns(PaymentShape),getRoot:M.call().returns(M.any()),getAdminNode:M.call().returns(M.remotable("adminNode"))}),withdrawFacet:M.interface("WithdrawFacet",{withdrawPayments:M.call(AmountKeywordRecordShape).returns(PaymentPKeywordRecordShape)}),helpers:M.interface("InstanceStorageManager helper",{wrapIssuerKitWithZoeMint:M.call(KeywordShape,IssuerKitShape,M.remotable("adminNode")).returns(ZoeMintShape)})};harden(InstanceStorageManagerIKit);var BundleCapShape=M.remotable("bundleCap");var BundleShape=M.and(M.splitRecord({moduleFormat:M.any()}),M.recordOf(M.string(),M.string({stringLengthLimit:Infinity})));var UnwrappedInstallationShape=M.splitRecord({installation:InstallationShape},{bundle:M.recordOf(M.string(),M.string({stringLengthLimit:Infinity})),bundleCap:BundleCapShape,bundleID:M.string()},{});var ZoeStorageManagerIKit={zoeServiceDataAccess:M.interface("ZoeService dataAccess",{getTerms:M.call(InstanceHandleShape).returns(M.splitRecord(TermsShape)),getIssuers:M.call(InstanceHandleShape).returns(IssuerKeywordRecordShape),getBrands:M.call(InstanceHandleShape).returns(BrandKeywordRecordShape),getInstallation:M.call(InstanceHandleShape).returns(M.eref(M.remotable("Installation"))),getInvitationIssuer:M.call().returns(IssuerShape),getBundleIDFromInstallation:M.call(InstallationShape).returns(M.eref(M.string())),installBundle:M.call(BundleShape).optional(M.string()).returns(M.promise()),installBundleID:M.call(M.string()).optional(M.string()).returns(M.promise()),getPublicFacet:M.call(InstanceHandleShape).returns(M.eref(M.remotable("PublicFacet"))),getOfferFilter:M.call(InstanceHandleShape).returns(M.arrayOf(M.string())),getProposalShapeForInvitation:M.call(InvitationHandleShape).returns(M.opt(M.pattern()))}),makeOfferAccess:M.interface("ZoeStorage makeOffer access",{getAssetKindByBrand:M.call(BrandShape).returns(AssetKindShape),getInstanceAdmin:M.call(InstanceHandleShape).returns(M.remotable("instanceAdmin")),getProposalShapeForInvitation:M.call(InvitationHandleShape).returns(M.opt(M.pattern())),getInvitationIssuer:M.call().returns(IssuerShape),depositPayments:M.call(ProposalShape,PaymentPKeywordRecordShape).returns(M.promise())}),startInstanceAccess:M.interface("ZoeStorage startInstance access",{makeZoeInstanceStorageManager:M.call(InstallationShape,M.any(),IssuerPKeywordRecordShape,InstanceHandleShape,M.or(BundleCapShape,BundleShape),M.string()).returns(M.promise()),unwrapInstallation:M.callWhen(M.eref(InstallationShape)).returns(UnwrappedInstallationShape)}),invitationIssuerAccess:M.interface("ZoeStorage invitationIssuer",{getInvitationIssuer:M.call().returns(IssuerShape)})};harden(ZoeStorageManagerIKit);var ZoeServiceI=M.interface("ZoeService",{install:M.call(M.any()).optional(M.string()).returns(M.promise()),installBundleID:M.call(M.string()).optional(M.string()).returns(M.promise()),startInstance:M.call(M.eref(InstallationShape)).optional(IssuerPKeywordRecordShape,M.record(),M.record(),M.string()).returns(M.promise()),offer:M.call(M.eref(InvitationShape)).optional(ProposalShape,PaymentPKeywordRecordShape,M.any()).returns(M.promise()),getOfferFilter:M.callWhen(M.await(InstanceHandleShape)).returns(M.arrayOf(M.string())),getInvitationIssuer:M.call().returns(M.promise()),getFeeIssuer:M.call().returns(M.promise()),getBrands:M.callWhen(M.await(InstanceHandleShape)).returns(BrandKeywordRecordShape),getIssuers:M.callWhen(M.await(InstanceHandleShape)).returns(IssuerKeywordRecordShape),getPublicFacet:M.callWhen(M.await(InstanceHandleShape)).returns(M.remotable("PublicFacet")),getTerms:M.callWhen(M.await(InstanceHandleShape)).returns(M.any()),getInstallationForInstance:M.callWhen(M.await(InstanceHandleShape)).returns(M.eref(M.remotable("Installation"))),getBundleIDFromInstallation:M.callWhen(M.await(InstallationShape)).returns(M.eref(M.string())),getInstallation:M.call(M.eref(InvitationShape)).returns(M.promise()),getInstance:M.call(M.eref(InvitationShape)).returns(M.promise()),getConfiguration:M.call().returns({feeIssuerConfig:{name:M.string(),assetKind:"nat",displayInfo:DisplayInfoShape}}),getInvitationDetails:M.call(M.eref(InvitationShape)).returns(M.any()),getProposalShapeForInvitation:M.call(InvitationHandleShape).returns(M.opt(M.pattern()))});var AdminFacetI=M.interface("ZcfAdminFacet",{getVatShutdownPromise:M.call().returns(M.promise()),restartContract:M.call().optional(M.any()).returns(M.promise()),upgradeContract:M.call(M.string()).optional(M.any()).returns(M.promise()),terminateContract:M.call(M.error()).returns(M.promise())});var SeatDataShape=M.splitRecord({proposal:ProposalShape,initialAllocation:AmountKeywordRecordShape,seatHandle:SeatShape},{offerArgs:M.any()});var HandleOfferI=M.interface("HandleOffer",{handleOffer:M.call(InvitationHandleShape,SeatDataShape).returns({offerResultPromise:M.promise(),exitObj:ExitObjectShape})});var PriceQuoteShape={quoteAmount:AmountShape,quotePayment:M.eref(PaymentShape)};harden(PriceQuoteShape);var TransferPartShape=M.splitArray(harden([M.opt(SeatShape),M.opt(SeatShape),M.opt(AmountKeywordRecordShape)]),harden([M.opt(AmountKeywordRecordShape)]));var atomicTransfer=(zcf,fromSeat=void 0,toSeat=void 0,fromAmounts=void 0,toAmounts=void 0)=>zcf.atomicRearrange(harden([[fromSeat,toSeat,fromAmounts,toAmounts]]));var satisfiesInternal=(giveOrWant={},allocation)=>{const isGTEByKeyword=([keyword,requiredAmount])=>{if(allocation[keyword]===void 0){return 0}const allocationAmount=allocation[keyword];return AmountMath.isGTE(allocationAmount,requiredAmount)?1:0};return Object.entries(giveOrWant).every(isGTEByKeyword)?1:0};var satisfiesWant=(proposal,allocation)=>satisfiesInternal(proposal.want,allocation);var satisfiesGive=(proposal,allocation)=>satisfiesInternal(proposal.give,allocation);function isOfferSafe(proposal,allocation){return satisfiesGive(proposal,allocation)>0||satisfiesWant(proposal,allocation)>0}harden(isOfferSafe);harden(satisfiesWant);var{multiply:multiply2,floorDivide:floorDivide2,ceilDivide,bankersDivide,add:add2,subtract:subtract2}=natSafeMath;var makeEphemeraProvider=init=>{const extant=new WeakMap;return key=>{if(extant.has(key)){return extant.get(key)}const newEph=init(key);extant.set(key,newEph);return newEph}};harden(makeEphemeraProvider);var provideEmptySeat=(zcf,baggage,name)=>{return provide(baggage,name,()=>zcf.makeEmptySeatKit().zcfSeat)};harden(provideEmptySeat);var provideAll=(baggage,thunks)=>{const keys2=Object.keys(thunks);const inBaggage=baggage.has(keys2[0]);if(inBaggage){const obj=objectMap(thunks,(_,k)=>baggage.get(k));return Promise.resolve(harden(obj))}const keyedPromises=objectMap(thunks,fn=>fn());return allValues(keyedPromises).then(keyedVals=>{for(const[k,v]of Object.entries(keyedVals)){baggage.init(k,v)}return keyedVals})};harden(provideAll);var wrapperMethods=(wrapperKindName,uMethodNames,extraMethods={})=>harden({...fromUniqueEntries(uMethodNames.map(name=>[name,{[name](...args){const{underlying}=this.state;underlying!==void 0||throwRedacted`${quote(wrapperKindName)} revoked`;return underlying[name](...args)}}[name]])),...extraMethods});harden(wrapperMethods);var prepareAttenuatorMaker=(zone,uKindName,uMethodNames,options={})=>{const{uInterfaceName=uKindName,extraMethodGuards={},extraMethods={}}=options;const AttenuatorI=M.interface(`${uInterfaceName}_attenuator`,extraMethodGuards,{defaultGuards:"raw"});const attenuatorKindName=`${uKindName}_attenuator`;return zone.exoClass(attenuatorKindName,AttenuatorI,underlying=>({underlying}),wrapperMethods(attenuatorKindName,uMethodNames,extraMethods),{stateShape:{underlying:M.opt(M.remotable("underlying"))}})};harden(prepareAttenuatorMaker);var RemotablePrefixRE=/^(Alleged: |DebugName: )/;var attenuateOne=(underlying,uMethodNames,options=void 0)=>{const heapZone=makeHeapZone();const uKindName=(underlying[Symbol.toStringTag]||"Underlying").replace(RemotablePrefixRE,"");const makeAttenuator=prepareAttenuatorMaker(heapZone,uKindName,uMethodNames,options);return makeAttenuator(underlying)};harden(attenuateOne);var prepareRevocableMakerKit=(zone,uKindName,uMethodNames,options={})=>{const{uInterfaceName=uKindName,extraMethodGuards={},extraMethods={}}=options;const RevocableIKit=harden({revoker:M.interface(`${uInterfaceName}_revoker`,{revoke:M.call().returns(M.boolean())}),revocable:M.interface(`${uInterfaceName}_revocable`,extraMethodGuards,{defaultGuards:"raw"})});const revocableKindName=`${uKindName}_caretaker`;let amplifier;const makeRevocableKit=zone.exoClassKit(revocableKindName,RevocableIKit,underlying=>({underlying}),{revoker:{revoke(){const{state}=this;if(state.underlying===void 0){return false}state.underlying=void 0;return true}},revocable:wrapperMethods(revocableKindName,uMethodNames,extraMethods)},{stateShape:{underlying:M.opt(M.remotable("underlying"))},receiveAmplifier:amp=>{amplifier=amp}});const makeRevocable=underlying=>makeRevocableKit(underlying).revocable;const revoke=revocable=>{const facets=amplifier(revocable);if(facets===void 0){return false}return facets.revoker.revoke()};return harden({revoke,makeRevocable,makeRevocableKit})};harden(prepareRevocableMakerKit);var TransferProposalShape=M.splitRecord({give:{},want:{},exit:{onDemand:null}});var prepareOwnable=(zone,makeInvitation,uKindName,uMethodNames,options={})=>{const{uInterfaceName=uKindName}=options;const{revoke,makeRevocable}=prepareRevocableMakerKit(zone,uKindName,uMethodNames,{uInterfaceName,extraMethodGuards:{makeTransferInvitation:M.call().returns(M.promise())},extraMethods:{makeTransferInvitation(){const{underlying}=this.state;const{revocable}=this.facets;const customDetails=underlying.getInvitationCustomDetails();const transferHandler=makeTransferHandler(underlying);const invitation=makeInvitation(transferHandler,"transfer",customDetails,TransferProposalShape);revoke(revocable);return invitation}}});const makeTransferHandler=zone.exoClass("TransferHandler",OfferHandlerI,underlying=>({underlying}),{handle(seat){const{underlying}=this.state;const revocable=makeRevocable(underlying);seat.exit();return revocable}});const makeOwnable=underlying=>makeRevocable(underlying);return harden(makeOwnable)};harden(prepareOwnable);var trace=makeTracer("PA",false);var GuardCallAmountTuple=M.call(AmountShape,AmountShape).returns(M.promise());var PriceAuthorityI=M.interface("PriceAuthority",{getQuoteIssuer:M.call(BrandShape,BrandShape).returns(M.promise()),getTimerService:M.call(BrandShape,BrandShape).returns(M.promise()),quoteGiven:M.call(AmountShape,BrandShape).returns(M.promise()),quoteWanted:M.call(BrandShape,AmountShape).returns(M.promise()),makeQuoteNotifier:M.call(AmountShape,BrandShape).returns(M.promise()),quoteAtTime:M.call(TimestampShape,AmountShape,BrandShape).returns(M.promise()),quoteWhenLT:GuardCallAmountTuple,quoteWhenLTE:GuardCallAmountTuple,quoteWhenGTE:GuardCallAmountTuple,quoteWhenGT:GuardCallAmountTuple,mutableQuoteWhenLT:GuardCallAmountTuple,mutableQuoteWhenLTE:GuardCallAmountTuple,mutableQuoteWhenGTE:GuardCallAmountTuple,mutableQuoteWhenGT:GuardCallAmountTuple});var unitAmount=async brand=>{const displayInfo=await E(brand).getDisplayInfo();const decimalPlaces=displayInfo.decimalPlaces??0;return AmountMath.make(brand,10n**Nat(decimalPlaces))};harden(unitAmount);var eventLoopIteration=async()=>new Promise(resolve=>setImmediate(resolve));harden(eventLoopIteration);var stringOrTag=value=>{if(typeof value==="string"){return value}else if(typeof value==="object"&&Symbol.toStringTag in value){return value[Symbol.toStringTag]}return String(value)};var inspectMapStore=store=>{const obj={};for(const key of store.keys()){const value=store.get(key);const hasKeys=typeof value==="object"&&"keys"in value;const index=stringOrTag(key);if(hasKeys&&"get"in value){obj[index]=inspectMapStore(value)}else if(hasKeys){obj[index]=Array.from(value.keys())}else{obj[index]=value instanceof Object&&Symbol.toStringTag in value?value[Symbol.toStringTag]:value}}return obj};harden(inspectMapStore);var makeFakeStorage=(path,publication)=>{let setValueCalls=0;const fullPath=`publish.${path}`;const storeKey=harden({storeName:"swingset",storeSubkey:`swingset/data:${fullPath}`,dataPrefixBytes:""});const storage=Far("StorageNode",{getPath:()=>path,getStoreKey:async()=>storeKey,setValue:async value=>{setValueCalls+=1;assert.typeof(value,"string");if(publication){publication.updateState(value)}},makeChildNode:()=>storage,countSetValueCalls:()=>setValueCalls});return storage};harden(makeFakeStorage);var makeFakeMarshaller=()=>makeMarshal(void 0,void 0,{marshalSaveError:()=>{}});harden(makeFakeMarshaller);var prepareRecorder=(baggage,marshaller)=>{const makeRecorder=prepareExoClass(baggage,"Recorder",M.interface("Recorder",{getStorageNode:M.call().returns(StorageNodeShape),getStoragePath:M.call().returns(M.promise()),write:M.call(M.any()).returns(M.promise()),writeFinal:M.call(M.any()).returns(M.promise())}),(publisher,storageNode,valueShape=M.any())=>{return{closed:false,publisher,storageNode,storagePath:void 0,valueShape}},{getStorageNode(){return this.state.storageNode},async getStoragePath(){const{storagePath:heldPath}=this.state;await null;if(heldPath!==void 0){return heldPath}const path=await E(this.state.storageNode).getPath();this.state.storagePath=path;return path},async write(value){const{closed,publisher,storageNode,valueShape}=this.state;!closed||throwRedacted`cannot write to closed recorder`;mustMatch2(value,valueShape);const encoded=await E(marshaller).toCapData(value);const serialized=JSON.stringify(encoded);await E(storageNode).setValue(serialized);return publisher.publish(value)},async writeFinal(value){const{closed,publisher,storageNode,valueShape}=this.state;!closed||throwRedacted`cannot write to closed recorder`;mustMatch2(value,valueShape);const encoded=await E(marshaller).toCapData(value);const serialized=JSON.stringify(encoded);await E(storageNode).setValue(serialized);this.state.closed=true;return publisher.finish(value)}});return makeRecorder};harden(prepareRecorder);var defineERecorderKit=({makeRecorder,makeDurablePublishKit})=>{const makeERecorderKit=(storageNodeP,valueShape)=>{const{publisher,subscriber}=makeDurablePublishKit();const recorderP=E.when(storageNodeP,storageNode=>makeRecorder(publisher,storageNode,valueShape));return{subscriber,recorderP}};return makeERecorderKit};harden(defineERecorderKit);var RecorderKitShape={recorder:M.remotable(),subscriber:M.remotable()};harden(RecorderKitShape);var PublicTopicShape=M.splitRecord({subscriber:SubscriberShape,storagePath:M.or(M.promise(),M.string())},{description:M.string()});var TopicsRecordShape=M.recordOf(M.string(),PublicTopicShape);var start=async zcf=>{const feeBrand=zcf.getTerms().brands.Fee;let handler;let revoked=false;const revokedMsg=`Oracle revoked`;const{zcfSeat:feeSeat}=zcf.makeEmptySeatKit();const realCreatorFacet=Far("realCreatorFacet",{makeWithdrawInvitation(total=false){return zcf.makeInvitation(seat=>{const gains=total?feeSeat.getCurrentAllocation():seat.getProposal().want;atomicTransfer(zcf,feeSeat,seat,gains);seat.exit();return"Successfully withdrawn"},"withdraw")},getCurrentFees(){return feeSeat.getCurrentAllocation()},makeShutdownInvitation:()=>{const shutdown=seat=>{revoked=true;atomicTransfer(zcf,feeSeat,seat,feeSeat.getCurrentAllocation());zcf.shutdown(revokedMsg)};return zcf.makeInvitation(shutdown,"shutdown")}});const creatorFacet=Far("creatorFacet",{initialize(privateParams){({oracleHandler:handler}=privateParams);return realCreatorFacet}});const publicFacet=Far("publicFacet",{async query(query){await null;try{assert2(!revoked,revokedMsg);const noFee=AmountMath.makeEmpty(feeBrand);const{requiredFee,reply}=await E(handler).onQuery(query,noFee);!requiredFee||AmountMath.isGTE(noFee,requiredFee)||throwRedacted`Oracle required a fee but the query had none`;return reply}catch(e){void E(handler).onError(query,e);throw e}},async makeQueryInvitation(query){const doQuery=async querySeat=>{await null;try{const fee=querySeat.getAmountAllocated("Fee",feeBrand);const{requiredFee,reply}=await E(handler).onQuery(query,fee);if(requiredFee){atomicTransfer(zcf,querySeat,feeSeat,{Fee:requiredFee})}querySeat.exit();void E(handler).onReply(query,reply,requiredFee);return reply}catch(e){void E(handler).onError(query,e);throw e}};return zcf.makeInvitation(doQuery,"oracle query",{query})}});return harden({creatorFacet,publicFacet})};harden(start);export{start};