npm - @hot-updater/aws - Versions diffs - 0.36.7 → 1.0.0-rc.0 - Mend

@hot-updater/aws 0.36.7 → 1.0.0-rc.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/dist/iac/index.cjs +2670 -824
package/dist/iac/index.d.cts +15 -1
package/dist/iac/index.d.mts +15 -1
package/dist/iac/index.mjs +2669 -825
package/dist/index.cjs +1916 -1853
package/dist/index.d.cts +37 -46
package/dist/index.d.mts +39 -47
package/dist/index.mjs +1916 -1828
package/dist/init/index.cjs +13 -13
package/dist/init/index.d.cts +13 -13
package/dist/init/index.d.mts +13 -13
package/dist/init/index.mjs +13 -13
package/dist/lambda/index.cjs +6468 -4308
package/dist/lambda/index.d.cts +4 -4
package/package.json +9 -9

package/dist/index.mjs CHANGED Viewed

@@ -1,1394 +1,1785 @@
 import { CloudFrontClient, CreateInvalidationCommand, GetInvalidationCommand } from "@aws-sdk/client-cloudfront";
-import { DeleteObjectCommand, DeleteObjectsCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, NoSuchKey, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
-import { createBlobDatabasePlugin, createStorageKeyBuilder, createUniversalStoragePlugin, getContentType, parseStorageUri } from "@hot-updater/plugin-core";
-import fs from "fs/promises";
-import path from "path";
-import { Upload } from "@aws-sdk/lib-storage";
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { BatchGetCommand, DynamoDBDocumentClient, GetCommand, PutCommand, QueryCommand, ScanCommand, TransactWriteCommand } from "@aws-sdk/lib-dynamodb";
+import { createDatabasePlugin, createStorageDownloadUrl, createStorageKeyBuilder, createStoragePlugin, createStorageUri, isDatabaseMetadataObject, parseStorageUri } from "@hot-updater/plugin-core";
+import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
 import { SSM } from "@aws-sdk/client-ssm";
-import { getSignedUrl as getSignedUrl$1 } from "@aws-sdk/cloudfront-signer";
-//#region ../../node_modules/.pnpm/mime@4.1.0/node_modules/mime/dist/types/other.js
-const types$1 = {
-	"application/prs.cww": ["cww"],
-	"application/prs.xsf+xml": ["xsf"],
-	"application/vnd.1000minds.decision-model+xml": ["1km"],
-	"application/vnd.3gpp.pic-bw-large": ["plb"],
-	"application/vnd.3gpp.pic-bw-small": ["psb"],
-	"application/vnd.3gpp.pic-bw-var": ["pvb"],
-	"application/vnd.3gpp2.tcap": ["tcap"],
-	"application/vnd.3m.post-it-notes": ["pwn"],
-	"application/vnd.accpac.simply.aso": ["aso"],
-	"application/vnd.accpac.simply.imp": ["imp"],
-	"application/vnd.acucobol": ["acu"],
-	"application/vnd.acucorp": ["atc", "acutc"],
-	"application/vnd.adobe.air-application-installer-package+zip": ["air"],
-	"application/vnd.adobe.formscentral.fcdt": ["fcdt"],
-	"application/vnd.adobe.fxp": ["fxp", "fxpl"],
-	"application/vnd.adobe.xdp+xml": ["xdp"],
-	"application/vnd.adobe.xfdf": ["*xfdf"],
-	"application/vnd.age": ["age"],
-	"application/vnd.ahead.space": ["ahead"],
-	"application/vnd.airzip.filesecure.azf": ["azf"],
-	"application/vnd.airzip.filesecure.azs": ["azs"],
-	"application/vnd.amazon.ebook": ["azw"],
-	"application/vnd.americandynamics.acc": ["acc"],
-	"application/vnd.amiga.ami": ["ami"],
-	"application/vnd.android.package-archive": ["apk"],
-	"application/vnd.anser-web-certificate-issue-initiation": ["cii"],
-	"application/vnd.anser-web-funds-transfer-initiation": ["fti"],
-	"application/vnd.antix.game-component": ["atx"],
-	"application/vnd.apple.installer+xml": ["mpkg"],
-	"application/vnd.apple.keynote": ["key"],
-	"application/vnd.apple.mpegurl": ["m3u8"],
-	"application/vnd.apple.numbers": ["numbers"],
-	"application/vnd.apple.pages": ["pages"],
-	"application/vnd.apple.pkpass": ["pkpass"],
-	"application/vnd.aristanetworks.swi": ["swi"],
-	"application/vnd.astraea-software.iota": ["iota"],
-	"application/vnd.audiograph": ["aep"],
-	"application/vnd.autodesk.fbx": ["fbx"],
-	"application/vnd.balsamiq.bmml+xml": ["bmml"],
-	"application/vnd.blueice.multipass": ["mpm"],
-	"application/vnd.bmi": ["bmi"],
-	"application/vnd.businessobjects": ["rep"],
-	"application/vnd.chemdraw+xml": ["cdxml"],
-	"application/vnd.chipnuts.karaoke-mmd": ["mmd"],
-	"application/vnd.cinderella": ["cdy"],
-	"application/vnd.citationstyles.style+xml": ["csl"],
-	"application/vnd.claymore": ["cla"],
-	"application/vnd.cloanto.rp9": ["rp9"],
-	"application/vnd.clonk.c4group": [
-		"c4g",
-		"c4d",
-		"c4f",
-		"c4p",
-		"c4u"
-	],
-	"application/vnd.cluetrust.cartomobile-config": ["c11amc"],
-	"application/vnd.cluetrust.cartomobile-config-pkg": ["c11amz"],
-	"application/vnd.commonspace": ["csp"],
-	"application/vnd.contact.cmsg": ["cdbcmsg"],
-	"application/vnd.cosmocaller": ["cmc"],
-	"application/vnd.crick.clicker": ["clkx"],
-	"application/vnd.crick.clicker.keyboard": ["clkk"],
-	"application/vnd.crick.clicker.palette": ["clkp"],
-	"application/vnd.crick.clicker.template": ["clkt"],
-	"application/vnd.crick.clicker.wordbank": ["clkw"],
-	"application/vnd.criticaltools.wbs+xml": ["wbs"],
-	"application/vnd.ctc-posml": ["pml"],
-	"application/vnd.cups-ppd": ["ppd"],
-	"application/vnd.curl.car": ["car"],
-	"application/vnd.curl.pcurl": ["pcurl"],
-	"application/vnd.dart": ["dart"],
-	"application/vnd.data-vision.rdz": ["rdz"],
-	"application/vnd.dbf": ["dbf"],
-	"application/vnd.dcmp+xml": ["dcmp"],
-	"application/vnd.dece.data": [
-		"uvf",
-		"uvvf",
-		"uvd",
-		"uvvd"
-	],
-	"application/vnd.dece.ttml+xml": ["uvt", "uvvt"],
-	"application/vnd.dece.unspecified": ["uvx", "uvvx"],
-	"application/vnd.dece.zip": ["uvz", "uvvz"],
-	"application/vnd.denovo.fcselayout-link": ["fe_launch"],
-	"application/vnd.dna": ["dna"],
-	"application/vnd.dolby.mlp": ["mlp"],
-	"application/vnd.dpgraph": ["dpg"],
-	"application/vnd.dreamfactory": ["dfac"],
-	"application/vnd.ds-keypoint": ["kpxx"],
-	"application/vnd.dvb.ait": ["ait"],
-	"application/vnd.dvb.service": ["svc"],
-	"application/vnd.dynageo": ["geo"],
-	"application/vnd.ecowin.chart": ["mag"],
-	"application/vnd.enliven": ["nml"],
-	"application/vnd.epson.esf": ["esf"],
-	"application/vnd.epson.msf": ["msf"],
-	"application/vnd.epson.quickanime": ["qam"],
-	"application/vnd.epson.salt": ["slt"],
-	"application/vnd.epson.ssf": ["ssf"],
-	"application/vnd.eszigno3+xml": ["es3", "et3"],
-	"application/vnd.ezpix-album": ["ez2"],
-	"application/vnd.ezpix-package": ["ez3"],
-	"application/vnd.fdf": ["*fdf"],
-	"application/vnd.fdsn.mseed": ["mseed"],
-	"application/vnd.fdsn.seed": ["seed", "dataless"],
-	"application/vnd.flographit": ["gph"],
-	"application/vnd.fluxtime.clip": ["ftc"],
-	"application/vnd.framemaker": [
-		"fm",
-		"frame",
-		"maker",
-		"book"
-	],
-	"application/vnd.frogans.fnc": ["fnc"],
-	"application/vnd.frogans.ltf": ["ltf"],
-	"application/vnd.fsc.weblaunch": ["fsc"],
-	"application/vnd.fujitsu.oasys": ["oas"],
-	"application/vnd.fujitsu.oasys2": ["oa2"],
-	"application/vnd.fujitsu.oasys3": ["oa3"],
-	"application/vnd.fujitsu.oasysgp": ["fg5"],
-	"application/vnd.fujitsu.oasysprs": ["bh2"],
-	"application/vnd.fujixerox.ddd": ["ddd"],
-	"application/vnd.fujixerox.docuworks": ["xdw"],
-	"application/vnd.fujixerox.docuworks.binder": ["xbd"],
-	"application/vnd.fuzzysheet": ["fzs"],
-	"application/vnd.genomatix.tuxedo": ["txd"],
-	"application/vnd.geogebra.file": ["ggb"],
-	"application/vnd.geogebra.slides": ["ggs"],
-	"application/vnd.geogebra.tool": ["ggt"],
-	"application/vnd.geometry-explorer": ["gex", "gre"],
-	"application/vnd.geonext": ["gxt"],
-	"application/vnd.geoplan": ["g2w"],
-	"application/vnd.geospace": ["g3w"],
-	"application/vnd.gmx": ["gmx"],
-	"application/vnd.google-apps.document": ["gdoc"],
-	"application/vnd.google-apps.drawing": ["gdraw"],
-	"application/vnd.google-apps.form": ["gform"],
-	"application/vnd.google-apps.jam": ["gjam"],
-	"application/vnd.google-apps.map": ["gmap"],
-	"application/vnd.google-apps.presentation": ["gslides"],
-	"application/vnd.google-apps.script": ["gscript"],
-	"application/vnd.google-apps.site": ["gsite"],
-	"application/vnd.google-apps.spreadsheet": ["gsheet"],
-	"application/vnd.google-earth.kml+xml": ["kml"],
-	"application/vnd.google-earth.kmz": ["kmz"],
-	"application/vnd.gov.sk.xmldatacontainer+xml": ["xdcf"],
-	"application/vnd.grafeq": ["gqf", "gqs"],
-	"application/vnd.groove-account": ["gac"],
-	"application/vnd.groove-help": ["ghf"],
-	"application/vnd.groove-identity-message": ["gim"],
-	"application/vnd.groove-injector": ["grv"],
-	"application/vnd.groove-tool-message": ["gtm"],
-	"application/vnd.groove-tool-template": ["tpl"],
-	"application/vnd.groove-vcard": ["vcg"],
-	"application/vnd.hal+xml": ["hal"],
-	"application/vnd.handheld-entertainment+xml": ["zmm"],
-	"application/vnd.hbci": ["hbci"],
-	"application/vnd.hhe.lesson-player": ["les"],
-	"application/vnd.hp-hpgl": ["hpgl"],
-	"application/vnd.hp-hpid": ["hpid"],
-	"application/vnd.hp-hps": ["hps"],
-	"application/vnd.hp-jlyt": ["jlt"],
-	"application/vnd.hp-pcl": ["pcl"],
-	"application/vnd.hp-pclxl": ["pclxl"],
-	"application/vnd.hydrostatix.sof-data": ["sfd-hdstx"],
-	"application/vnd.ibm.minipay": ["mpy"],
-	"application/vnd.ibm.modcap": [
-		"afp",
-		"listafp",
-		"list3820"
-	],
-	"application/vnd.ibm.rights-management": ["irm"],
-	"application/vnd.ibm.secure-container": ["sc"],
-	"application/vnd.iccprofile": ["icc", "icm"],
-	"application/vnd.igloader": ["igl"],
-	"application/vnd.immervision-ivp": ["ivp"],
-	"application/vnd.immervision-ivu": ["ivu"],
-	"application/vnd.insors.igm": ["igm"],
-	"application/vnd.intercon.formnet": ["xpw", "xpx"],
-	"application/vnd.intergeo": ["i2g"],
-	"application/vnd.intu.qbo": ["qbo"],
-	"application/vnd.intu.qfx": ["qfx"],
-	"application/vnd.ipunplugged.rcprofile": ["rcprofile"],
-	"application/vnd.irepository.package+xml": ["irp"],
-	"application/vnd.is-xpr": ["xpr"],
-	"application/vnd.isac.fcs": ["fcs"],
-	"application/vnd.jam": ["jam"],
-	"application/vnd.jcp.javame.midlet-rms": ["rms"],
-	"application/vnd.jisp": ["jisp"],
-	"application/vnd.joost.joda-archive": ["joda"],
-	"application/vnd.kahootz": ["ktz", "ktr"],
-	"application/vnd.kde.karbon": ["karbon"],
-	"application/vnd.kde.kchart": ["chrt"],
-	"application/vnd.kde.kformula": ["kfo"],
-	"application/vnd.kde.kivio": ["flw"],
-	"application/vnd.kde.kontour": ["kon"],
-	"application/vnd.kde.kpresenter": ["kpr", "kpt"],
-	"application/vnd.kde.kspread": ["ksp"],
-	"application/vnd.kde.kword": ["kwd", "kwt"],
-	"application/vnd.kenameaapp": ["htke"],
-	"application/vnd.kidspiration": ["kia"],
-	"application/vnd.kinar": ["kne", "knp"],
-	"application/vnd.koan": [
-		"skp",
-		"skd",
-		"skt",
-		"skm"
-	],
-	"application/vnd.kodak-descriptor": ["sse"],
-	"application/vnd.las.las+xml": ["lasxml"],
-	"application/vnd.llamagraphics.life-balance.desktop": ["lbd"],
-	"application/vnd.llamagraphics.life-balance.exchange+xml": ["lbe"],
-	"application/vnd.lotus-1-2-3": ["123"],
-	"application/vnd.lotus-approach": ["apr"],
-	"application/vnd.lotus-freelance": ["pre"],
-	"application/vnd.lotus-notes": ["nsf"],
-	"application/vnd.lotus-organizer": ["org"],
-	"application/vnd.lotus-screencam": ["scm"],
-	"application/vnd.lotus-wordpro": ["lwp"],
-	"application/vnd.macports.portpkg": ["portpkg"],
-	"application/vnd.mapbox-vector-tile": ["mvt"],
-	"application/vnd.mcd": ["mcd"],
-	"application/vnd.medcalcdata": ["mc1"],
-	"application/vnd.mediastation.cdkey": ["cdkey"],
-	"application/vnd.mfer": ["mwf"],
-	"application/vnd.mfmp": ["mfm"],
-	"application/vnd.micrografx.flo": ["flo"],
-	"application/vnd.micrografx.igx": ["igx"],
-	"application/vnd.mif": ["mif"],
-	"application/vnd.mobius.daf": ["daf"],
-	"application/vnd.mobius.dis": ["dis"],
-	"application/vnd.mobius.mbk": ["mbk"],
-	"application/vnd.mobius.mqy": ["mqy"],
-	"application/vnd.mobius.msl": ["msl"],
-	"application/vnd.mobius.plc": ["plc"],
-	"application/vnd.mobius.txf": ["txf"],
-	"application/vnd.mophun.application": ["mpn"],
-	"application/vnd.mophun.certificate": ["mpc"],
-	"application/vnd.mozilla.xul+xml": ["xul"],
-	"application/vnd.ms-artgalry": ["cil"],
-	"application/vnd.ms-cab-compressed": ["cab"],
-	"application/vnd.ms-excel": [
-		"xls",
-		"xlm",
-		"xla",
-		"xlc",
-		"xlt",
-		"xlw"
-	],
-	"application/vnd.ms-excel.addin.macroenabled.12": ["xlam"],
-	"application/vnd.ms-excel.sheet.binary.macroenabled.12": ["xlsb"],
-	"application/vnd.ms-excel.sheet.macroenabled.12": ["xlsm"],
-	"application/vnd.ms-excel.template.macroenabled.12": ["xltm"],
-	"application/vnd.ms-fontobject": ["eot"],
-	"application/vnd.ms-htmlhelp": ["chm"],
-	"application/vnd.ms-ims": ["ims"],
-	"application/vnd.ms-lrm": ["lrm"],
-	"application/vnd.ms-officetheme": ["thmx"],
-	"application/vnd.ms-outlook": ["msg"],
-	"application/vnd.ms-pki.seccat": ["cat"],
-	"application/vnd.ms-pki.stl": ["*stl"],
-	"application/vnd.ms-powerpoint": [
-		"ppt",
-		"pps",
-		"pot"
-	],
-	"application/vnd.ms-powerpoint.addin.macroenabled.12": ["ppam"],
-	"application/vnd.ms-powerpoint.presentation.macroenabled.12": ["pptm"],
-	"application/vnd.ms-powerpoint.slide.macroenabled.12": ["sldm"],
-	"application/vnd.ms-powerpoint.slideshow.macroenabled.12": ["ppsm"],
-	"application/vnd.ms-powerpoint.template.macroenabled.12": ["potm"],
-	"application/vnd.ms-project": ["*mpp", "mpt"],
-	"application/vnd.ms-visio.viewer": ["vdx"],
-	"application/vnd.ms-word.document.macroenabled.12": ["docm"],
-	"application/vnd.ms-word.template.macroenabled.12": ["dotm"],
-	"application/vnd.ms-works": [
-		"wps",
-		"wks",
-		"wcm",
-		"wdb"
-	],
-	"application/vnd.ms-wpl": ["wpl"],
-	"application/vnd.ms-xpsdocument": ["xps"],
-	"application/vnd.mseq": ["mseq"],
-	"application/vnd.musician": ["mus"],
-	"application/vnd.muvee.style": ["msty"],
-	"application/vnd.mynfc": ["taglet"],
-	"application/vnd.nato.bindingdataobject+xml": ["bdo"],
-	"application/vnd.neurolanguage.nlu": ["nlu"],
-	"application/vnd.nitf": ["ntf", "nitf"],
-	"application/vnd.noblenet-directory": ["nnd"],
-	"application/vnd.noblenet-sealer": ["nns"],
-	"application/vnd.noblenet-web": ["nnw"],
-	"application/vnd.nokia.n-gage.ac+xml": ["*ac"],
-	"application/vnd.nokia.n-gage.data": ["ngdat"],
-	"application/vnd.nokia.n-gage.symbian.install": ["n-gage"],
-	"application/vnd.nokia.radio-preset": ["rpst"],
-	"application/vnd.nokia.radio-presets": ["rpss"],
-	"application/vnd.novadigm.edm": ["edm"],
-	"application/vnd.novadigm.edx": ["edx"],
-	"application/vnd.novadigm.ext": ["ext"],
-	"application/vnd.oasis.opendocument.chart": ["odc"],
-	"application/vnd.oasis.opendocument.chart-template": ["otc"],
-	"application/vnd.oasis.opendocument.database": ["odb"],
-	"application/vnd.oasis.opendocument.formula": ["odf"],
-	"application/vnd.oasis.opendocument.formula-template": ["odft"],
-	"application/vnd.oasis.opendocument.graphics": ["odg"],
-	"application/vnd.oasis.opendocument.graphics-template": ["otg"],
-	"application/vnd.oasis.opendocument.image": ["odi"],
-	"application/vnd.oasis.opendocument.image-template": ["oti"],
-	"application/vnd.oasis.opendocument.presentation": ["odp"],
-	"application/vnd.oasis.opendocument.presentation-template": ["otp"],
-	"application/vnd.oasis.opendocument.spreadsheet": ["ods"],
-	"application/vnd.oasis.opendocument.spreadsheet-template": ["ots"],
-	"application/vnd.oasis.opendocument.text": ["odt"],
-	"application/vnd.oasis.opendocument.text-master": ["odm"],
-	"application/vnd.oasis.opendocument.text-template": ["ott"],
-	"application/vnd.oasis.opendocument.text-web": ["oth"],
-	"application/vnd.olpc-sugar": ["xo"],
-	"application/vnd.oma.dd2+xml": ["dd2"],
-	"application/vnd.openblox.game+xml": ["obgx"],
-	"application/vnd.openofficeorg.extension": ["oxt"],
-	"application/vnd.openstreetmap.data+xml": ["osm"],
-	"application/vnd.openxmlformats-officedocument.presentationml.presentation": ["pptx"],
-	"application/vnd.openxmlformats-officedocument.presentationml.slide": ["sldx"],
-	"application/vnd.openxmlformats-officedocument.presentationml.slideshow": ["ppsx"],
-	"application/vnd.openxmlformats-officedocument.presentationml.template": ["potx"],
-	"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ["xlsx"],
-	"application/vnd.openxmlformats-officedocument.spreadsheetml.template": ["xltx"],
-	"application/vnd.openxmlformats-officedocument.wordprocessingml.document": ["docx"],
-	"application/vnd.openxmlformats-officedocument.wordprocessingml.template": ["dotx"],
-	"application/vnd.osgeo.mapguide.package": ["mgp"],
-	"application/vnd.osgi.dp": ["dp"],
-	"application/vnd.osgi.subsystem": ["esa"],
-	"application/vnd.palm": [
-		"pdb",
-		"pqa",
-		"oprc"
-	],
-	"application/vnd.pawaafile": ["paw"],
-	"application/vnd.pg.format": ["str"],
-	"application/vnd.pg.osasli": ["ei6"],
-	"application/vnd.picsel": ["efif"],
-	"application/vnd.pmi.widget": ["wg"],
-	"application/vnd.pocketlearn": ["plf"],
-	"application/vnd.powerbuilder6": ["pbd"],
-	"application/vnd.previewsystems.box": ["box"],
-	"application/vnd.procrate.brushset": ["brushset"],
-	"application/vnd.procreate.brush": ["brush"],
-	"application/vnd.procreate.dream": ["drm"],
-	"application/vnd.proteus.magazine": ["mgz"],
-	"application/vnd.publishare-delta-tree": ["qps"],
-	"application/vnd.pvi.ptid1": ["ptid"],
-	"application/vnd.pwg-xhtml-print+xml": ["xhtm"],
-	"application/vnd.quark.quarkxpress": [
-		"qxd",
-		"qxt",
-		"qwd",
-		"qwt",
-		"qxl",
-		"qxb"
-	],
-	"application/vnd.rar": ["rar"],
-	"application/vnd.realvnc.bed": ["bed"],
-	"application/vnd.recordare.musicxml": ["mxl"],
-	"application/vnd.recordare.musicxml+xml": ["musicxml"],
-	"application/vnd.rig.cryptonote": ["cryptonote"],
-	"application/vnd.rim.cod": ["cod"],
-	"application/vnd.rn-realmedia": ["rm"],
-	"application/vnd.rn-realmedia-vbr": ["rmvb"],
-	"application/vnd.route66.link66+xml": ["link66"],
-	"application/vnd.sailingtracker.track": ["st"],
-	"application/vnd.seemail": ["see"],
-	"application/vnd.sema": ["sema"],
-	"application/vnd.semd": ["semd"],
-	"application/vnd.semf": ["semf"],
-	"application/vnd.shana.informed.formdata": ["ifm"],
-	"application/vnd.shana.informed.formtemplate": ["itp"],
-	"application/vnd.shana.informed.interchange": ["iif"],
-	"application/vnd.shana.informed.package": ["ipk"],
-	"application/vnd.simtech-mindmapper": ["twd", "twds"],
-	"application/vnd.smaf": ["mmf"],
-	"application/vnd.smart.teacher": ["teacher"],
-	"application/vnd.software602.filler.form+xml": ["fo"],
-	"application/vnd.solent.sdkm+xml": ["sdkm", "sdkd"],
-	"application/vnd.spotfire.dxp": ["dxp"],
-	"application/vnd.spotfire.sfs": ["sfs"],
-	"application/vnd.stardivision.calc": ["sdc"],
-	"application/vnd.stardivision.draw": ["sda"],
-	"application/vnd.stardivision.impress": ["sdd"],
-	"application/vnd.stardivision.math": ["smf"],
-	"application/vnd.stardivision.writer": ["sdw", "vor"],
-	"application/vnd.stardivision.writer-global": ["sgl"],
-	"application/vnd.stepmania.package": ["smzip"],
-	"application/vnd.stepmania.stepchart": ["sm"],
-	"application/vnd.sun.wadl+xml": ["wadl"],
-	"application/vnd.sun.xml.calc": ["sxc"],
-	"application/vnd.sun.xml.calc.template": ["stc"],
-	"application/vnd.sun.xml.draw": ["sxd"],
-	"application/vnd.sun.xml.draw.template": ["std"],
-	"application/vnd.sun.xml.impress": ["sxi"],
-	"application/vnd.sun.xml.impress.template": ["sti"],
-	"application/vnd.sun.xml.math": ["sxm"],
-	"application/vnd.sun.xml.writer": ["sxw"],
-	"application/vnd.sun.xml.writer.global": ["sxg"],
-	"application/vnd.sun.xml.writer.template": ["stw"],
-	"application/vnd.sus-calendar": ["sus", "susp"],
-	"application/vnd.svd": ["svd"],
-	"application/vnd.symbian.install": ["sis", "sisx"],
-	"application/vnd.syncml+xml": ["xsm"],
-	"application/vnd.syncml.dm+wbxml": ["bdm"],
-	"application/vnd.syncml.dm+xml": ["xdm"],
-	"application/vnd.syncml.dmddf+xml": ["ddf"],
-	"application/vnd.tao.intent-module-archive": ["tao"],
-	"application/vnd.tcpdump.pcap": [
-		"pcap",
-		"cap",
-		"dmp"
-	],
-	"application/vnd.tmobile-livetv": ["tmo"],
-	"application/vnd.trid.tpt": ["tpt"],
-	"application/vnd.triscape.mxs": ["mxs"],
-	"application/vnd.trueapp": ["tra"],
-	"application/vnd.ufdl": ["ufd", "ufdl"],
-	"application/vnd.uiq.theme": ["utz"],
-	"application/vnd.umajin": ["umj"],
-	"application/vnd.unity": ["unityweb"],
-	"application/vnd.uoml+xml": ["uoml", "uo"],
-	"application/vnd.vcx": ["vcx"],
-	"application/vnd.visio": [
-		"vsd",
-		"vst",
-		"vss",
-		"vsw",
-		"vsdx",
-		"vtx"
-	],
-	"application/vnd.visionary": ["vis"],
-	"application/vnd.vsf": ["vsf"],
-	"application/vnd.wap.wbxml": ["wbxml"],
-	"application/vnd.wap.wmlc": ["wmlc"],
-	"application/vnd.wap.wmlscriptc": ["wmlsc"],
-	"application/vnd.webturbo": ["wtb"],
-	"application/vnd.wolfram.player": ["nbp"],
-	"application/vnd.wordperfect": ["wpd"],
-	"application/vnd.wqd": ["wqd"],
-	"application/vnd.wt.stf": ["stf"],
-	"application/vnd.xara": ["xar"],
-	"application/vnd.xfdl": ["xfdl"],
-	"application/vnd.yamaha.hv-dic": ["hvd"],
-	"application/vnd.yamaha.hv-script": ["hvs"],
-	"application/vnd.yamaha.hv-voice": ["hvp"],
-	"application/vnd.yamaha.openscoreformat": ["osf"],
-	"application/vnd.yamaha.openscoreformat.osfpvg+xml": ["osfpvg"],
-	"application/vnd.yamaha.smaf-audio": ["saf"],
-	"application/vnd.yamaha.smaf-phrase": ["spf"],
-	"application/vnd.yellowriver-custom-menu": ["cmp"],
-	"application/vnd.zul": ["zir", "zirz"],
-	"application/vnd.zzazz.deck+xml": ["zaz"],
-	"application/x-7z-compressed": ["7z"],
-	"application/x-abiword": ["abw"],
-	"application/x-ace-compressed": ["ace"],
-	"application/x-apple-diskimage": ["*dmg"],
-	"application/x-arj": ["arj"],
-	"application/x-authorware-bin": [
-		"aab",
-		"x32",
-		"u32",
-		"vox"
-	],
-	"application/x-authorware-map": ["aam"],
-	"application/x-authorware-seg": ["aas"],
-	"application/x-bcpio": ["bcpio"],
-	"application/x-bdoc": ["*bdoc"],
-	"application/x-bittorrent": ["torrent"],
-	"application/x-blender": ["blend"],
-	"application/x-blorb": ["blb", "blorb"],
-	"application/x-bzip": ["bz"],
-	"application/x-bzip2": ["bz2", "boz"],
-	"application/x-cbr": [
-		"cbr",
-		"cba",
-		"cbt",
-		"cbz",
-		"cb7"
-	],
-	"application/x-cdlink": ["vcd"],
-	"application/x-cfs-compressed": ["cfs"],
-	"application/x-chat": ["chat"],
-	"application/x-chess-pgn": ["pgn"],
-	"application/x-chrome-extension": ["crx"],
-	"application/x-cocoa": ["cco"],
-	"application/x-compressed": ["*rar"],
-	"application/x-conference": ["nsc"],
-	"application/x-cpio": ["cpio"],
-	"application/x-csh": ["csh"],
-	"application/x-debian-package": ["*deb", "udeb"],
-	"application/x-dgc-compressed": ["dgc"],
-	"application/x-director": [
-		"dir",
-		"dcr",
-		"dxr",
-		"cst",
-		"cct",
-		"cxt",
-		"w3d",
-		"fgd",
-		"swa"
-	],
-	"application/x-doom": ["wad"],
-	"application/x-dtbncx+xml": ["ncx"],
-	"application/x-dtbook+xml": ["dtb"],
-	"application/x-dtbresource+xml": ["res"],
-	"application/x-dvi": ["dvi"],
-	"application/x-envoy": ["evy"],
-	"application/x-eva": ["eva"],
-	"application/x-font-bdf": ["bdf"],
-	"application/x-font-ghostscript": ["gsf"],
-	"application/x-font-linux-psf": ["psf"],
-	"application/x-font-pcf": ["pcf"],
-	"application/x-font-snf": ["snf"],
-	"application/x-font-type1": [
-		"pfa",
-		"pfb",
-		"pfm",
-		"afm"
-	],
-	"application/x-freearc": ["arc"],
-	"application/x-futuresplash": ["spl"],
-	"application/x-gca-compressed": ["gca"],
-	"application/x-glulx": ["ulx"],
-	"application/x-gnumeric": ["gnumeric"],
-	"application/x-gramps-xml": ["gramps"],
-	"application/x-gtar": ["gtar"],
-	"application/x-hdf": ["hdf"],
-	"application/x-httpd-php": ["php"],
-	"application/x-install-instructions": ["install"],
-	"application/x-ipynb+json": ["ipynb"],
-	"application/x-iso9660-image": ["*iso"],
-	"application/x-iwork-keynote-sffkey": ["*key"],
-	"application/x-iwork-numbers-sffnumbers": ["*numbers"],
-	"application/x-iwork-pages-sffpages": ["*pages"],
-	"application/x-java-archive-diff": ["jardiff"],
-	"application/x-java-jnlp-file": ["jnlp"],
-	"application/x-keepass2": ["kdbx"],
-	"application/x-latex": ["latex"],
-	"application/x-lua-bytecode": ["luac"],
-	"application/x-lzh-compressed": ["lzh", "lha"],
-	"application/x-makeself": ["run"],
-	"application/x-mie": ["mie"],
-	"application/x-mobipocket-ebook": ["*prc", "mobi"],
-	"application/x-ms-application": ["application"],
-	"application/x-ms-shortcut": ["lnk"],
-	"application/x-ms-wmd": ["wmd"],
-	"application/x-ms-wmz": ["wmz"],
-	"application/x-ms-xbap": ["xbap"],
-	"application/x-msaccess": ["mdb"],
-	"application/x-msbinder": ["obd"],
-	"application/x-mscardfile": ["crd"],
-	"application/x-msclip": ["clp"],
-	"application/x-msdos-program": ["*exe"],
-	"application/x-msdownload": [
-		"*exe",
-		"*dll",
-		"com",
-		"bat",
-		"*msi"
-	],
-	"application/x-msmediaview": [
-		"mvb",
-		"m13",
-		"m14"
-	],
-	"application/x-msmetafile": [
-		"*wmf",
-		"*wmz",
-		"*emf",
-		"emz"
-	],
-	"application/x-msmoney": ["mny"],
-	"application/x-mspublisher": ["pub"],
-	"application/x-msschedule": ["scd"],
-	"application/x-msterminal": ["trm"],
-	"application/x-mswrite": ["wri"],
-	"application/x-netcdf": ["nc", "cdf"],
-	"application/x-ns-proxy-autoconfig": ["pac"],
-	"application/x-nzb": ["nzb"],
-	"application/x-perl": ["pl", "pm"],
-	"application/x-pilot": ["*prc", "*pdb"],
-	"application/x-pkcs12": ["p12", "pfx"],
-	"application/x-pkcs7-certificates": ["p7b", "spc"],
-	"application/x-pkcs7-certreqresp": ["p7r"],
-	"application/x-rar-compressed": ["*rar"],
-	"application/x-redhat-package-manager": ["rpm"],
-	"application/x-research-info-systems": ["ris"],
-	"application/x-sea": ["sea"],
-	"application/x-sh": ["sh"],
-	"application/x-shar": ["shar"],
-	"application/x-shockwave-flash": ["swf"],
-	"application/x-silverlight-app": ["xap"],
-	"application/x-sql": ["*sql"],
-	"application/x-stuffit": ["sit"],
-	"application/x-stuffitx": ["sitx"],
-	"application/x-subrip": ["srt"],
-	"application/x-sv4cpio": ["sv4cpio"],
-	"application/x-sv4crc": ["sv4crc"],
-	"application/x-t3vm-image": ["t3"],
-	"application/x-tads": ["gam"],
-	"application/x-tar": ["tar"],
-	"application/x-tcl": ["tcl", "tk"],
-	"application/x-tex": ["tex"],
-	"application/x-tex-tfm": ["tfm"],
-	"application/x-texinfo": ["texinfo", "texi"],
-	"application/x-tgif": ["*obj"],
-	"application/x-ustar": ["ustar"],
-	"application/x-virtualbox-hdd": ["hdd"],
-	"application/x-virtualbox-ova": ["ova"],
-	"application/x-virtualbox-ovf": ["ovf"],
-	"application/x-virtualbox-vbox": ["vbox"],
-	"application/x-virtualbox-vbox-extpack": ["vbox-extpack"],
-	"application/x-virtualbox-vdi": ["vdi"],
-	"application/x-virtualbox-vhd": ["vhd"],
-	"application/x-virtualbox-vmdk": ["vmdk"],
-	"application/x-wais-source": ["src"],
-	"application/x-web-app-manifest+json": ["webapp"],
-	"application/x-x509-ca-cert": [
-		"der",
-		"crt",
-		"pem"
-	],
-	"application/x-xfig": ["fig"],
-	"application/x-xliff+xml": ["*xlf"],
-	"application/x-xpinstall": ["xpi"],
-	"application/x-xz": ["xz"],
-	"application/x-zip-compressed": ["*zip"],
-	"application/x-zmachine": [
-		"z1",
-		"z2",
-		"z3",
-		"z4",
-		"z5",
-		"z6",
-		"z7",
-		"z8"
-	],
-	"audio/vnd.dece.audio": ["uva", "uvva"],
-	"audio/vnd.digital-winds": ["eol"],
-	"audio/vnd.dra": ["dra"],
-	"audio/vnd.dts": ["dts"],
-	"audio/vnd.dts.hd": ["dtshd"],
-	"audio/vnd.lucent.voice": ["lvp"],
-	"audio/vnd.ms-playready.media.pya": ["pya"],
-	"audio/vnd.nuera.ecelp4800": ["ecelp4800"],
-	"audio/vnd.nuera.ecelp7470": ["ecelp7470"],
-	"audio/vnd.nuera.ecelp9600": ["ecelp9600"],
-	"audio/vnd.rip": ["rip"],
-	"audio/x-aac": ["*aac"],
-	"audio/x-aiff": [
-		"aif",
-		"aiff",
-		"aifc"
-	],
-	"audio/x-caf": ["caf"],
-	"audio/x-flac": ["flac"],
-	"audio/x-m4a": ["*m4a"],
-	"audio/x-matroska": ["mka"],
-	"audio/x-mpegurl": ["m3u"],
-	"audio/x-ms-wax": ["wax"],
-	"audio/x-ms-wma": ["wma"],
-	"audio/x-pn-realaudio": ["ram", "ra"],
-	"audio/x-pn-realaudio-plugin": ["rmp"],
-	"audio/x-realaudio": ["*ra"],
-	"audio/x-wav": ["*wav"],
-	"chemical/x-cdx": ["cdx"],
-	"chemical/x-cif": ["cif"],
-	"chemical/x-cmdf": ["cmdf"],
-	"chemical/x-cml": ["cml"],
-	"chemical/x-csml": ["csml"],
-	"chemical/x-xyz": ["xyz"],
-	"image/prs.btif": ["btif", "btf"],
-	"image/prs.pti": ["pti"],
-	"image/vnd.adobe.photoshop": ["psd"],
-	"image/vnd.airzip.accelerator.azv": ["azv"],
-	"image/vnd.blockfact.facti": ["facti"],
-	"image/vnd.dece.graphic": [
-		"uvi",
-		"uvvi",
-		"uvg",
-		"uvvg"
-	],
-	"image/vnd.djvu": ["djvu", "djv"],
-	"image/vnd.dvb.subtitle": ["*sub"],
-	"image/vnd.dwg": ["dwg"],
-	"image/vnd.dxf": ["dxf"],
-	"image/vnd.fastbidsheet": ["fbs"],
-	"image/vnd.fpx": ["fpx"],
-	"image/vnd.fst": ["fst"],
-	"image/vnd.fujixerox.edmics-mmr": ["mmr"],
-	"image/vnd.fujixerox.edmics-rlc": ["rlc"],
-	"image/vnd.microsoft.icon": ["ico"],
-	"image/vnd.ms-dds": ["dds"],
-	"image/vnd.ms-modi": ["mdi"],
-	"image/vnd.ms-photo": ["wdp"],
-	"image/vnd.net-fpx": ["npx"],
-	"image/vnd.pco.b16": ["b16"],
-	"image/vnd.tencent.tap": ["tap"],
-	"image/vnd.valve.source.texture": ["vtf"],
-	"image/vnd.wap.wbmp": ["wbmp"],
-	"image/vnd.xiff": ["xif"],
-	"image/vnd.zbrush.pcx": ["pcx"],
-	"image/x-3ds": ["3ds"],
-	"image/x-adobe-dng": ["dng"],
-	"image/x-cmu-raster": ["ras"],
-	"image/x-cmx": ["cmx"],
-	"image/x-freehand": [
-		"fh",
-		"fhc",
-		"fh4",
-		"fh5",
-		"fh7"
-	],
-	"image/x-icon": ["*ico"],
-	"image/x-jng": ["jng"],
-	"image/x-mrsid-image": ["sid"],
-	"image/x-ms-bmp": ["*bmp"],
-	"image/x-pcx": ["*pcx"],
-	"image/x-pict": ["pic", "pct"],
-	"image/x-portable-anymap": ["pnm"],
-	"image/x-portable-bitmap": ["pbm"],
-	"image/x-portable-graymap": ["pgm"],
-	"image/x-portable-pixmap": ["ppm"],
-	"image/x-rgb": ["rgb"],
-	"image/x-tga": ["tga"],
-	"image/x-xbitmap": ["xbm"],
-	"image/x-xpixmap": ["xpm"],
-	"image/x-xwindowdump": ["xwd"],
-	"message/vnd.wfa.wsc": ["wsc"],
-	"model/vnd.bary": ["bary"],
-	"model/vnd.cld": ["cld"],
-	"model/vnd.collada+xml": ["dae"],
-	"model/vnd.dwf": ["dwf"],
-	"model/vnd.gdl": ["gdl"],
-	"model/vnd.gtw": ["gtw"],
-	"model/vnd.mts": ["*mts"],
-	"model/vnd.opengex": ["ogex"],
-	"model/vnd.parasolid.transmit.binary": ["x_b"],
-	"model/vnd.parasolid.transmit.text": ["x_t"],
-	"model/vnd.pytha.pyox": ["pyo", "pyox"],
-	"model/vnd.sap.vds": ["vds"],
-	"model/vnd.usda": ["usda"],
-	"model/vnd.usdz+zip": ["usdz"],
-	"model/vnd.valve.source.compiled-map": ["bsp"],
-	"model/vnd.vtu": ["vtu"],
-	"text/prs.lines.tag": ["dsc"],
-	"text/vnd.curl": ["curl"],
-	"text/vnd.curl.dcurl": ["dcurl"],
-	"text/vnd.curl.mcurl": ["mcurl"],
-	"text/vnd.curl.scurl": ["scurl"],
-	"text/vnd.dvb.subtitle": ["sub"],
-	"text/vnd.familysearch.gedcom": ["ged"],
-	"text/vnd.fly": ["fly"],
-	"text/vnd.fmi.flexstor": ["flx"],
-	"text/vnd.graphviz": ["gv"],
-	"text/vnd.in3d.3dml": ["3dml"],
-	"text/vnd.in3d.spot": ["spot"],
-	"text/vnd.sun.j2me.app-descriptor": ["jad"],
-	"text/vnd.wap.wml": ["wml"],
-	"text/vnd.wap.wmlscript": ["wmls"],
-	"text/x-asm": ["s", "asm"],
-	"text/x-c": [
-		"c",
-		"cc",
-		"cxx",
-		"cpp",
-		"h",
-		"hh",
-		"dic"
-	],
-	"text/x-component": ["htc"],
-	"text/x-fortran": [
-		"f",
-		"for",
-		"f77",
-		"f90"
-	],
-	"text/x-handlebars-template": ["hbs"],
-	"text/x-java-source": ["java"],
-	"text/x-lua": ["lua"],
-	"text/x-markdown": ["mkd"],
-	"text/x-nfo": ["nfo"],
-	"text/x-opml": ["opml"],
-	"text/x-org": ["*org"],
-	"text/x-pascal": ["p", "pas"],
-	"text/x-processing": ["pde"],
-	"text/x-sass": ["sass"],
-	"text/x-scss": ["scss"],
-	"text/x-setext": ["etx"],
-	"text/x-sfv": ["sfv"],
-	"text/x-suse-ymp": ["ymp"],
-	"text/x-uuencode": ["uu"],
-	"text/x-vcalendar": ["vcs"],
-	"text/x-vcard": ["vcf"],
-	"video/vnd.dece.hd": ["uvh", "uvvh"],
-	"video/vnd.dece.mobile": ["uvm", "uvvm"],
-	"video/vnd.dece.pd": ["uvp", "uvvp"],
-	"video/vnd.dece.sd": ["uvs", "uvvs"],
-	"video/vnd.dece.video": ["uvv", "uvvv"],
-	"video/vnd.dvb.file": ["dvb"],
-	"video/vnd.fvt": ["fvt"],
-	"video/vnd.mpegurl": ["mxu", "m4u"],
-	"video/vnd.ms-playready.media.pyv": ["pyv"],
-	"video/vnd.uvvu.mp4": ["uvu", "uvvu"],
-	"video/vnd.vivo": ["viv"],
-	"video/x-f4v": ["f4v"],
-	"video/x-fli": ["fli"],
-	"video/x-flv": ["flv"],
-	"video/x-m4v": ["m4v"],
-	"video/x-matroska": [
-		"mkv",
-		"mk3d",
-		"mks"
-	],
-	"video/x-mng": ["mng"],
-	"video/x-ms-asf": ["asf", "asx"],
-	"video/x-ms-vob": ["vob"],
-	"video/x-ms-wm": ["wm"],
-	"video/x-ms-wmv": ["wmv"],
-	"video/x-ms-wmx": ["wmx"],
-	"video/x-ms-wvx": ["wvx"],
-	"video/x-msvideo": ["avi"],
-	"video/x-sgi-movie": ["movie"],
-	"video/x-smv": ["smv"],
-	"x-conference/x-cooltalk": ["ice"]
-};
-Object.freeze(types$1);
-//#endregion
-//#region ../../node_modules/.pnpm/mime@4.1.0/node_modules/mime/dist/types/standard.js
-const types = {
-	"application/andrew-inset": ["ez"],
-	"application/appinstaller": ["appinstaller"],
-	"application/applixware": ["aw"],
-	"application/appx": ["appx"],
-	"application/appxbundle": ["appxbundle"],
-	"application/atom+xml": ["atom"],
-	"application/atomcat+xml": ["atomcat"],
-	"application/atomdeleted+xml": ["atomdeleted"],
-	"application/atomsvc+xml": ["atomsvc"],
-	"application/atsc-dwd+xml": ["dwd"],
-	"application/atsc-held+xml": ["held"],
-	"application/atsc-rsat+xml": ["rsat"],
-	"application/automationml-aml+xml": ["aml"],
-	"application/automationml-amlx+zip": ["amlx"],
-	"application/bdoc": ["bdoc"],
-	"application/calendar+xml": ["xcs"],
-	"application/ccxml+xml": ["ccxml"],
-	"application/cdfx+xml": ["cdfx"],
-	"application/cdmi-capability": ["cdmia"],
-	"application/cdmi-container": ["cdmic"],
-	"application/cdmi-domain": ["cdmid"],
-	"application/cdmi-object": ["cdmio"],
-	"application/cdmi-queue": ["cdmiq"],
-	"application/cpl+xml": ["cpl"],
-	"application/cu-seeme": ["cu"],
-	"application/cwl": ["cwl"],
-	"application/dash+xml": ["mpd"],
-	"application/dash-patch+xml": ["mpp"],
-	"application/davmount+xml": ["davmount"],
-	"application/dicom": ["dcm"],
-	"application/docbook+xml": ["dbk"],
-	"application/dssc+der": ["dssc"],
-	"application/dssc+xml": ["xdssc"],
-	"application/ecmascript": ["ecma"],
-	"application/emma+xml": ["emma"],
-	"application/emotionml+xml": ["emotionml"],
-	"application/epub+zip": ["epub"],
-	"application/exi": ["exi"],
-	"application/express": ["exp"],
-	"application/fdf": ["fdf"],
-	"application/fdt+xml": ["fdt"],
-	"application/font-tdpfr": ["pfr"],
-	"application/geo+json": ["geojson"],
-	"application/gml+xml": ["gml"],
-	"application/gpx+xml": ["gpx"],
-	"application/gxf": ["gxf"],
-	"application/gzip": ["gz"],
-	"application/hjson": ["hjson"],
-	"application/hyperstudio": ["stk"],
-	"application/inkml+xml": ["ink", "inkml"],
-	"application/ipfix": ["ipfix"],
-	"application/its+xml": ["its"],
-	"application/java-archive": [
-		"jar",
-		"war",
-		"ear"
-	],
-	"application/java-serialized-object": ["ser"],
-	"application/java-vm": ["class"],
-	"application/javascript": ["*js"],
-	"application/json": ["json", "map"],
-	"application/json5": ["json5"],
-	"application/jsonml+json": ["jsonml"],
-	"application/ld+json": ["jsonld"],
-	"application/lgr+xml": ["lgr"],
-	"application/lost+xml": ["lostxml"],
-	"application/mac-binhex40": ["hqx"],
-	"application/mac-compactpro": ["cpt"],
-	"application/mads+xml": ["mads"],
-	"application/manifest+json": ["webmanifest"],
-	"application/marc": ["mrc"],
-	"application/marcxml+xml": ["mrcx"],
-	"application/mathematica": [
-		"ma",
-		"nb",
-		"mb"
-	],
-	"application/mathml+xml": ["mathml"],
-	"application/mbox": ["mbox"],
-	"application/media-policy-dataset+xml": ["mpf"],
-	"application/mediaservercontrol+xml": ["mscml"],
-	"application/metalink+xml": ["metalink"],
-	"application/metalink4+xml": ["meta4"],
-	"application/mets+xml": ["mets"],
-	"application/mmt-aei+xml": ["maei"],
-	"application/mmt-usd+xml": ["musd"],
-	"application/mods+xml": ["mods"],
-	"application/mp21": ["m21", "mp21"],
-	"application/mp4": [
-		"*mp4",
-		"*mpg4",
-		"mp4s",
-		"m4p"
-	],
-	"application/msix": ["msix"],
-	"application/msixbundle": ["msixbundle"],
-	"application/msword": ["doc", "dot"],
-	"application/mxf": ["mxf"],
-	"application/n-quads": ["nq"],
-	"application/n-triples": ["nt"],
-	"application/node": ["cjs"],
-	"application/octet-stream": [
-		"bin",
-		"dms",
-		"lrf",
-		"mar",
-		"so",
-		"dist",
-		"distz",
-		"pkg",
-		"bpk",
-		"dump",
-		"elc",
-		"deploy",
-		"exe",
-		"dll",
-		"deb",
-		"dmg",
-		"iso",
-		"img",
-		"msi",
-		"msp",
-		"msm",
-		"buffer"
-	],
-	"application/oda": ["oda"],
-	"application/oebps-package+xml": ["opf"],
-	"application/ogg": ["ogx"],
-	"application/omdoc+xml": ["omdoc"],
-	"application/onenote": [
-		"onetoc",
-		"onetoc2",
-		"onetmp",
-		"onepkg",
-		"one",
-		"onea"
-	],
-	"application/oxps": ["oxps"],
-	"application/p2p-overlay+xml": ["relo"],
-	"application/patch-ops-error+xml": ["xer"],
-	"application/pdf": ["pdf"],
-	"application/pgp-encrypted": ["pgp"],
-	"application/pgp-keys": ["asc"],
-	"application/pgp-signature": ["sig", "*asc"],
-	"application/pics-rules": ["prf"],
-	"application/pkcs10": ["p10"],
-	"application/pkcs7-mime": ["p7m", "p7c"],
-	"application/pkcs7-signature": ["p7s"],
-	"application/pkcs8": ["p8"],
-	"application/pkix-attr-cert": ["ac"],
-	"application/pkix-cert": ["cer"],
-	"application/pkix-crl": ["crl"],
-	"application/pkix-pkipath": ["pkipath"],
-	"application/pkixcmp": ["pki"],
-	"application/pls+xml": ["pls"],
-	"application/postscript": [
-		"ai",
-		"eps",
-		"ps"
-	],
-	"application/provenance+xml": ["provx"],
-	"application/pskc+xml": ["pskcxml"],
-	"application/raml+yaml": ["raml"],
-	"application/rdf+xml": ["rdf", "owl"],
-	"application/reginfo+xml": ["rif"],
-	"application/relax-ng-compact-syntax": ["rnc"],
-	"application/resource-lists+xml": ["rl"],
-	"application/resource-lists-diff+xml": ["rld"],
-	"application/rls-services+xml": ["rs"],
-	"application/route-apd+xml": ["rapd"],
-	"application/route-s-tsid+xml": ["sls"],
-	"application/route-usd+xml": ["rusd"],
-	"application/rpki-ghostbusters": ["gbr"],
-	"application/rpki-manifest": ["mft"],
-	"application/rpki-roa": ["roa"],
-	"application/rsd+xml": ["rsd"],
-	"application/rss+xml": ["rss"],
-	"application/rtf": ["rtf"],
-	"application/sbml+xml": ["sbml"],
-	"application/scvp-cv-request": ["scq"],
-	"application/scvp-cv-response": ["scs"],
-	"application/scvp-vp-request": ["spq"],
-	"application/scvp-vp-response": ["spp"],
-	"application/sdp": ["sdp"],
-	"application/senml+xml": ["senmlx"],
-	"application/sensml+xml": ["sensmlx"],
-	"application/set-payment-initiation": ["setpay"],
-	"application/set-registration-initiation": ["setreg"],
-	"application/shf+xml": ["shf"],
-	"application/sieve": ["siv", "sieve"],
-	"application/smil+xml": ["smi", "smil"],
-	"application/sparql-query": ["rq"],
-	"application/sparql-results+xml": ["srx"],
-	"application/sql": ["sql"],
-	"application/srgs": ["gram"],
-	"application/srgs+xml": ["grxml"],
-	"application/sru+xml": ["sru"],
-	"application/ssdl+xml": ["ssdl"],
-	"application/ssml+xml": ["ssml"],
-	"application/swid+xml": ["swidtag"],
-	"application/tei+xml": ["tei", "teicorpus"],
-	"application/thraud+xml": ["tfi"],
-	"application/timestamped-data": ["tsd"],
-	"application/toml": ["toml"],
-	"application/trig": ["trig"],
-	"application/ttml+xml": ["ttml"],
-	"application/ubjson": ["ubj"],
-	"application/urc-ressheet+xml": ["rsheet"],
-	"application/urc-targetdesc+xml": ["td"],
-	"application/voicexml+xml": ["vxml"],
-	"application/wasm": ["wasm"],
-	"application/watcherinfo+xml": ["wif"],
-	"application/widget": ["wgt"],
-	"application/winhlp": ["hlp"],
-	"application/wsdl+xml": ["wsdl"],
-	"application/wspolicy+xml": ["wspolicy"],
-	"application/xaml+xml": ["xaml"],
-	"application/xcap-att+xml": ["xav"],
-	"application/xcap-caps+xml": ["xca"],
-	"application/xcap-diff+xml": ["xdf"],
-	"application/xcap-el+xml": ["xel"],
-	"application/xcap-ns+xml": ["xns"],
-	"application/xenc+xml": ["xenc"],
-	"application/xfdf": ["xfdf"],
-	"application/xhtml+xml": ["xhtml", "xht"],
-	"application/xliff+xml": ["xlf"],
-	"application/xml": [
-		"xml",
-		"xsl",
-		"xsd",
-		"rng"
-	],
-	"application/xml-dtd": ["dtd"],
-	"application/xop+xml": ["xop"],
-	"application/xproc+xml": ["xpl"],
-	"application/xslt+xml": ["*xsl", "xslt"],
-	"application/xspf+xml": ["xspf"],
-	"application/xv+xml": [
-		"mxml",
-		"xhvml",
-		"xvml",
-		"xvm"
-	],
-	"application/yang": ["yang"],
-	"application/yin+xml": ["yin"],
-	"application/zip": ["zip"],
-	"application/zip+dotlottie": ["lottie"],
-	"audio/3gpp": ["*3gpp"],
-	"audio/aac": ["adts", "aac"],
-	"audio/adpcm": ["adp"],
-	"audio/amr": ["amr"],
-	"audio/basic": ["au", "snd"],
-	"audio/midi": [
-		"mid",
-		"midi",
-		"kar",
-		"rmi"
-	],
-	"audio/mobile-xmf": ["mxmf"],
-	"audio/mp3": ["*mp3"],
-	"audio/mp4": [
-		"m4a",
-		"mp4a",
-		"m4b"
-	],
-	"audio/mpeg": [
-		"mpga",
-		"mp2",
-		"mp2a",
-		"mp3",
-		"m2a",
-		"m3a"
-	],
-	"audio/ogg": [
-		"oga",
-		"ogg",
-		"spx",
-		"opus"
-	],
-	"audio/s3m": ["s3m"],
-	"audio/silk": ["sil"],
-	"audio/wav": ["wav"],
-	"audio/wave": ["*wav"],
-	"audio/webm": ["weba"],
-	"audio/xm": ["xm"],
-	"font/collection": ["ttc"],
-	"font/otf": ["otf"],
-	"font/ttf": ["ttf"],
-	"font/woff": ["woff"],
-	"font/woff2": ["woff2"],
-	"image/aces": ["exr"],
-	"image/apng": ["apng"],
-	"image/avci": ["avci"],
-	"image/avcs": ["avcs"],
-	"image/avif": ["avif"],
-	"image/bmp": ["bmp", "dib"],
-	"image/cgm": ["cgm"],
-	"image/dicom-rle": ["drle"],
-	"image/dpx": ["dpx"],
-	"image/emf": ["emf"],
-	"image/fits": ["fits"],
-	"image/g3fax": ["g3"],
-	"image/gif": ["gif"],
-	"image/heic": ["heic"],
-	"image/heic-sequence": ["heics"],
-	"image/heif": ["heif"],
-	"image/heif-sequence": ["heifs"],
-	"image/hej2k": ["hej2"],
-	"image/ief": ["ief"],
-	"image/jaii": ["jaii"],
-	"image/jais": ["jais"],
-	"image/jls": ["jls"],
-	"image/jp2": ["jp2", "jpg2"],
-	"image/jpeg": [
-		"jpg",
-		"jpeg",
-		"jpe"
-	],
-	"image/jph": ["jph"],
-	"image/jphc": ["jhc"],
-	"image/jpm": ["jpm", "jpgm"],
-	"image/jpx": ["jpx", "jpf"],
-	"image/jxl": ["jxl"],
-	"image/jxr": ["jxr"],
-	"image/jxra": ["jxra"],
-	"image/jxrs": ["jxrs"],
-	"image/jxs": ["jxs"],
-	"image/jxsc": ["jxsc"],
-	"image/jxsi": ["jxsi"],
-	"image/jxss": ["jxss"],
-	"image/ktx": ["ktx"],
-	"image/ktx2": ["ktx2"],
-	"image/pjpeg": ["jfif"],
-	"image/png": ["png"],
-	"image/sgi": ["sgi"],
-	"image/svg+xml": ["svg", "svgz"],
-	"image/t38": ["t38"],
-	"image/tiff": ["tif", "tiff"],
-	"image/tiff-fx": ["tfx"],
-	"image/webp": ["webp"],
-	"image/wmf": ["wmf"],
-	"message/disposition-notification": ["disposition-notification"],
-	"message/global": ["u8msg"],
-	"message/global-delivery-status": ["u8dsn"],
-	"message/global-disposition-notification": ["u8mdn"],
-	"message/global-headers": ["u8hdr"],
-	"message/rfc822": [
-		"eml",
-		"mime",
-		"mht",
-		"mhtml"
-	],
-	"model/3mf": ["3mf"],
-	"model/gltf+json": ["gltf"],
-	"model/gltf-binary": ["glb"],
-	"model/iges": ["igs", "iges"],
-	"model/jt": ["jt"],
-	"model/mesh": [
-		"msh",
-		"mesh",
-		"silo"
-	],
-	"model/mtl": ["mtl"],
-	"model/obj": ["obj"],
-	"model/prc": ["prc"],
-	"model/step": [
-		"step",
-		"stp",
-		"stpnc",
-		"p21",
-		"210"
-	],
-	"model/step+xml": ["stpx"],
-	"model/step+zip": ["stpz"],
-	"model/step-xml+zip": ["stpxz"],
-	"model/stl": ["stl"],
-	"model/u3d": ["u3d"],
-	"model/vrml": ["wrl", "vrml"],
-	"model/x3d+binary": ["*x3db", "x3dbz"],
-	"model/x3d+fastinfoset": ["x3db"],
-	"model/x3d+vrml": ["*x3dv", "x3dvz"],
-	"model/x3d+xml": ["x3d", "x3dz"],
-	"model/x3d-vrml": ["x3dv"],
-	"text/cache-manifest": ["appcache", "manifest"],
-	"text/calendar": ["ics", "ifb"],
-	"text/coffeescript": ["coffee", "litcoffee"],
-	"text/css": ["css"],
-	"text/csv": ["csv"],
-	"text/html": [
-		"html",
-		"htm",
-		"shtml"
-	],
-	"text/jade": ["jade"],
-	"text/javascript": ["js", "mjs"],
-	"text/jsx": ["jsx"],
-	"text/less": ["less"],
-	"text/markdown": ["md", "markdown"],
-	"text/mathml": ["mml"],
-	"text/mdx": ["mdx"],
-	"text/n3": ["n3"],
-	"text/plain": [
-		"txt",
-		"text",
-		"conf",
-		"def",
-		"list",
-		"log",
-		"in",
-		"ini"
-	],
-	"text/richtext": ["rtx"],
-	"text/rtf": ["*rtf"],
-	"text/sgml": ["sgml", "sgm"],
-	"text/shex": ["shex"],
-	"text/slim": ["slim", "slm"],
-	"text/spdx": ["spdx"],
-	"text/stylus": ["stylus", "styl"],
-	"text/tab-separated-values": ["tsv"],
-	"text/troff": [
-		"t",
-		"tr",
-		"roff",
-		"man",
-		"me",
-		"ms"
-	],
-	"text/turtle": ["ttl"],
-	"text/uri-list": [
-		"uri",
-		"uris",
-		"urls"
-	],
-	"text/vcard": ["vcard"],
-	"text/vtt": ["vtt"],
-	"text/wgsl": ["wgsl"],
-	"text/xml": ["*xml"],
-	"text/yaml": ["yaml", "yml"],
-	"video/3gpp": ["3gp", "3gpp"],
-	"video/3gpp2": ["3g2"],
-	"video/h261": ["h261"],
-	"video/h263": ["h263"],
-	"video/h264": ["h264"],
-	"video/iso.segment": ["m4s"],
-	"video/jpeg": ["jpgv"],
-	"video/jpm": ["*jpm", "*jpgm"],
-	"video/mj2": ["mj2", "mjp2"],
-	"video/mp2t": [
-		"ts",
-		"m2t",
-		"m2ts",
-		"mts"
-	],
-	"video/mp4": [
-		"mp4",
-		"mp4v",
-		"mpg4"
-	],
-	"video/mpeg": [
-		"mpeg",
-		"mpg",
-		"mpe",
-		"m1v",
-		"m2v"
-	],
-	"video/ogg": ["ogv"],
-	"video/quicktime": ["qt", "mov"],
-	"video/webm": ["webm"]
-};
-Object.freeze(types);
+import { getSignedUrl } from "@aws-sdk/cloudfront-signer";
+import { DeleteObjectCommand, DeleteObjectsCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, S3Client } from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+//#region src/cloudFrontInvalidation.ts
+const DEFAULT_POLL_INTERVAL_MS = 2e3;
+const DEFAULT_TIMEOUT_MS = 300 * 1e3;
+const sleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+const invalidateCloudFront = async (client, distributionId, paths, options) => {
+	if (paths.length === 0) return;
+	const response = await client.send(new CreateInvalidationCommand({
+		DistributionId: distributionId,
+		InvalidationBatch: {
+			CallerReference: `invalidation-${Date.now()}`,
+			Paths: {
+				Quantity: paths.length,
+				Items: paths.map((path) => encodeURI(path))
+			}
+		}
+	}));
+	if (!options.shouldWait || response.Invalidation?.Status === "Completed") return;
+	const invalidationId = response.Invalidation?.Id;
+	if (!invalidationId) throw new Error("CloudFront invalidation response is missing Invalidation.Id");
+	const deadline = Date.now() + DEFAULT_TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		await sleep(DEFAULT_POLL_INTERVAL_MS);
+		if ((await client.send(new GetInvalidationCommand({
+			DistributionId: distributionId,
+			Id: invalidationId
+		}))).Invalidation?.Status === "Completed") return;
+	}
+	throw new Error(`Timed out waiting for CloudFront invalidation ${invalidationId}.`);
+};
 //#endregion
-//#region ../../node_modules/.pnpm/mime@4.1.0/node_modules/mime/dist/src/Mime.js
-var __classPrivateFieldGet = function(receiver, state, kind, f) {
-	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Mime_extensionToType, _Mime_typeToExtension, _Mime_typeToExtensions;
-var Mime = class {
-	constructor(...args) {
-		_Mime_extensionToType.set(this, /* @__PURE__ */ new Map());
-		_Mime_typeToExtension.set(this, /* @__PURE__ */ new Map());
-		_Mime_typeToExtensions.set(this, /* @__PURE__ */ new Map());
-		for (const arg of args) this.define(arg);
+//#region src/dynamoDB.ts
+const DYNAMODB_MAX_METADATA_ITEM_BYTES = 8 * 1024;
+const DYNAMODB_MAX_CATALOG_ITEM_BYTES = 400 * 1024;
+var DynamoDBMetadataItemSizeError = class extends Error {
+	name = "DynamoDBMetadataItemSizeError";
+	constructor(byteLength) {
+		super(`DynamoDB metadata item is ${byteLength} bytes; maximum is ${DYNAMODB_MAX_METADATA_ITEM_BYTES}`);
+		this.byteLength = byteLength;
+	}
+};
+const boundedDynamoDBMetadataItem = (item) => {
+	const byteLength = new TextEncoder().encode(JSON.stringify(item)).byteLength;
+	if (byteLength > 8192) throw new DynamoDBMetadataItemSizeError(byteLength);
+	return item;
+};
+var DynamoDBCatalogItemSizeError = class extends Error {
+	name = "DynamoDBCatalogItemSizeError";
+	constructor(byteLength) {
+		super(`DynamoDB catalog item is ${byteLength} bytes; maximum is ${DYNAMODB_MAX_CATALOG_ITEM_BYTES}`);
+		this.byteLength = byteLength;
+	}
+};
+const boundedDynamoDBCatalogItem = (item) => {
+	const byteLength = new TextEncoder().encode(JSON.stringify(item)).byteLength;
+	if (byteLength > 409600) throw new DynamoDBCatalogItemSizeError(byteLength);
+	return item;
+};
+const DYNAMODB_CHANNEL_PARTITION = "channels";
+const DYNAMODB_CHANNEL_NAME_PARTITION = "_hot-updater#channel-names";
+var DynamoDBStoredItemError = class extends Error {
+	name = "DynamoDBStoredItemError";
+	constructor() {
+		super("DynamoDB contains an invalid Hot Updater row");
+	}
+};
+const field = (value, name) => Reflect.get(value, name);
+const isNullableString = (value) => value === null || typeof value === "string";
+const isByteSize = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+const withLegacyArchiveByteSize = (value) => typeof value === "object" && value !== null && field(value, "archive_byte_size") === void 0 ? {
+	...value,
+	archive_byte_size: 0
+} : value;
+const isBundleRow = (value) => typeof value === "object" && value !== null && typeof field(value, "id") === "string" && (field(value, "platform") === "ios" || field(value, "platform") === "android") && typeof field(value, "file_hash") === "string" && isNullableString(field(value, "git_commit_hash")) && typeof field(value, "storage_uri") === "string" && isByteSize(field(value, "archive_byte_size")) && isDatabaseMetadataObject(field(value, "metadata")) && isNullableString(field(value, "manifest_storage_uri")) && isNullableString(field(value, "manifest_file_hash")) && isNullableString(field(value, "asset_base_storage_uri"));
+const isPatchRow = (value) => typeof value === "object" && value !== null && typeof field(value, "id") === "string" && typeof field(value, "bundle_id") === "string" && typeof field(value, "base_bundle_id") === "string" && typeof field(value, "base_file_hash") === "string" && typeof field(value, "patch_file_hash") === "string" && typeof field(value, "patch_storage_uri") === "string" && isByteSize(field(value, "byte_size")) && typeof field(value, "order_index") === "number";
+const isChannelRow = (value) => typeof value === "object" && value !== null && typeof field(value, "id") === "string" && typeof field(value, "name") === "string";
+const isReleaseRow = (value) => typeof value === "object" && value !== null && typeof field(value, "id") === "string" && typeof field(value, "revision") === "number" && typeof field(value, "scope_key") === "string" && typeof field(value, "channel_id") === "string" && (field(value, "platform") === "ios" || field(value, "platform") === "android") && (field(value, "kind") === "BUNDLE" || field(value, "kind") === "EMBEDDED") && isNullableString(field(value, "bundle_id")) && (field(value, "strategy") === "APP_VERSION" || field(value, "strategy") === "FINGERPRINT") && isNullableString(field(value, "target_app_version")) && isNullableString(field(value, "fingerprint_hash")) && typeof field(value, "enabled") === "boolean" && typeof field(value, "should_force_update") === "boolean" && isNullableString(field(value, "message")) && typeof field(value, "rollout_cohort_count") === "number" && Array.isArray(field(value, "target_cohorts")) && field(value, "target_cohorts").every((cohort) => typeof cohort === "string") && (field(value, "operation") === "DEPLOY" || field(value, "operation") === "PROMOTE" || field(value, "operation") === "ROLLBACK") && isNullableString(field(value, "source_release_id")) && typeof field(value, "created_at_ms") === "number" && typeof field(value, "updated_at_ms") === "number";
+const isReleaseCatalogRow = (value) => typeof value === "object" && value !== null && typeof field(value, "scope_key") === "string" && typeof field(value, "catalog_id") === "string" && (field(value, "strategy") === "APP_VERSION" || field(value, "strategy") === "FINGERPRINT") && typeof field(value, "channel_id") === "string" && typeof field(value, "channel_key") === "string" && (field(value, "platform") === "ios" || field(value, "platform") === "android") && isNullableString(field(value, "fingerprint_hash")) && typeof field(value, "generation") === "number" && typeof field(value, "payload") === "string" && typeof field(value, "catalog_hash") === "string" && typeof field(value, "byte_size") === "number" && typeof field(value, "is_tombstone") === "boolean" && typeof field(value, "updated_at_ms") === "number";
+const parseDynamoDBItem = (value) => {
+	const pk = value.pk;
+	const sk = value.sk;
+	const version = value.version;
+	const relationCount = value.relation_count;
+	const ownedPatchCount = value.owned_patch_count;
+	const gsi1pk = value.gsi1pk;
+	const gsi1sk = value.gsi1sk;
+	const row = pk === "bundles" ? withLegacyArchiveByteSize(value.row) : value.row;
+	if (typeof sk !== "string" || typeof version !== "number") throw new DynamoDBStoredItemError();
+	if (pk === "channels" && typeof value.reference_count === "number" && isChannelRow(row)) return {
+		pk,
+		sk,
+		version,
+		reference_count: value.reference_count,
+		row
+	};
+	if (typeof pk === "string" && pk.startsWith("release-scope#") && isReleaseRow(row)) return {
+		pk,
+		sk,
+		version,
+		row
+	};
+	if (pk === "release_catalogs" && isReleaseCatalogRow(row)) return {
+		pk,
+		sk,
+		version,
+		row
+	};
+	if (typeof gsi1pk !== "string" || typeof gsi1sk !== "string") throw new DynamoDBStoredItemError();
+	if (pk === "bundles" && isBundleRow(row)) {
+		if (typeof relationCount !== "number" || typeof ownedPatchCount !== "number") throw new DynamoDBStoredItemError();
+		return {
+			pk,
+			sk,
+			version,
+			relation_count: relationCount,
+			owned_patch_count: ownedPatchCount,
+			gsi1pk,
+			gsi1sk,
+			row
+		};
+	}
+	if (pk === "bundle_patches" && isPatchRow(row)) return {
+		pk,
+		sk,
+		version,
+		gsi1pk,
+		gsi1sk,
+		row
+	};
+	throw new DynamoDBStoredItemError();
+};
+const bundlePlatformPartition = (row) => `bundle#${row.platform}`;
+const patchOwnerPartition = (bundleId) => `patch-owner#${bundleId}`;
+const patchOrderKey = (row) => `${row.order_index.toString().padStart(10, "0")}#${row.id}`;
+const toDynamoDBBundleItem = (row, version = 1, relationCount = 0, ownedPatchCount = 0) => ({
+	pk: "bundles",
+	sk: row.id,
+	version,
+	relation_count: relationCount,
+	owned_patch_count: ownedPatchCount,
+	gsi1pk: bundlePlatformPartition(row),
+	gsi1sk: row.id,
+	row
+});
+const toDynamoDBPatchItem = (row, version = 1) => {
+	const orderKey = patchOrderKey(row);
+	return {
+		pk: "bundle_patches",
+		sk: row.id,
+		version,
+		gsi1pk: patchOwnerPartition(row.bundle_id),
+		gsi1sk: orderKey,
+		row
+	};
+};
+const toDynamoDBChannelItem = (row, version = 1, referenceCount = 0) => ({
+	pk: DYNAMODB_CHANNEL_PARTITION,
+	sk: row.id,
+	version,
+	reference_count: referenceCount,
+	row
+});
+const releaseScopePartition = (scopeKey) => `release-scope#${scopeKey}`;
+const toDynamoDBReleaseItem = (row, version = 1) => ({
+	pk: releaseScopePartition(row.scope_key),
+	sk: row.id,
+	version,
+	row
+});
+const toDynamoDBReleaseCatalogItem = (row, version = 1) => ({
+	pk: "release_catalogs",
+	sk: row.scope_key,
+	version,
+	row
+});
+const itemKey = (model, id) => ({
+	pk: model,
+	sk: id
+});
+const exactDynamoDBId = (where) => {
+	if (where?.length !== 1) return void 0;
+	const condition = where[0];
+	if (Reflect.get(condition, "field") !== "id" || (Reflect.get(condition, "operator") ?? "eq") !== "eq" || Reflect.get(condition, "mode") === "insensitive") return;
+	const value = Reflect.get(condition, "value");
+	return typeof value === "string" ? value : void 0;
+};
+const exactDynamoDBPatchOwner = (where) => {
+	const owners = exactDynamoDBPatchOwners(where);
+	return owners?.length === 1 ? owners[0] : void 0;
+};
+const exactDynamoDBPatchOwners = (where) => {
+	if (!where || where.some((condition) => Reflect.get(condition, "connector") === "OR")) return;
+	const ownerConditions = where.filter((condition) => Reflect.get(condition, "field") === "bundle_id");
+	if (ownerConditions.length !== 1) return void 0;
+	const condition = ownerConditions[0];
+	if (Reflect.get(condition, "mode") === "insensitive") return;
+	const operator = Reflect.get(condition, "operator") ?? "eq";
+	const value = Reflect.get(condition, "value");
+	if (operator === "eq") return typeof value === "string" ? [value] : void 0;
+	if (operator === "in" && Array.isArray(value) && value.every((id) => typeof id === "string")) return value;
+};
+const exactDynamoDBBundleIds = (where) => {
+	if (!where || where.some((condition) => Reflect.get(condition, "connector") === "OR")) return;
+	for (const condition of where) {
+		if (Reflect.get(condition, "field") !== "id" || Reflect.get(condition, "mode") === "insensitive") continue;
+		const operator = Reflect.get(condition, "operator") ?? "eq";
+		const value = Reflect.get(condition, "value");
+		if (operator === "eq" && typeof value === "string") return [value];
+		if (operator === "in" && Array.isArray(value) && value.every((id) => typeof id === "string")) return value;
+	}
+};
+const dynamoDBBundlePageStart = (where, direction) => {
+	if ((where ?? []).some((condition) => Reflect.get(condition, "connector") === "OR")) return;
+	let result;
+	for (const condition of where ?? []) {
+		if (Reflect.get(condition, "field") !== "id") continue;
+		const operator = Reflect.get(condition, "operator") ?? "eq";
+		const value = Reflect.get(condition, "value");
+		if (!(direction === "asc" ? operator === "gt" || operator === "gte" : operator === "lt" || operator === "lte") || typeof value !== "string") continue;
+		const inclusive = operator === "gte" || operator === "lte";
+		if (result === void 0 || (direction === "asc" ? value > result.id : value < result.id) || value === result.id && !inclusive) result = {
+			id: value,
+			inclusive
+		};
+	}
+	return result;
+};
+const parseStoredItem = (item) => parseDynamoDBItem(item.pk === "release_catalogs" ? boundedDynamoDBCatalogItem(item) : boundedDynamoDBMetadataItem(item));
+const queryItems = async (store, input) => {
+	let exclusiveStartKey;
+	const items = [];
+	do {
+		const sortCondition = input.minimumSortKey ? " AND #sortKey >= :minimumSortKey" : "";
+		const page = await store.client.send(new QueryCommand({
+			TableName: store.tableName,
+			...input.indexName ? { IndexName: input.indexName } : {},
+			...input.consistentRead ? { ConsistentRead: true } : {},
+			ExclusiveStartKey: exclusiveStartKey,
+			KeyConditionExpression: `#partitionKey = :partition${sortCondition}`,
+			ExpressionAttributeNames: {
+				"#partitionKey": input.indexName ? "gsi1pk" : "pk",
+				...input.minimumSortKey ? { "#sortKey": input.indexName ? "gsi1sk" : "sk" } : {}
+			},
+			ExpressionAttributeValues: {
+				":partition": input.partition,
+				...input.minimumSortKey ? { ":minimumSortKey": input.minimumSortKey } : {}
+			}
+		}));
+		const pageItems = (page.Items ?? []).map(parseStoredItem);
+		items.push(...pageItems);
+		exclusiveStartKey = page.LastEvaluatedKey;
+	} while (exclusiveStartKey !== void 0);
+	return items;
+};
+const queryBundleItemsPage = async (store, input) => {
+	if (input.limit === 0) return [];
+	let exclusiveStartKey;
+	const items = [];
+	do {
+		const startOperator = input.start?.inclusive ? input.direction === "asc" ? ">=" : "<=" : input.direction === "asc" ? ">" : "<";
+		const page = await store.client.send(new QueryCommand({
+			TableName: store.tableName,
+			ExclusiveStartKey: exclusiveStartKey,
+			KeyConditionExpression: input.start ? `#pk = :pk AND #sk ${startOperator} :start` : "#pk = :pk",
+			ExpressionAttributeNames: {
+				"#pk": "pk",
+				...input.start ? { "#sk": "sk" } : {}
+			},
+			ExpressionAttributeValues: {
+				":pk": "bundles",
+				...input.start ? { ":start": input.start.id } : {}
+			},
+			Limit: Math.max(input.limit - items.length, 100),
+			ScanIndexForward: input.direction === "asc"
+		}));
+		for (const item of (page.Items ?? []).map(parseStoredItem)) {
+			if (item.pk === "bundles" && input.matches(item.row)) items.push(item);
+			if (items.length === input.limit) return items;
+		}
+		exclusiveStartKey = page.LastEvaluatedKey;
+	} while (exclusiveStartKey !== void 0);
+	return items;
+};
+const loadModelItems = (store, model) => queryItems(store, {
+	partition: model,
+	consistentRead: true
+});
+const loadModelItem = async (store, model, id) => {
+	const { Item } = await store.client.send(new GetCommand({
+		TableName: store.tableName,
+		Key: itemKey(model, id),
+		ConsistentRead: true
+	}));
+	return Item === void 0 ? void 0 : parseStoredItem(Item);
+};
+const loadBundleItem = async (store, id) => {
+	const item = await loadModelItem(store, "bundles", id);
+	return item?.pk === "bundles" ? item : void 0;
+};
+const loadPatchItem = async (store, id) => {
+	const item = await loadModelItem(store, "bundle_patches", id);
+	return item?.pk === "bundle_patches" ? item : void 0;
+};
+const loadChannelItem = async (store, id) => {
+	const item = await loadModelItem(store, DYNAMODB_CHANNEL_PARTITION, id);
+	return item?.pk === "channels" ? item : void 0;
+};
+const loadBundleItems = async (store) => {
+	return (await loadModelItems(store, "bundles")).filter((item) => item.pk === "bundles");
+};
+const loadPatchItems = async (store) => {
+	return (await loadModelItems(store, "bundle_patches")).filter((item) => item.pk === "bundle_patches");
+};
+const loadChannelItems = async (store) => {
+	return (await loadModelItems(store, DYNAMODB_CHANNEL_PARTITION)).filter((item) => item.pk === DYNAMODB_CHANNEL_PARTITION);
+};
+const DYNAMODB_RELEASE_ID_PARTITION = "_hot-updater#release-scope-by-id";
+const releaseLocatorItem = (row) => ({
+	pk: DYNAMODB_RELEASE_ID_PARTITION,
+	sk: row.id,
+	scope_key: row.scope_key
+});
+const loadReleaseItem = async (store, id) => {
+	const locator = await store.client.send(new GetCommand({
+		TableName: store.tableName,
+		Key: {
+			pk: DYNAMODB_RELEASE_ID_PARTITION,
+			sk: id
+		},
+		ConsistentRead: true
+	}));
+	if (locator.Item === void 0) return void 0;
+	const scopeKey = locator.Item.scope_key;
+	if (typeof scopeKey !== "string") throw new DynamoDBStoredItemError();
+	const result = await store.client.send(new GetCommand({
+		TableName: store.tableName,
+		Key: {
+			pk: releaseScopePartition(scopeKey),
+			sk: id
+		},
+		ConsistentRead: true
+	}));
+	if (result.Item === void 0) throw new DynamoDBStoredItemError();
+	const item = parseStoredItem(result.Item);
+	if (!isReleaseRow(item.row) || item.sk !== id) throw new DynamoDBStoredItemError();
+	return item;
+};
+const loadReleaseItemsByScope = async (store, scopeKey) => (await queryItems(store, {
+	partition: releaseScopePartition(scopeKey),
+	consistentRead: true
+})).filter((item) => item.pk === releaseScopePartition(scopeKey) && isReleaseRow(item.row));
+const loadReleaseItems = async (store) => {
+	let exclusiveStartKey;
+	const items = [];
+	do {
+		const page = await store.client.send(new ScanCommand({
+			TableName: store.tableName,
+			ExclusiveStartKey: exclusiveStartKey,
+			ConsistentRead: true,
+			FilterExpression: "begins_with(#pk, :prefix)",
+			ExpressionAttributeNames: { "#pk": "pk" },
+			ExpressionAttributeValues: { ":prefix": "release-scope#" }
+		}));
+		for (const value of page.Items ?? []) {
+			const item = parseStoredItem(value);
+			if (isReleaseRow(item.row)) items.push(item);
+		}
+		exclusiveStartKey = page.LastEvaluatedKey;
+	} while (exclusiveStartKey !== void 0);
+	return items;
+};
+const loadReleaseCatalogItem = async (store, scopeKey) => {
+	const result = await store.client.send(new GetCommand({
+		TableName: store.tableName,
+		Key: itemKey("release_catalogs", scopeKey),
+		ConsistentRead: true
+	}));
+	if (result.Item === void 0) return void 0;
+	const item = parseStoredItem(result.Item);
+	return item.pk === "release_catalogs" ? item : void 0;
+};
+const loadReleaseCatalogItems = async (store) => (await queryItems(store, {
+	partition: "release_catalogs",
+	consistentRead: true
+})).filter((item) => item.pk === "release_catalogs");
+const loadChannelByName = async (store, name) => {
+	const { Item } = await store.client.send(new GetCommand({
+		TableName: store.tableName,
+		Key: {
+			pk: DYNAMODB_CHANNEL_NAME_PARTITION,
+			sk: name
+		},
+		ConsistentRead: true
+	}));
+	const id = Item?.channel_id;
+	if (Item === void 0) return void 0;
+	if (typeof id !== "string") throw new DynamoDBStoredItemError();
+	const channel = await loadChannelItem(store, id);
+	if (channel === void 0 || channel.row.name !== name) throw new DynamoDBStoredItemError();
+	return channel;
+};
+const insertDynamoDBChannel = async (store, input) => {
+	const existing = await loadChannelByName(store, input.row.name);
+	if (existing !== void 0) return {
+		row: existing.row,
+		inserted: false
+	};
+	const existingId = await loadChannelItem(store, input.row.id);
+	if (existingId !== void 0) {
+		if (existingId.row.name === input.row.name) return {
+			row: existingId.row,
+			inserted: false
+		};
+		throw new DynamoDBStoredItemError();
+	}
+	try {
+		await commitDynamoDBTransaction(store, [{ Put: {
+			TableName: store.tableName,
+			Item: boundedDynamoDBMetadataItem(toDynamoDBChannelItem(input.row)),
+			ConditionExpression: "attribute_not_exists(#pk)",
+			ExpressionAttributeNames: { "#pk": "pk" }
+		} }, { Put: {
+			TableName: store.tableName,
+			Item: {
+				pk: DYNAMODB_CHANNEL_NAME_PARTITION,
+				sk: input.row.name,
+				channel_id: input.row.id
+			},
+			ConditionExpression: "attribute_not_exists(#pk)",
+			ExpressionAttributeNames: { "#pk": "pk" }
+		} }]);
+		return {
+			row: input.row,
+			inserted: true
+		};
+	} catch (error) {
+		const canonical = await loadChannelByName(store, input.row.name);
+		if (canonical !== void 0) return {
+			row: canonical.row,
+			inserted: false
+		};
+		throw error;
 	}
-	define(typeMap, force = false) {
-		for (let [type, extensions] of Object.entries(typeMap)) {
-			type = type.toLowerCase();
-			extensions = extensions.map((ext) => ext.toLowerCase());
-			if (!__classPrivateFieldGet(this, _Mime_typeToExtensions, "f").has(type)) __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").set(type, /* @__PURE__ */ new Set());
-			const allExtensions = __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").get(type);
-			let first = true;
-			for (let extension of extensions) {
-				const starred = extension.startsWith("*");
-				extension = starred ? extension.slice(1) : extension;
-				allExtensions?.add(extension);
-				if (first) __classPrivateFieldGet(this, _Mime_typeToExtension, "f").set(type, extension);
-				first = false;
-				if (starred) continue;
-				const currentType = __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(extension);
-				if (currentType && currentType != type && !force) throw new Error(`"${type} -> ${extension}" conflicts with "${currentType} -> ${extension}". Pass \`force=true\` to override this definition.`);
-				__classPrivateFieldGet(this, _Mime_extensionToType, "f").set(extension, type);
+};
+const deleteDynamoDBChannel = async (store, input) => {
+	const current = await loadChannelItem(store, input.id);
+	if (current === void 0) return {
+		deleted: false,
+		reason: "not_found"
+	};
+	if (current.reference_count !== 0) return {
+		deleted: false,
+		reason: "not_empty"
+	};
+	try {
+		await commitDynamoDBTransaction(store, [{ Delete: {
+			TableName: store.tableName,
+			Key: itemKey(DYNAMODB_CHANNEL_PARTITION, current.sk),
+			ConditionExpression: "#version = :version AND #referenceCount = :zero",
+			ExpressionAttributeNames: {
+				"#version": "version",
+				"#referenceCount": "reference_count"
+			},
+			ExpressionAttributeValues: {
+				":version": current.version,
+				":zero": 0
 			}
+		} }, { Delete: {
+			TableName: store.tableName,
+			Key: {
+				pk: DYNAMODB_CHANNEL_NAME_PARTITION,
+				sk: current.row.name
+			},
+			ConditionExpression: "#channelId = :channelId",
+			ExpressionAttributeNames: { "#channelId": "channel_id" },
+			ExpressionAttributeValues: { ":channelId": current.sk }
+		} }]);
+		return { deleted: true };
+	} catch (error) {
+		const latest = await loadChannelItem(store, input.id);
+		if (latest !== void 0 && latest.reference_count > 0) return {
+			deleted: false,
+			reason: "not_empty"
+		};
+		if (latest === void 0) return {
+			deleted: false,
+			reason: "not_found"
+		};
+		throw error;
+	}
+};
+const queryOwnerPatchIds = async (store, indexName, bundleId) => {
+	return (await queryItems(store, {
+		partition: patchOwnerPartition(bundleId),
+		indexName
+	})).filter((item) => item.pk === "bundle_patches").map(({ sk }) => sk);
+};
+var DynamoDBTransactionLimitError = class extends Error {
+	name = "DynamoDBTransactionLimitError";
+	constructor(actionCount) {
+		super(`DynamoDB transaction requires ${actionCount} actions; maximum is 100`);
+		this.actionCount = actionCount;
+	}
+};
+const metadataUpdate = (store, delta) => {
+	const entries = Object.entries(delta).filter(([, value]) => value !== 0);
+	if (entries.length === 0) return void 0;
+	const names = {};
+	const values = {};
+	const updates = [];
+	const conditions = [];
+	for (const [model, change] of entries) {
+		const name = model === "bundles" ? "bundles" : "patches";
+		const valueName = model === "bundles" ? "bundle" : "patch";
+		names[`#${name}`] = name;
+		values[`:${valueName}Delta`] = change;
+		updates.push(`#${name} :${valueName}Delta`);
+		if (change < 0) {
+			values[`:${valueName}Removal`] = -change;
+			conditions.push(`#${name} >= :${valueName}Removal`);
+		}
+	}
+	return { Update: {
+		TableName: store.tableName,
+		Key: {
+			pk: "_hot-updater",
+			sk: "limits.metadata"
+		},
+		UpdateExpression: `ADD ${updates.join(", ")}`,
+		...conditions.length > 0 ? { ConditionExpression: conditions.join(" AND ") } : {},
+		ExpressionAttributeNames: names,
+		ExpressionAttributeValues: values
+	} };
+};
+const updateBundleRelation = (store, bundleId, delta, ownedPatchDelta = 0) => {
+	const names = {
+		"#pk": "pk",
+		"#version": "version"
+	};
+	const values = { ":one": 1 };
+	const additions = [];
+	let condition = "attribute_exists(#pk)";
+	let update = "SET #version = #version + :one";
+	if (delta !== 0) {
+		names["#relationCount"] = "relation_count";
+		values[":relationDelta"] = delta;
+		additions.push("#relationCount :relationDelta");
+		if (delta < 0) {
+			values[":relationRemoval"] = -delta;
+			condition += " AND #relationCount >= :relationRemoval";
 		}
-		return this;
 	}
-	getType(path) {
-		if (typeof path !== "string") return null;
-		const last = path.replace(/^.*[/\\]/s, "").toLowerCase();
-		const ext = last.replace(/^.*\./s, "").toLowerCase();
-		const hasPath = last.length < path.length;
-		if (!(ext.length < last.length - 1) && hasPath) return null;
-		return __classPrivateFieldGet(this, _Mime_extensionToType, "f").get(ext) ?? null;
+	if (ownedPatchDelta !== 0) {
+		names["#ownedPatchCount"] = "owned_patch_count";
+		values[":ownedPatchDelta"] = ownedPatchDelta;
+		additions.push("#ownedPatchCount :ownedPatchDelta");
+		if (ownedPatchDelta < 0) {
+			values[":ownedPatchRemoval"] = -ownedPatchDelta;
+			condition += " AND #ownedPatchCount >= :ownedPatchRemoval";
+		}
 	}
-	getExtension(type) {
-		if (typeof type !== "string") return null;
-		type = type?.split?.(";")[0];
-		return (type && __classPrivateFieldGet(this, _Mime_typeToExtension, "f").get(type.trim().toLowerCase())) ?? null;
+	if (additions.length > 0) update += ` ADD ${additions.join(", ")}`;
+	return { Update: {
+		TableName: store.tableName,
+		Key: itemKey("bundles", bundleId),
+		ConditionExpression: condition,
+		ExpressionAttributeNames: names,
+		ExpressionAttributeValues: values,
+		UpdateExpression: update
+	} };
+};
+const commitDynamoDBTransaction = async (store, actions) => {
+	if (actions.length > 100) throw new DynamoDBTransactionLimitError(actions.length);
+	await store.client.send(new TransactWriteCommand({ TransactItems: [...actions] }));
+};
+const DYNAMODB_BATCH_GET_ATTEMPTS = 5;
+const DYNAMODB_BATCH_GET_BASE_DELAY_MS = 25;
+var DynamoDBBatchGetExhaustedError = class extends Error {
+	name = "DynamoDBBatchGetExhaustedError";
+	constructor(unprocessedKeyCount) {
+		super(`DynamoDB did not process ${unprocessedKeyCount} batch-get keys after ${DYNAMODB_BATCH_GET_ATTEMPTS} attempts`);
+		this.unprocessedKeyCount = unprocessedKeyCount;
+	}
+};
+const waitBeforeRetry = (attempt) => new Promise((resolve) => setTimeout(resolve, DYNAMODB_BATCH_GET_BASE_DELAY_MS * 2 ** attempt));
+const batchGetDynamoDBItems = async (store, keys) => {
+	const items = [];
+	for (let offset = 0; offset < keys.length; offset += 100) {
+		let pending = keys.slice(offset, offset + 100);
+		for (let attempt = 0; attempt < DYNAMODB_BATCH_GET_ATTEMPTS && pending.length > 0; attempt++) {
+			const { Responses, UnprocessedKeys } = await store.client.send(new BatchGetCommand({ RequestItems: { [store.tableName]: {
+				ConsistentRead: true,
+				Keys: pending
+			} } }));
+			items.push(...Responses?.[store.tableName] ?? []);
+			pending = UnprocessedKeys?.[store.tableName]?.Keys ?? [];
+			if (pending.length > 0 && attempt + 1 < DYNAMODB_BATCH_GET_ATTEMPTS) await waitBeforeRetry(attempt);
+		}
+		if (pending.length > 0) throw new DynamoDBBatchGetExhaustedError(pending.length);
+	}
+	return items;
+};
+const parseKeyReadItem = (item) => parseDynamoDBItem(boundedDynamoDBMetadataItem(item));
+const loadBundleItemsById = async (store, ids) => {
+	const uniqueIds = [...new Set(ids)];
+	if (uniqueIds.length === 0) return [];
+	return (await batchGetDynamoDBItems(store, uniqueIds.map((id) => itemKey("bundles", id)))).map(parseKeyReadItem).filter((item) => item.pk === "bundles");
+};
+const loadPatchItemsById = async (store, ids) => {
+	const uniqueIds = [...new Set(ids)];
+	if (uniqueIds.length === 0) return [];
+	return (await batchGetDynamoDBItems(store, uniqueIds.map((id) => itemKey("bundle_patches", id)))).map(parseKeyReadItem).filter((item) => item.pk === "bundle_patches");
+};
+const loadMetadataCount = async (store, model) => {
+	if (model !== "bundles" && model !== "bundle_patches") return void 0;
+	const field = model === "bundles" ? "bundles" : "patches";
+	const { Item } = await store.client.send(new GetCommand({
+		TableName: store.tableName,
+		Key: {
+			pk: "_hot-updater",
+			sk: "limits.metadata"
+		},
+		ConsistentRead: true,
+		ProjectionExpression: "#count",
+		ExpressionAttributeNames: { "#count": field }
+	}));
+	const count = Item?.[field];
+	return typeof count === "number" && Number.isSafeInteger(count) && count >= 0 ? count : void 0;
+};
+var DynamoDBPatchIndexConsistencyError = class extends Error {
+	name = "DynamoDBPatchIndexConsistencyError";
+	constructor(bundleId, expectedCount) {
+		super(`DynamoDB patch index did not converge to ${expectedCount} rows for bundle "${bundleId}"`);
+		this.bundleId = bundleId;
+		this.expectedCount = expectedCount;
 	}
-	getAllExtensions(type) {
-		if (typeof type !== "string") return null;
-		return __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").get(type.toLowerCase()) ?? null;
+};
+const waitForIndex = (attempt) => new Promise((resolve) => setTimeout(resolve, 20 * (attempt + 1)));
+const queryCompleteOwnerPatches = async (store, indexName, bundleId) => {
+	const owner = await loadBundleItem(store, bundleId);
+	if (!owner || owner.owned_patch_count === 0) return [];
+	for (let attempt = 0; attempt < 3; attempt++) {
+		const patchIds = await queryOwnerPatchIds(store, indexName, bundleId);
+		const patchIdSet = new Set(patchIds);
+		const patches = (await loadPatchItemsById(store, patchIds)).filter(({ row }) => row.bundle_id === bundleId);
+		if (patchIds.length === owner.owned_patch_count && patchIdSet.size === owner.owned_patch_count && patches.length === owner.owned_patch_count && patches.every(({ sk }) => patchIdSet.has(sk))) return patches.map(({ row }) => row).sort((left, right) => left.order_index - right.order_index || left.id.localeCompare(right.id));
+		if (attempt < 2) await waitForIndex(attempt);
+	}
+	throw new DynamoDBPatchIndexConsistencyError(bundleId, owner.owned_patch_count);
+};
+const queryCompleteOwnersPatches = async (store, indexName, bundleIds) => {
+	const owners = (await loadBundleItemsById(store, bundleIds)).filter(({ owned_patch_count }) => owned_patch_count > 0);
+	const firstOwner = owners[0];
+	if (!firstOwner) return [];
+	let failedOwner = firstOwner;
+	for (let attempt = 0; attempt < 3; attempt++) {
+		const candidateIdsByOwner = await Promise.all(owners.map(({ sk }) => queryOwnerPatchIds(store, indexName, sk)));
+		const patches = await loadPatchItemsById(store, candidateIdsByOwner.flat());
+		const patchesById = new Map(patches.map((patch) => [patch.sk, patch]));
+		const mismatchedOwner = owners.find((owner, ownerIndex) => {
+			const ids = candidateIdsByOwner[ownerIndex] ?? [];
+			const uniqueIds = new Set(ids);
+			return ids.length !== owner.owned_patch_count || uniqueIds.size !== owner.owned_patch_count || ids.some((id) => patchesById.get(id)?.row.bundle_id !== owner.sk);
+		});
+		if (!mismatchedOwner) return patches.map(({ row }) => row);
+		failedOwner = mismatchedOwner;
+		if (attempt < 2) await waitForIndex(attempt);
+	}
+	throw new DynamoDBPatchIndexConsistencyError(failedOwner.sk, failedOwner.owned_patch_count);
+};
+const createDynamoDBBundlePatchTable = (store, indexName) => ({ findByBundleIds: (bundleIds) => bundleIds.length === 0 ? Promise.resolve([]) : queryCompleteOwnersPatches(store, indexName, bundleIds) });
+const compare = (left, right) => {
+	if (typeof left === "number" && typeof right === "number") return left - right;
+	if (left == null) return right == null ? 0 : -1;
+	if (right == null) return 1;
+	return JSON.stringify(left).localeCompare(JSON.stringify(right));
+};
+const compareString = (actual, expected, mode, predicate) => {
+	if (typeof actual !== "string") return false;
+	return mode === "insensitive" ? predicate(actual.toLocaleLowerCase(), expected.toLocaleLowerCase()) : predicate(actual, expected);
+};
+const matchesCondition = (row, condition) => {
+	const actual = Reflect.get(row, condition.field);
+	const expected = Reflect.get(condition, "value");
+	switch (Reflect.get(condition, "operator") ?? "eq") {
+		case "eq": return typeof expected === "string" ? compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value === query) : actual === expected;
+		case "ne":
+			if (actual == null) return false;
+			return typeof expected === "string" ? !compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value === query) : actual !== expected;
+		case "gt": return actual != null && compare(actual, expected) > 0;
+		case "gte": return actual != null && compare(actual, expected) >= 0;
+		case "lt": return actual != null && compare(actual, expected) < 0;
+		case "lte": return actual != null && compare(actual, expected) <= 0;
+		case "in": return Array.isArray(expected) && expected.some((candidate) => candidate === actual);
+		case "not_in": return Array.isArray(expected) && (expected.length === 0 || actual != null && expected.every((candidate) => candidate !== actual));
+		case "contains": return typeof expected === "string" ? compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value.includes(query)) : false;
+		case "starts_with": return typeof expected === "string" ? compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value.startsWith(query)) : false;
+		case "ends_with": return typeof expected === "string" ? compareString(actual, expected, Reflect.get(condition, "mode"), (value, query) => value.endsWith(query)) : false;
+		default: return false;
+	}
+};
+const matchesDynamoDBWhere = (row, where) => {
+	if (!where || where.length === 0) return true;
+	let result = matchesCondition(row, where[0]);
+	for (const condition of where.slice(1)) {
+		const current = matchesCondition(row, condition);
+		result = condition.connector === "OR" ? result || current : result && current;
+	}
+	return result;
+};
+const compareRows = (left, right, orderBy) => {
+	for (const clause of orderBy) {
+		const leftValue = Reflect.get(left, clause.field);
+		const rightValue = Reflect.get(right, clause.field);
+		if (leftValue == null || rightValue == null) {
+			if (leftValue == null && rightValue == null) continue;
+			const nulls = clause.nulls ?? (clause.direction === "asc" ? "last" : "first");
+			const order = leftValue == null ? -1 : 1;
+			return nulls === "first" ? order : -order;
+		}
+		const order = compare(leftValue, rightValue);
+		if (order !== 0) return clause.direction === "asc" ? order : -order;
+	}
+	return 0;
+};
+const distinctKey = (row, distinctOn) => JSON.stringify(distinctOn.fields.map((field) => Reflect.get(row, field)));
+const queryDynamoDBRows = (rows, input) => {
+	const filtered = rows.filter((row) => matchesDynamoDBWhere(row, input.where));
+	const orderBy = input.orderBy;
+	const ordered = orderBy ? filtered.toSorted((left, right) => compareRows(left, right, orderBy)) : filtered;
+	const distinctOn = input.distinctOn;
+	const distinct = distinctOn ? (() => {
+		const seen = /* @__PURE__ */ new Set();
+		return ordered.filter((row) => {
+			const key = distinctKey(row, distinctOn);
+			if (seen.has(key)) return false;
+			seen.add(key);
+			return true;
+		});
+	})() : ordered;
+	const offset = input.offset ?? 0;
+	return distinct.slice(offset, offset + (input.limit ?? 100));
+};
+const countDistinctDynamoDBRows = (rows, fields) => {
+	if (fields === void 0) return rows.length;
+	return new Set(rows.map((row) => JSON.stringify(fields.map((field) => Reflect.get(row, field))))).size;
+};
+const createDynamoDBBundle = async (store, row) => {
+	const counter = metadataUpdate(store, { bundles: 1 });
+	if (!counter) return;
+	await commitDynamoDBTransaction(store, [counter, { Put: {
+		TableName: store.tableName,
+		Item: boundedDynamoDBMetadataItem(toDynamoDBBundleItem(row)),
+		ConditionExpression: "attribute_not_exists(#pk)",
+		ExpressionAttributeNames: { "#pk": "pk" }
+	} }]);
+};
+const createDynamoDBPatch = async (store, row) => {
+	const bundleIds = [...new Set([row.bundle_id, row.base_bundle_id])];
+	const counter = metadataUpdate(store, { bundle_patches: 1 });
+	if (!counter) return;
+	await commitDynamoDBTransaction(store, [
+		counter,
+		...bundleIds.map((bundleId) => updateBundleRelation(store, bundleId, 1, bundleId === row.bundle_id ? 1 : 0)),
+		{ Put: {
+			TableName: store.tableName,
+			Item: boundedDynamoDBMetadataItem(toDynamoDBPatchItem(row)),
+			ConditionExpression: "attribute_not_exists(#pk)",
+			ExpressionAttributeNames: { "#pk": "pk" }
+		} }
+	]);
+};
+const replaceDynamoDBBundle = async (store, current, row) => {
+	await store.client.send(new PutCommand({
+		TableName: store.tableName,
+		Item: boundedDynamoDBMetadataItem(toDynamoDBBundleItem(row, current.version + 1, current.relation_count, current.owned_patch_count)),
+		ConditionExpression: "#version = :currentVersion",
+		ExpressionAttributeNames: { "#version": "version" },
+		ExpressionAttributeValues: { ":currentVersion": current.version }
+	}));
+};
+const deleteAction = (store, item) => ({ Delete: {
+	TableName: store.tableName,
+	Key: {
+		pk: item.pk,
+		sk: item.sk
+	},
+	ConditionExpression: "#version = :currentVersion",
+	ExpressionAttributeNames: { "#version": "version" },
+	ExpressionAttributeValues: { ":currentVersion": item.version }
+} });
+const deleteDynamoDBPatch = async (store, item) => {
+	const counter = metadataUpdate(store, { bundle_patches: -1 });
+	if (!counter) return;
+	await commitDynamoDBTransaction(store, [
+		counter,
+		...[...new Set([item.row.bundle_id, item.row.base_bundle_id])].map((id) => updateBundleRelation(store, id, -1, id === item.row.bundle_id ? -1 : 0)),
+		deleteAction(store, item)
+	]);
+};
+const deleteBundle = async (store, bundle, patches) => {
+	const counter = metadataUpdate(store, {
+		bundles: -1,
+		bundle_patches: -patches.length
+	});
+	if (!counter) return;
+	const otherEndpointCounts = /* @__PURE__ */ new Map();
+	for (const { row } of patches) for (const id of new Set([row.bundle_id, row.base_bundle_id])) {
+		if (id === bundle.sk) continue;
+		const current = otherEndpointCounts.get(id) ?? {
+			owned: 0,
+			relations: 0
+		};
+		otherEndpointCounts.set(id, {
+			owned: current.owned + (id === row.bundle_id ? 1 : 0),
+			relations: current.relations + 1
+		});
 	}
-	_freeze() {
-		this.define = () => {
-			throw new Error("define() not allowed for built-in Mime objects. See https://github.com/broofa/mime/blob/main/README.md#custom-mime-instances");
+	await commitDynamoDBTransaction(store, [
+		counter,
+		...[...otherEndpointCounts].map(([id, count]) => updateBundleRelation(store, id, -count.relations, -count.owned)),
+		...patches.map((patch) => deleteAction(store, patch)),
+		deleteAction(store, bundle)
+	]);
+};
+const deleteDynamoDBBundles = async (store, bundles, allPatches) => {
+	let patches = [...allPatches];
+	const versionIncrements = /* @__PURE__ */ new Map();
+	for (const originalBundle of bundles) {
+		const bundle = {
+			...originalBundle,
+			version: originalBundle.version + (versionIncrements.get(originalBundle.sk) ?? 0)
 		};
-		Object.freeze(this);
-		for (const extensions of __classPrivateFieldGet(this, _Mime_typeToExtensions, "f").values()) Object.freeze(extensions);
-		return this;
+		const related = patches.filter(({ row }) => row.bundle_id === bundle.sk || row.base_bundle_id === bundle.sk);
+		await deleteBundle(store, bundle, related);
+		const updatedBundleIds = new Set(related.flatMap(({ row }) => [row.bundle_id, row.base_bundle_id]));
+		updatedBundleIds.delete(bundle.sk);
+		for (const id of updatedBundleIds) versionIncrements.set(id, (versionIncrements.get(id) ?? 0) + 1);
+		const removedPatchIds = new Set(related.map(({ sk }) => sk));
+		patches = patches.filter(({ sk }) => !removedPatchIds.has(sk));
 	}
-	_getTestState() {
-		return {
-			types: __classPrivateFieldGet(this, _Mime_extensionToType, "f"),
-			extensions: __classPrivateFieldGet(this, _Mime_typeToExtension, "f")
+};
+var DynamoDBUnsupportedModelError = class extends Error {
+	name = "DynamoDBUnsupportedModelError";
+	constructor() {
+		super("DynamoDB received an unsupported database model");
+	}
+};
+const distinctFields = (fields) => fields;
+const exactDynamoDBField = (where, fieldName) => {
+	const conditions = (where ?? []).filter((condition) => Reflect.get(condition, "field") === fieldName);
+	if (conditions.length !== 1) return void 0;
+	const condition = conditions[0];
+	if ((Reflect.get(condition, "operator") ?? "eq") !== "eq" || Reflect.get(condition, "mode") === "insensitive") return;
+	const value = Reflect.get(condition, "value");
+	return typeof value === "string" ? value : void 0;
+};
+const createDynamoDBCrud = (store, updateIndexName) => ({
+	async create(input) {
+		switch (input.model) {
+			case "bundles":
+				await createDynamoDBBundle(store, input.data);
+				return input.data;
+			case "bundle_patches":
+				await createDynamoDBPatch(store, input.data);
+				return input.data;
+			case "releases": {
+				const channel = await loadChannelItem(store, input.data.channel_id);
+				if (channel === void 0) throw new DynamoDBStoredItemError();
+				await commitDynamoDBTransaction(store, [
+					updateChannelReferenceCount(store, channel, 1),
+					{ Put: {
+						TableName: store.tableName,
+						Item: boundedDynamoDBMetadataItem(toDynamoDBReleaseItem(input.data)),
+						ConditionExpression: "attribute_not_exists(#pk)",
+						ExpressionAttributeNames: { "#pk": "pk" }
+					} },
+					{ Put: {
+						TableName: store.tableName,
+						Item: releaseLocatorItem(input.data),
+						ConditionExpression: "attribute_not_exists(#pk)",
+						ExpressionAttributeNames: { "#pk": "pk" }
+					} }
+				]);
+				return input.data;
+			}
+			case "release_catalogs":
+				await store.client.send(new PutCommand({
+					TableName: store.tableName,
+					Item: boundedDynamoDBCatalogItem(toDynamoDBReleaseCatalogItem(input.data)),
+					ConditionExpression: "attribute_not_exists(#pk)",
+					ExpressionAttributeNames: { "#pk": "pk" }
+				}));
+				return input.data;
+			case "channels": return (await insertDynamoDBChannel(store, {
+				row: input.data,
+				onConflict: "returnExisting"
+			})).row;
+		}
+		throw new DynamoDBUnsupportedModelError();
+	},
+	async update(input) {
+		if (input.model === "releases") {
+			const id = exactDynamoDBId(input.where);
+			if (id === void 0) throw new DynamoDBUnsupportedModelError();
+			const current = await loadReleaseItem(store, id);
+			if (current === void 0) return null;
+			const updated = {
+				...current.row,
+				...input.update
+			};
+			const nextPartition = releaseScopePartition(updated.scope_key);
+			const moved = current.pk !== nextPartition;
+			await commitDynamoDBTransaction(store, [
+				...moved ? [{ Delete: {
+					TableName: store.tableName,
+					Key: {
+						pk: current.pk,
+						sk: current.sk
+					},
+					ConditionExpression: "#version = :version",
+					ExpressionAttributeNames: { "#version": "version" },
+					ExpressionAttributeValues: { ":version": current.version }
+				} }] : [],
+				{ Put: {
+					TableName: store.tableName,
+					Item: boundedDynamoDBMetadataItem(toDynamoDBReleaseItem(updated, current.version + 1)),
+					ConditionExpression: moved ? "attribute_not_exists(#pk)" : "#version = :version",
+					ExpressionAttributeNames: moved ? { "#pk": "pk" } : { "#version": "version" },
+					...moved ? {} : { ExpressionAttributeValues: { ":version": current.version } }
+				} },
+				{ Put: {
+					TableName: store.tableName,
+					Item: releaseLocatorItem(updated),
+					ConditionExpression: "#scopeKey = :scopeKey",
+					ExpressionAttributeNames: { "#scopeKey": "scope_key" },
+					ExpressionAttributeValues: { ":scopeKey": current.row.scope_key }
+				} }
+			]);
+			return updated;
+		}
+		if (input.model === "release_catalogs") {
+			const scopeKey = exactDynamoDBField(input.where, "scope_key");
+			if (scopeKey === void 0) throw new DynamoDBUnsupportedModelError();
+			const current = await loadReleaseCatalogItem(store, scopeKey);
+			if (current === void 0) return null;
+			const updated = {
+				...current.row,
+				...input.update
+			};
+			await store.client.send(new PutCommand({
+				TableName: store.tableName,
+				Item: boundedDynamoDBCatalogItem(toDynamoDBReleaseCatalogItem(updated, current.version + 1)),
+				ConditionExpression: "#version = :version",
+				ExpressionAttributeNames: { "#version": "version" },
+				ExpressionAttributeValues: { ":version": current.version }
+			}));
+			return updated;
+		}
+		if (input.model !== "bundles") throw new DynamoDBUnsupportedModelError();
+		const id = exactDynamoDBId(input.where);
+		const current = id === void 0 ? (await loadBundleItems(store)).find(({ row }) => matchesDynamoDBWhere(row, input.where)) : await loadBundleItem(store, id);
+		if (!current) return null;
+		const updated = {
+			...current.row,
+			...input.update
 		};
+		await replaceDynamoDBBundle(store, current, updated);
+		return updated;
+	},
+	async delete(input) {
+		if (input.model === "channels") {
+			const id = exactDynamoDBId(input.where);
+			if (id !== void 0) await deleteDynamoDBChannel(store, { id });
+			return;
+		}
+		if (input.model === "bundle_patches") {
+			const items = (await loadPatchItems(store)).filter(({ row }) => matchesDynamoDBWhere(row, input.where));
+			for (const item of items) await deleteDynamoDBPatch(store, item);
+			return;
+		}
+		if (input.model === "releases") {
+			const items = (await loadReleaseItems(store)).filter(({ row }) => matchesDynamoDBWhere(row, input.where));
+			for (const item of items) {
+				const channel = await loadChannelItem(store, item.row.channel_id);
+				if (channel === void 0) throw new DynamoDBStoredItemError();
+				await commitDynamoDBTransaction(store, [
+					updateChannelReferenceCount(store, channel, -1),
+					deleteAction(store, item),
+					{ Delete: {
+						TableName: store.tableName,
+						Key: {
+							pk: DYNAMODB_RELEASE_ID_PARTITION,
+							sk: item.sk
+						},
+						ConditionExpression: "#scopeKey = :scopeKey",
+						ExpressionAttributeNames: { "#scopeKey": "scope_key" },
+						ExpressionAttributeValues: { ":scopeKey": item.row.scope_key }
+					} }
+				]);
+			}
+			return;
+		}
+		if (input.model !== "bundles") throw new DynamoDBUnsupportedModelError();
+		const bundleItems = (await loadBundleItems(store)).filter(({ row }) => matchesDynamoDBWhere(row, input.where));
+		if (bundleItems.length === 0) return;
+		await deleteDynamoDBBundles(store, bundleItems, await loadPatchItems(store));
+	},
+	async count(input) {
+		if ((input.where === void 0 || input.where.length === 0) && input.distinct === void 0) {
+			const count = await loadMetadataCount(store, input.model);
+			if (count !== void 0) return count;
+		}
+		switch (input.model) {
+			case "bundles": return countDistinctDynamoDBRows((await loadBundleItems(store)).map(({ row }) => row).filter((row) => matchesDynamoDBWhere(row, input.where)), distinctFields(input.distinct));
+			case "bundle_patches": {
+				const ownerId = exactDynamoDBPatchOwner(input.where);
+				return countDistinctDynamoDBRows((ownerId ? await queryCompleteOwnerPatches(store, updateIndexName, ownerId) : (await loadPatchItems(store)).map(({ row }) => row)).filter((row) => matchesDynamoDBWhere(row, input.where)), distinctFields(input.distinct));
+			}
+			case "releases": {
+				const scopeKey = exactDynamoDBField(input.where, "scope_key");
+				return countDistinctDynamoDBRows((scopeKey === void 0 ? await loadReleaseItems(store) : await loadReleaseItemsByScope(store, scopeKey)).map(({ row }) => row).filter((row) => matchesDynamoDBWhere(row, input.where)), distinctFields(input.distinct));
+			}
+		}
+		throw new DynamoDBUnsupportedModelError();
+	},
+	async findOne(input) {
+		const id = exactDynamoDBId(input.where);
+		switch (input.model) {
+			case "bundles":
+				if (id !== void 0) return (await loadBundleItem(store, id))?.row ?? null;
+				return (await loadBundleItems(store)).map(({ row }) => row).find((row) => matchesDynamoDBWhere(row, input.where)) ?? null;
+			case "bundle_patches":
+				if (id !== void 0) return (await loadPatchItem(store, id))?.row ?? null;
+				{
+					const ownerId = exactDynamoDBPatchOwner(input.where);
+					if (ownerId === void 0) break;
+					return (await queryCompleteOwnerPatches(store, updateIndexName, ownerId)).find((row) => matchesDynamoDBWhere(row, input.where)) ?? null;
+				}
+				break;
+			case "channels":
+				if (id !== void 0) return (await loadChannelItem(store, id))?.row ?? null;
+				return (await loadChannelItems(store)).map(({ row }) => row).find((row) => matchesDynamoDBWhere(row, input.where)) ?? null;
+			case "releases":
+				if (id !== void 0) return (await loadReleaseItem(store, id))?.row ?? null;
+				{
+					const scopeKey = exactDynamoDBField(input.where, "scope_key");
+					return (scopeKey === void 0 ? await loadReleaseItems(store) : await loadReleaseItemsByScope(store, scopeKey)).map(({ row }) => row).find((row) => matchesDynamoDBWhere(row, input.where)) ?? null;
+				}
+			case "release_catalogs": {
+				const scopeKey = exactDynamoDBField(input.where, "scope_key");
+				if (scopeKey !== void 0) return (await loadReleaseCatalogItem(store, scopeKey))?.row ?? null;
+				return (await loadReleaseCatalogItems(store)).map(({ row }) => row).find((row) => matchesDynamoDBWhere(row, input.where)) ?? null;
+			}
+		}
+		if (input.model === "bundle_patches") return (await loadPatchItems(store)).map(({ row }) => row).find((row) => matchesDynamoDBWhere(row, input.where)) ?? null;
+		throw new DynamoDBUnsupportedModelError();
+	},
+	async findMany(input) {
+		if (input.limit === 0) return [];
+		switch (input.model) {
+			case "bundles": {
+				const ids = exactDynamoDBBundleIds(input.where);
+				if (ids !== void 0) return queryDynamoDBRows((await loadBundleItemsById(store, ids)).map(({ row }) => row), input);
+				const orderBy = input.orderBy;
+				const direction = orderBy?.[0]?.direction;
+				if ((input.offset ?? 0) === 0 && input.distinctOn === void 0 && orderBy?.length === 1 && orderBy[0]?.field === "id" && (direction === "asc" || direction === "desc")) return (await queryBundleItemsPage(store, {
+					direction,
+					limit: input.limit ?? 100,
+					matches: (row) => matchesDynamoDBWhere(row, input.where),
+					start: dynamoDBBundlePageStart(input.where, direction)
+				})).map(({ row }) => row);
+				return queryDynamoDBRows((await loadBundleItems(store)).map(({ row }) => row), input);
+			}
+			case "bundle_patches": {
+				const ownerIds = exactDynamoDBPatchOwners(input.where);
+				if (ownerIds !== void 0) {
+					const ownerId = ownerIds.length === 1 ? ownerIds[0] : void 0;
+					return queryDynamoDBRows(ownerId !== void 0 ? await queryCompleteOwnerPatches(store, updateIndexName, ownerId) : await queryCompleteOwnersPatches(store, updateIndexName, ownerIds), input);
+				}
+				return queryDynamoDBRows((await loadPatchItems(store)).map(({ row }) => row), input);
+			}
+			case "channels": return queryDynamoDBRows((await loadChannelItems(store)).map(({ row }) => row), input);
+			case "releases": {
+				const scopeKey = exactDynamoDBField(input.where, "scope_key");
+				return queryDynamoDBRows((scopeKey === void 0 ? await loadReleaseItems(store) : await loadReleaseItemsByScope(store, scopeKey)).map(({ row }) => row), input);
+			}
+			case "release_catalogs": return queryDynamoDBRows((await loadReleaseCatalogItems(store)).map(({ row }) => row), input);
+		}
+		throw new DynamoDBUnsupportedModelError();
+	},
+	insertChannel: (input) => insertDynamoDBChannel(store, input),
+	deleteChannel: (input) => deleteDynamoDBChannel(store, input)
+});
+var DynamoDBDuplicatePatchError = class extends Error {
+	name = "DynamoDBDuplicatePatchError";
+	constructor(patchId) {
+		super(`DynamoDB bundle mutation contains duplicate patch "${patchId}"`);
+		this.patchId = patchId;
 	}
 };
-_Mime_extensionToType = /* @__PURE__ */ new WeakMap(), _Mime_typeToExtension = /* @__PURE__ */ new WeakMap(), _Mime_typeToExtensions = /* @__PURE__ */ new WeakMap();
-//#endregion
-//#region ../../node_modules/.pnpm/mime@4.1.0/node_modules/mime/dist/src/index.js
-var src_default = new Mime(types, types$1)._freeze();
+const putNewBundle = (store, row, relationCount, ownedPatchCount = relationCount) => ({ Put: {
+	TableName: store.tableName,
+	Item: boundedDynamoDBMetadataItem(toDynamoDBBundleItem(row, 1, relationCount, ownedPatchCount)),
+	ConditionExpression: "attribute_not_exists(#pk)",
+	ExpressionAttributeNames: { "#pk": "pk" }
+} });
+const putUpdatedBundle = (store, current, row, relationCount, ownedPatchCount) => ({ Put: {
+	TableName: store.tableName,
+	Item: boundedDynamoDBMetadataItem(toDynamoDBBundleItem(row, current.version + 1, relationCount, ownedPatchCount)),
+	ConditionExpression: "#version = :currentVersion",
+	ExpressionAttributeNames: { "#version": "version" },
+	ExpressionAttributeValues: { ":currentVersion": current.version }
+} });
+const putPatch = (store, row, current) => ({ Put: {
+	TableName: store.tableName,
+	Item: boundedDynamoDBMetadataItem(toDynamoDBPatchItem(row, (current?.version ?? 0) + 1)),
+	ConditionExpression: current ? "#version = :currentVersion" : "attribute_not_exists(#pk)",
+	ExpressionAttributeNames: current ? { "#version": "version" } : { "#pk": "pk" },
+	...current ? { ExpressionAttributeValues: { ":currentVersion": current.version } } : {}
+} });
+const deletePatch = (store, item) => ({ Delete: {
+	TableName: store.tableName,
+	Key: itemKey(item.pk, item.sk),
+	ConditionExpression: "#version = :currentVersion",
+	ExpressionAttributeNames: { "#version": "version" },
+	ExpressionAttributeValues: { ":currentVersion": item.version }
+} });
+var DynamoDBCommitStateError = class extends Error {
+	name = "DynamoDBCommitStateError";
+	constructor(message) {
+		super(message);
+	}
+};
+const rowsEqual = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+const putChannel = (store, row, current, referenceCount) => ({ Put: {
+	TableName: store.tableName,
+	Item: boundedDynamoDBMetadataItem(toDynamoDBChannelItem(row, (current?.version ?? 0) + 1, referenceCount)),
+	ConditionExpression: current ? "#version = :version" : "attribute_not_exists(#pk)",
+	ExpressionAttributeNames: current ? { "#version": "version" } : { "#pk": "pk" },
+	...current ? { ExpressionAttributeValues: { ":version": current.version } } : {}
+} });
+const deleteChannelActions = (store, current) => [{ Delete: {
+	TableName: store.tableName,
+	Key: itemKey(DYNAMODB_CHANNEL_PARTITION, current.sk),
+	ConditionExpression: "#version = :version",
+	ExpressionAttributeNames: { "#version": "version" },
+	ExpressionAttributeValues: { ":version": current.version }
+} }, { Delete: {
+	TableName: store.tableName,
+	Key: {
+		pk: DYNAMODB_CHANNEL_NAME_PARTITION,
+		sk: current.row.name
+	},
+	ConditionExpression: "#channelId = :channelId",
+	ExpressionAttributeNames: { "#channelId": "channel_id" },
+	ExpressionAttributeValues: { ":channelId": current.sk }
+} }];
+const updateChannelReferenceCount = (store, current, delta) => ({ Update: {
+	TableName: store.tableName,
+	Key: itemKey(DYNAMODB_CHANNEL_PARTITION, current.sk),
+	ConditionExpression: "#row.#name = :name" + (delta < 0 ? " AND #referenceCount >= :removal" : ""),
+	UpdateExpression: "SET #version = #version + :one ADD #referenceCount :delta",
+	ExpressionAttributeNames: {
+		"#row": "row",
+		"#name": "name",
+		"#version": "version",
+		"#referenceCount": "reference_count"
+	},
+	ExpressionAttributeValues: {
+		":name": current.row.name,
+		":one": 1,
+		":delta": delta,
+		...delta < 0 ? { ":removal": -delta } : {}
+	}
+} });
+const loadApiKeyByHash = async (store, hash) => {
+	const { Item } = await store.client.send(new GetCommand({
+		TableName: store.tableName,
+		Key: {
+			pk: DYNAMODB_API_KEY_HASH_PARTITION,
+			sk: hash
+		},
+		ConsistentRead: true
+	}));
+	if (Item === void 0) return null;
+	const id = Item.api_key_id;
+	if (typeof id !== "string") throw new DynamoDBStoredItemError();
+	return loadApiKey(store, id);
+};
+const compileAndCommitDynamoDBChanges = async (store, input) => {
+	const [originalBundleItems, originalPatchItems, originalChannelItems, originalReleaseItems, originalReleaseCatalogItems] = await Promise.all([
+		loadBundleItems(store),
+		loadPatchItems(store),
+		loadChannelItems(store),
+		loadReleaseItems(store),
+		loadReleaseCatalogItems(store)
+	]);
+	const bundles = new Map(originalBundleItems.map(({ sk, row }) => [sk, row]));
+	const patches = new Map(originalPatchItems.map(({ sk, row }) => [sk, row]));
+	const channels = new Map(originalChannelItems.map(({ sk, row }) => [sk, row]));
+	const channelNames = new Map(originalChannelItems.map(({ sk, row }) => [row.name, sk]));
+	const releases = new Map(originalReleaseItems.map(({ sk, row }) => [sk, row]));
+	const releaseCatalogs = new Map(originalReleaseCatalogItems.map(({ sk, row }) => [sk, row]));
+	const originalApiKeys = /* @__PURE__ */ new Map();
+	const apiKeys = /* @__PURE__ */ new Map();
+	const apiKeyHashes = /* @__PURE__ */ new Map();
+	const analytics = /* @__PURE__ */ new Map();
+	const rememberApiKey = (value) => {
+		if (value === null || apiKeys.has(value.row.id)) return;
+		originalApiKeys.set(value.row.id, value);
+		apiKeys.set(value.row.id, value);
+		apiKeyHashes.set(value.row.hash, value.row.id);
+	};
+	const requireReleaseReferences = (row) => {
+		if (!channels.has(row.channel_id)) throw new DynamoDBCommitStateError(`Release "${row.id}" references an invalid channel`);
+		if (row.bundle_id !== null) {
+			const bundle = bundles.get(row.bundle_id);
+			if (bundle === void 0 || bundle.platform !== row.platform) throw new DynamoDBCommitStateError(`Release "${row.id}" references an invalid bundle`);
+		}
+	};
+	for (const expectation of input.expectations ?? []) {
+		const actualVersion = expectation.model === "releases" ? releases.get(expectation.id)?.revision ?? null : releaseCatalogs.get(expectation.scopeKey)?.generation ?? null;
+		const expectedVersion = expectation.model === "releases" ? expectation.revision : expectation.generation;
+		if (actualVersion !== expectedVersion) return {
+			committed: false,
+			conflict: {
+				actualVersion,
+				changeIndex: -1,
+				expectedVersion,
+				key: expectation.model === "releases" ? expectation.id : expectation.scopeKey,
+				model: expectation.model,
+				reason: "version_conflict"
+			}
+		};
+	}
+	for (const [changeIndex, change] of input.changes.entries()) switch (change.model) {
+		case "channels":
+			if (change.operation === "insert") {
+				if (channelNames.get(change.row.name) !== void 0) break;
+				if (channels.get(change.row.id) !== void 0) throw new DynamoDBCommitStateError(`Channel id "${change.row.id}" already exists`);
+				channels.set(change.row.id, change.row);
+				channelNames.set(change.row.name, change.row.id);
+			} else {
+				const current = channels.get(change.where.id);
+				if (current === void 0) break;
+				if ([...releases.values()].some(({ channel_id }) => channel_id === change.where.id)) return {
+					committed: false,
+					conflict: {
+						changeIndex,
+						reason: "referenced"
+					}
+				};
+				channels.delete(change.where.id);
+				channelNames.delete(current.name);
+			}
+			break;
+		case "bundles":
+			if (change.operation === "insert") {
+				if (bundles.has(change.row.id)) throw new DynamoDBCommitStateError(`Bundle "${change.row.id}" already exists`);
+				bundles.set(change.row.id, change.row);
+			} else {
+				const current = bundles.get(change.where.id);
+				if (current === void 0) {
+					if (change.operation === "update") return {
+						committed: false,
+						conflict: {
+							changeIndex,
+							reason: "not_found"
+						}
+					};
+					break;
+				}
+				if (change.operation === "update") {
+					const row = {
+						...current,
+						...change.update
+					};
+					bundles.set(row.id, row);
+				} else {
+					if ([...releases.values()].some(({ bundle_id }) => bundle_id === change.where.id)) return {
+						committed: false,
+						conflict: {
+							changeIndex,
+							reason: "referenced"
+						}
+					};
+					bundles.delete(change.where.id);
+					for (const [id, patch] of patches) if (patch.bundle_id === change.where.id || patch.base_bundle_id === change.where.id) patches.delete(id);
+				}
+			}
+			break;
+		case "releases":
+			if (change.operation === "insert") {
+				requireReleaseReferences(change.row);
+				if (releases.has(change.row.id)) throw new DynamoDBCommitStateError(`Release "${change.row.id}" already exists`);
+				releases.set(change.row.id, change.row);
+			} else {
+				const current = releases.get(change.where.id);
+				if (current === void 0) {
+					if (change.operation === "update") return {
+						committed: false,
+						conflict: {
+							changeIndex,
+							reason: "not_found"
+						}
+					};
+					break;
+				}
+				if (change.operation === "update") {
+					const row = {
+						...current,
+						...change.update
+					};
+					requireReleaseReferences(row);
+					releases.set(row.id, row);
+				} else releases.delete(change.where.id);
+			}
+			break;
+		case "releaseCatalogs":
+			if (!channels.has(change.row.channel_id)) throw new DynamoDBCommitStateError(`Release catalog "${change.row.scope_key}" references an invalid channel`);
+			releaseCatalogs.set(change.row.scope_key, change.row);
+			break;
+		case "bundlePatches":
+			if (change.operation === "insert") {
+				if (!bundles.has(change.row.bundle_id) || !bundles.has(change.row.base_bundle_id)) throw new DynamoDBCommitStateError(`Patch "${change.row.id}" references a missing bundle`);
+				if (patches.has(change.row.id)) throw new DynamoDBDuplicatePatchError(change.row.id);
+				patches.set(change.row.id, change.row);
+			} else for (const [id, patch] of patches) if (patch.bundle_id === change.where.bundleId) patches.delete(id);
+			break;
+		case "analytics": {
+			const key = analyticsSortKey(change.row);
+			if (analytics.has(key)) throw new DynamoDBCommitStateError(`Analytics event "${change.row.id}" is duplicated`);
+			analytics.set(key, change.row);
+			break;
+		}
+		case "apiKeys":
+			if (change.operation === "insert") {
+				rememberApiKey(await loadApiKeyByHash(store, change.row.hash));
+				if (apiKeyHashes.has(change.row.hash)) break;
+				rememberApiKey(await loadApiKey(store, change.row.id));
+				if (apiKeys.has(change.row.id)) throw new DynamoDBCommitStateError(`API key id "${change.row.id}" already exists`);
+				const inserted = {
+					row: change.row,
+					version: 1
+				};
+				apiKeys.set(change.row.id, inserted);
+				apiKeyHashes.set(change.row.hash, change.row.id);
+			} else {
+				rememberApiKey(await loadApiKey(store, change.where.id));
+				const current = apiKeys.get(change.where.id);
+				if (current === void 0) return {
+					committed: false,
+					conflict: {
+						changeIndex,
+						reason: "not_found"
+					}
+				};
+				apiKeys.set(change.where.id, {
+					row: {
+						...current.row,
+						revoked_at_ms: change.update.revokedAtMs
+					},
+					version: current.version
+				});
+			}
+			break;
+	}
+	const relationCounts = /* @__PURE__ */ new Map();
+	const ownedPatchCounts = /* @__PURE__ */ new Map();
+	for (const patch of patches.values()) {
+		for (const id of new Set([patch.bundle_id, patch.base_bundle_id])) relationCounts.set(id, (relationCounts.get(id) ?? 0) + 1);
+		ownedPatchCounts.set(patch.bundle_id, (ownedPatchCounts.get(patch.bundle_id) ?? 0) + 1);
+	}
+	const channelReferenceCounts = /* @__PURE__ */ new Map();
+	for (const release of releases.values()) channelReferenceCounts.set(release.channel_id, (channelReferenceCounts.get(release.channel_id) ?? 0) + 1);
+	const actions = [];
+	const originalChannels = new Map(originalChannelItems.map((item) => [item.sk, item]));
+	for (const original of originalChannelItems) if (!channels.has(original.sk)) actions.push(...deleteChannelActions(store, original));
+	for (const [id, row] of channels) {
+		const original = originalChannels.get(id);
+		const referenceCount = channelReferenceCounts.get(id) ?? 0;
+		if (original === void 0) {
+			actions.push(putChannel(store, row, original, referenceCount));
+			actions.push({ Put: {
+				TableName: store.tableName,
+				Item: {
+					pk: DYNAMODB_CHANNEL_NAME_PARTITION,
+					sk: row.name,
+					channel_id: id
+				},
+				ConditionExpression: "attribute_not_exists(#pk)",
+				ExpressionAttributeNames: { "#pk": "pk" }
+			} });
+		} else {
+			if (!rowsEqual(original.row, row)) throw new DynamoDBCommitStateError(`Channel "${id}" cannot be updated`);
+			const delta = referenceCount - original.reference_count;
+			if (delta !== 0) actions.push(updateChannelReferenceCount(store, original, delta));
+		}
+	}
+	const originalBundles = new Map(originalBundleItems.map((item) => [item.sk, item]));
+	for (const original of originalBundleItems) if (!bundles.has(original.sk)) actions.push(deleteAction(store, original));
+	for (const [id, row] of bundles) {
+		const original = originalBundles.get(id);
+		const relationCount = relationCounts.get(id) ?? 0;
+		const ownedPatchCount = ownedPatchCounts.get(id) ?? 0;
+		if (original === void 0) actions.push(putNewBundle(store, row, relationCount, ownedPatchCount));
+		else if (!rowsEqual(original.row, row)) actions.push(putUpdatedBundle(store, original, row, relationCount, ownedPatchCount));
+		else {
+			const relationDelta = relationCount - original.relation_count;
+			const ownedPatchDelta = ownedPatchCount - original.owned_patch_count;
+			if (relationDelta !== 0 || ownedPatchDelta !== 0) actions.push(updateBundleRelation(store, id, relationDelta, ownedPatchDelta));
+		}
+	}
+	const originalPatches = new Map(originalPatchItems.map((item) => [item.sk, item]));
+	for (const original of originalPatchItems) if (!patches.has(original.sk)) actions.push(deletePatch(store, original));
+	for (const [id, row] of patches) {
+		const original = originalPatches.get(id);
+		if (original === void 0 || !rowsEqual(original.row, row)) actions.push(putPatch(store, row, original));
+	}
+	const originalReleases = new Map(originalReleaseItems.map((item) => [item.sk, item]));
+	for (const original of originalReleaseItems) {
+		if (releases.get(original.sk) !== void 0) continue;
+		actions.push(deleteAction(store, original));
+		actions.push({ Delete: {
+			TableName: store.tableName,
+			Key: {
+				pk: DYNAMODB_RELEASE_ID_PARTITION,
+				sk: original.sk
+			},
+			ConditionExpression: "#scopeKey = :scopeKey",
+			ExpressionAttributeNames: { "#scopeKey": "scope_key" },
+			ExpressionAttributeValues: { ":scopeKey": original.row.scope_key }
+		} });
+	}
+	for (const [id, row] of releases) {
+		const original = originalReleases.get(id);
+		if (original === void 0) {
+			actions.push({ Put: {
+				TableName: store.tableName,
+				Item: boundedDynamoDBMetadataItem(toDynamoDBReleaseItem(row)),
+				ConditionExpression: "attribute_not_exists(#pk)",
+				ExpressionAttributeNames: { "#pk": "pk" }
+			} });
+			actions.push({ Put: {
+				TableName: store.tableName,
+				Item: releaseLocatorItem(row),
+				ConditionExpression: "attribute_not_exists(#pk)",
+				ExpressionAttributeNames: { "#pk": "pk" }
+			} });
+		} else if (!rowsEqual(original.row, row)) {
+			const moved = original.row.scope_key !== row.scope_key;
+			if (moved) actions.push(deleteAction(store, original));
+			actions.push({ Put: {
+				TableName: store.tableName,
+				Item: boundedDynamoDBMetadataItem(toDynamoDBReleaseItem(row, original.version + 1)),
+				ConditionExpression: moved ? "attribute_not_exists(#pk)" : "#version = :version",
+				ExpressionAttributeNames: moved ? { "#pk": "pk" } : { "#version": "version" },
+				...moved ? {} : { ExpressionAttributeValues: { ":version": original.version } }
+			} });
+			if (moved) actions.push({ Put: {
+				TableName: store.tableName,
+				Item: releaseLocatorItem(row),
+				ConditionExpression: "#scopeKey = :scopeKey",
+				ExpressionAttributeNames: { "#scopeKey": "scope_key" },
+				ExpressionAttributeValues: { ":scopeKey": original.row.scope_key }
+			} });
+		}
+	}
+	const originalReleaseCatalogs = new Map(originalReleaseCatalogItems.map((item) => [item.sk, item]));
+	for (const [scopeKey, row] of releaseCatalogs) {
+		const original = originalReleaseCatalogs.get(scopeKey);
+		if (original === void 0 || !rowsEqual(original.row, row)) actions.push({ Put: {
+			TableName: store.tableName,
+			Item: boundedDynamoDBCatalogItem(toDynamoDBReleaseCatalogItem(row, (original?.version ?? 0) + 1)),
+			ConditionExpression: original ? "#version = :version" : "attribute_not_exists(#pk)",
+			ExpressionAttributeNames: original ? { "#version": "version" } : { "#pk": "pk" },
+			...original ? { ExpressionAttributeValues: { ":version": original.version } } : {}
+		} });
+	}
+	const changedReleaseIds = new Set([...new Set([...originalReleases.keys(), ...releases.keys()])].filter((id) => {
+		const original = originalReleases.get(id)?.row;
+		const next = releases.get(id);
+		return original === void 0 || next === void 0 || !rowsEqual(original, next);
+	}));
+	const changedCatalogScopes = new Set([...releaseCatalogs].flatMap(([scopeKey, row]) => {
+		const original = originalReleaseCatalogs.get(scopeKey)?.row;
+		return original === void 0 || !rowsEqual(original, row) ? [scopeKey] : [];
+	}));
+	for (const expectation of input.expectations ?? []) {
+		if (expectation.model === "releases" && !changedReleaseIds.has(expectation.id)) {
+			const original = originalReleases.get(expectation.id);
+			actions.push({ ConditionCheck: {
+				TableName: store.tableName,
+				Key: original === void 0 ? {
+					pk: DYNAMODB_RELEASE_ID_PARTITION,
+					sk: expectation.id
+				} : {
+					pk: original.pk,
+					sk: original.sk
+				},
+				ConditionExpression: original === void 0 ? "attribute_not_exists(#pk)" : "#version = :version",
+				ExpressionAttributeNames: original === void 0 ? { "#pk": "pk" } : { "#version": "version" },
+				...original === void 0 ? {} : { ExpressionAttributeValues: { ":version": original.version } }
+			} });
+		}
+		if (expectation.model === "releaseCatalogs" && !changedCatalogScopes.has(expectation.scopeKey)) {
+			const original = originalReleaseCatalogs.get(expectation.scopeKey);
+			actions.push({ ConditionCheck: {
+				TableName: store.tableName,
+				Key: itemKey("release_catalogs", expectation.scopeKey),
+				ConditionExpression: original === void 0 ? "attribute_not_exists(#pk)" : "#version = :version",
+				ExpressionAttributeNames: original === void 0 ? { "#pk": "pk" } : { "#version": "version" },
+				...original === void 0 ? {} : { ExpressionAttributeValues: { ":version": original.version } }
+			} });
+		}
+	}
+	const counter = metadataUpdate(store, {
+		bundles: bundles.size - originalBundles.size,
+		bundle_patches: patches.size - originalPatches.size
+	});
+	if (counter !== void 0) actions.push(counter);
+	for (const [key, row] of analytics) actions.push({ Put: {
+		TableName: store.tableName,
+		Item: boundedDynamoDBMetadataItem({
+			pk: DYNAMODB_ANALYTICS_PARTITION,
+			sk: key,
+			version: 1,
+			row
+		}),
+		ConditionExpression: "attribute_not_exists(#pk)",
+		ExpressionAttributeNames: { "#pk": "pk" }
+	} });
+	for (const [id, current] of apiKeys) {
+		const original = originalApiKeys.get(id);
+		if (original !== void 0 && rowsEqual(original.row, current.row)) continue;
+		actions.push({ Put: {
+			TableName: store.tableName,
+			Item: boundedDynamoDBMetadataItem(apiKeyItem(current.row, original === void 0 ? 1 : original.version + 1)),
+			ConditionExpression: original ? "#version = :version" : "attribute_not_exists(#pk)",
+			ExpressionAttributeNames: original ? { "#version": "version" } : { "#pk": "pk" },
+			...original ? { ExpressionAttributeValues: { ":version": original.version } } : {}
+		} });
+		if (original === void 0) actions.push({ Put: {
+			TableName: store.tableName,
+			Item: {
+				pk: DYNAMODB_API_KEY_HASH_PARTITION,
+				sk: current.row.hash,
+				api_key_id: current.row.id
+			},
+			ConditionExpression: "attribute_not_exists(#pk)",
+			ExpressionAttributeNames: { "#pk": "pk" }
+		} });
+	}
+	if (actions.length > 0) await commitDynamoDBTransaction(store, actions);
+	return { committed: true };
+};
+const isDynamoDBTransactionConflict = (error) => typeof error === "object" && error !== null && Reflect.get(error, "name") === "TransactionCanceledException";
+const createDynamoDBCommit = (store) => async (input) => {
+	try {
+		return await compileAndCommitDynamoDBChanges(store, input);
+	} catch (error) {
+		if (!isDynamoDBTransactionConflict(error)) throw error;
+		return compileAndCommitDynamoDBChanges(store, input);
+	}
+};
+const DYNAMODB_ANALYTICS_PARTITION = "bundle_events";
+const DYNAMODB_API_KEY_PARTITION = "api_keys";
+const DYNAMODB_API_KEY_HASH_PARTITION = "_hot-updater#api-key-hashes";
+const hasValidBundleEventShape = (value) => {
+	const type = field(value, "type");
+	const fromBundleId = field(value, "from_bundle_id");
+	const updateStrategy = field(value, "update_strategy");
+	return (type === "UPDATE_APPLIED" || type === "RECOVERED" || type === "RELEASE_ADOPTED") && typeof fromBundleId === "string" && (updateStrategy === "fingerprint" || updateStrategy === "appVersion") || type === "UNCHANGED" && fromBundleId === null && updateStrategy === null;
+};
+const isBundleEventRow = (value) => typeof value === "object" && value !== null && typeof field(value, "id") === "string" && typeof field(value, "install_id") === "string" && isNullableString(field(value, "from_release_id")) && isNullableString(field(value, "to_release_id")) && typeof field(value, "to_bundle_id") === "string" && (field(value, "platform") === "ios" || field(value, "platform") === "android") && typeof field(value, "received_at_ms") === "number" && hasValidBundleEventShape(value);
+const isApiKeyRow = (value) => typeof value === "object" && value !== null && typeof field(value, "id") === "string" && typeof field(value, "hash") === "string" && typeof field(value, "name") === "string" && typeof field(value, "prefix") === "string" && field(value, "role") === "client" && typeof field(value, "created_at_ms") === "number" && (field(value, "revoked_at_ms") === null || typeof field(value, "revoked_at_ms") === "number");
+const parseOfficialRowItem = (value, partition, isRow) => {
+	if (value.pk !== partition || typeof value.sk !== "string" || typeof value.version !== "number" || !isRow(value.row)) throw new DynamoDBStoredItemError();
+	return {
+		row: value.row,
+		version: value.version
+	};
+};
+const timestampSortKey = (timestampMs) => Math.trunc(timestampMs).toString().padStart(16, "0");
+const analyticsSortKey = (row) => `${timestampSortKey(row.received_at_ms)}#${row.id}`;
+const createDynamoDBAnalyticsTable = (store) => ({
+	async append(row) {
+		await store.client.send(new PutCommand({
+			TableName: store.tableName,
+			Item: boundedDynamoDBMetadataItem({
+				pk: DYNAMODB_ANALYTICS_PARTITION,
+				sk: analyticsSortKey(row),
+				version: 1,
+				row
+			}),
+			ConditionExpression: "attribute_not_exists(#pk)",
+			ExpressionAttributeNames: { "#pk": "pk" }
+		}));
+	},
+	async scan(input) {
+		if (input.limit <= 0) return [];
+		if (input.after !== void 0 && input.after.receivedAtMs >= input.beforeReceivedAtMs) return [];
+		const rows = [];
+		const afterKey = input.after === void 0 ? void 0 : `${timestampSortKey(input.after.receivedAtMs)}#${input.after.id}`;
+		let exclusiveStartKey;
+		do {
+			const page = await store.client.send(new QueryCommand({
+				TableName: store.tableName,
+				ExclusiveStartKey: exclusiveStartKey,
+				KeyConditionExpression: afterKey === void 0 ? "#pk = :pk AND #sk < :before" : "#pk = :pk AND #sk BETWEEN :after AND :before",
+				ExpressionAttributeNames: {
+					"#pk": "pk",
+					"#sk": "sk"
+				},
+				ExpressionAttributeValues: {
+					":before": `${timestampSortKey(input.beforeReceivedAtMs)}#`,
+					":pk": DYNAMODB_ANALYTICS_PARTITION,
+					...afterKey === void 0 ? {} : { ":after": afterKey }
+				},
+				Limit: input.limit - rows.length + (afterKey === void 0 ? 0 : 1),
+				ScanIndexForward: true
+			}));
+			for (const item of page.Items ?? []) {
+				if (item.sk === afterKey) continue;
+				rows.push(parseOfficialRowItem(item, DYNAMODB_ANALYTICS_PARTITION, isBundleEventRow).row);
+				if (rows.length === input.limit) return rows;
+			}
+			exclusiveStartKey = page.LastEvaluatedKey;
+		} while (exclusiveStartKey !== void 0);
+		return rows;
+	}
+});
+const apiKeyItem = (row, version) => ({
+	pk: DYNAMODB_API_KEY_PARTITION,
+	sk: row.id,
+	version,
+	row
+});
+const loadApiKey = async (store, id) => {
+	const result = await store.client.send(new GetCommand({
+		TableName: store.tableName,
+		Key: {
+			pk: DYNAMODB_API_KEY_PARTITION,
+			sk: id
+		},
+		ConsistentRead: true
+	}));
+	return result.Item === void 0 ? null : parseOfficialRowItem(result.Item, DYNAMODB_API_KEY_PARTITION, isApiKeyRow);
+};
+const createDynamoDBApiKeyTable = (store) => {
+	const findByHash = async (hash) => {
+		const lookup = await store.client.send(new GetCommand({
+			TableName: store.tableName,
+			Key: {
+				pk: DYNAMODB_API_KEY_HASH_PARTITION,
+				sk: hash
+			},
+			ConsistentRead: true
+		}));
+		const id = lookup.Item?.api_key_id;
+		if (lookup.Item === void 0) return null;
+		if (typeof id !== "string") throw new DynamoDBStoredItemError();
+		return (await loadApiKey(store, id))?.row ?? null;
+	};
+	return {
+		async create(row) {
+			if (await findByHash(row.hash) !== null) return "existing";
+			try {
+				await commitDynamoDBTransaction(store, [{ Put: {
+					TableName: store.tableName,
+					Item: boundedDynamoDBMetadataItem(apiKeyItem(row, 1)),
+					ConditionExpression: "attribute_not_exists(#pk)",
+					ExpressionAttributeNames: { "#pk": "pk" }
+				} }, { Put: {
+					TableName: store.tableName,
+					Item: {
+						pk: DYNAMODB_API_KEY_HASH_PARTITION,
+						sk: row.hash,
+						api_key_id: row.id
+					},
+					ConditionExpression: "attribute_not_exists(#pk)",
+					ExpressionAttributeNames: { "#pk": "pk" }
+				} }]);
+				return "created";
+			} catch (error) {
+				if (await findByHash(row.hash) !== null) return "existing";
+				throw error;
+			}
+		},
+		findByHash,
+		async list() {
+			const rows = [];
+			let exclusiveStartKey;
+			do {
+				const page = await store.client.send(new QueryCommand({
+					TableName: store.tableName,
+					ExclusiveStartKey: exclusiveStartKey,
+					KeyConditionExpression: "#pk = :pk",
+					ExpressionAttributeNames: { "#pk": "pk" },
+					ExpressionAttributeValues: { ":pk": DYNAMODB_API_KEY_PARTITION },
+					ConsistentRead: true
+				}));
+				rows.push(...(page.Items ?? []).map((item) => parseOfficialRowItem(item, DYNAMODB_API_KEY_PARTITION, isApiKeyRow).row));
+				exclusiveStartKey = page.LastEvaluatedKey;
+			} while (exclusiveStartKey !== void 0);
+			return rows.sort((left, right) => right.created_at_ms - left.created_at_ms || left.id.localeCompare(right.id));
+		},
+		async revoke({ id, revokedAtMs }) {
+			const current = await loadApiKey(store, id);
+			if (current === null) return null;
+			const row = {
+				...current.row,
+				revoked_at_ms: revokedAtMs
+			};
+			await store.client.send(new PutCommand({
+				TableName: store.tableName,
+				Item: boundedDynamoDBMetadataItem(apiKeyItem(row, current.version + 1)),
+				ConditionExpression: "#version = :currentVersion",
+				ExpressionAttributeNames: { "#version": "version" },
+				ExpressionAttributeValues: { ":currentVersion": current.version }
+			}));
+			return row;
+		}
+	};
+};
+const DYNAMODB_UPDATE_INDEX_NAME = "hot-updater-update-index";
+const dynamoDB = (config) => {
+	const { apiBasePath = "/release-catalogs", cloudfrontDistributionId, shouldWaitForInvalidation = false, tableName, ...clientConfig } = config;
+	const client = DynamoDBDocumentClient.from(new DynamoDBClient(clientConfig), { marshallOptions: { removeUndefinedValues: true } });
+	const cloudFront = cloudfrontDistributionId ? new CloudFrontClient({
+		credentials: clientConfig.credentials,
+		region: clientConfig.region
+	}) : null;
+	const store = {
+		client,
+		tableName
+	};
+	const crud = createDynamoDBCrud(store, DYNAMODB_UPDATE_INDEX_NAME);
+	const invalidateUpdateRoutes = async () => {
+		if (!cloudFront || !cloudfrontDistributionId) return;
+		try {
+			await invalidateCloudFront(cloudFront, cloudfrontDistributionId, [`${apiBasePath.replace(/\/+$/, "")}/*`], { shouldWait: shouldWaitForInvalidation });
+		} catch (error) {
+			console.warn("[hot-updater/aws] CloudFront invalidation failed; continuing without cache invalidation.", {
+				distributionId: cloudfrontDistributionId,
+				error: error instanceof Error ? error.message : "Unknown error"
+			});
+		}
+	};
+	const adapter = createDatabasePluginAdapter("dynamoDB", {
+		...crud,
+		commit: createDynamoDBCommit(store),
+		dispose: async () => {
+			client.destroy();
+			cloudFront?.destroy();
+		}
+	});
+	return createDatabasePlugin({
+		name: "dynamoDB",
+		models: {
+			...adapter.models,
+			bundlePatches: createDynamoDBBundlePatchTable(store, DYNAMODB_UPDATE_INDEX_NAME),
+			analytics: createDynamoDBAnalyticsTable(store),
+			apiKeys: createDynamoDBApiKeyTable(store)
+		},
+		async commit(input) {
+			const result = await adapter.commit(input);
+			if (result.committed && input.changes.some(({ model }) => model === "bundles" || model === "bundlePatches")) await invalidateUpdateRoutes();
+			return result;
+		},
+		dispose: adapter.dispose
+	});
+};
 //#endregion
 //#region src/runtimeAwsConfig.ts
 const truthyValues = new Set([
@@ -1425,473 +1816,170 @@ const applySsmRuntimeAwsConfig = (config) => {
 	};
 };
 //#endregion
-//#region src/utils/streamToString.ts
-const streamToString = (stream) => {
-	return new Promise((resolve, reject) => {
-		const chunks = [];
-		stream.on("data", (chunk) => chunks.push(chunk));
-		stream.on("error", reject);
-		stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
-	});
-};
-//#endregion
-//#region src/s3Database.ts
-const DEFAULT_INVALIDATION_POLL_INTERVAL_MS = 2e3;
-const DEFAULT_INVALIDATION_TIMEOUT_MS = 300 * 1e3;
-const S3_LIST_OBJECTS_CONCURRENCY = 4;
-const S3_DIRECTORY_DELIMITER = "/";
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const getS3ErrorProperty = (error, key) => {
-	if (typeof error !== "object" || error === null) return;
-	const value = error[key];
-	return typeof value === "string" ? value : void 0;
-};
-const isArchivedS3ObjectError = (error) => {
-	if (!(error instanceof Error)) return false;
-	return error.name === "InvalidObjectState" || getS3ErrorProperty(error, "Code") === "InvalidObjectState";
-};
-const createArchivedS3ObjectError = ({ bucket, key, error }) => {
-	const storageClass = getS3ErrorProperty(error, "StorageClass") ?? "archived storage";
-	const nextError = new Error(`S3 object "${key}" in bucket "${bucket}" is archived (${storageClass}) and cannot be read. Restore the object in S3 or exclude Hot Updater metadata from lifecycle archival: "**/target-app-versions.json" and "**/update.json".`, { cause: error });
-	nextError.name = "S3ArchivedObjectError";
-	return nextError;
-};
-function normalizeBasePath(basePath) {
-	return basePath?.replace(/^\/+|\/+$/g, "") ?? "";
-}
-function createDatabaseKeyBuilder(basePath) {
-	const normalizedBasePath = normalizeBasePath(basePath);
-	const toStorageKey = (key) => [normalizedBasePath, key].filter(Boolean).join("/");
-	const fromStorageKey = (key) => {
-		if (!normalizedBasePath) return key;
-		const prefix = `${normalizedBasePath}/`;
-		return key.startsWith(prefix) ? key.slice(prefix.length) : key;
-	};
-	return {
-		fromStorageKey,
-		toStorageKey
-	};
-}
-function normalizeDirectoryPrefix(prefix) {
-	if (!prefix) return "";
-	return prefix.endsWith(S3_DIRECTORY_DELIMITER) ? prefix : `${prefix}${S3_DIRECTORY_DELIMITER}`;
-}
-function getRelativeDirectoryPrefix(prefix, rootPrefix) {
-	if (!rootPrefix) return prefix;
-	return prefix.startsWith(rootPrefix) ? prefix.slice(rootPrefix.length) : prefix;
-}
-function getDirectoryDepth(prefix, rootPrefix) {
-	return getRelativeDirectoryPrefix(prefix, rootPrefix).split(S3_DIRECTORY_DELIMITER).filter(Boolean).length;
-}
-function getLastDirectorySegment(prefix) {
-	return prefix.split(S3_DIRECTORY_DELIMITER).filter(Boolean).at(-1);
-}
-function isPlatformDirectoryPrefix(prefix) {
-	const lastSegment = getLastDirectorySegment(prefix);
-	return lastSegment === "ios" || lastSegment === "android";
-}
-function isLegacyBundleStorageDirectoryPrefix(prefix) {
-	const lastSegment = getLastDirectorySegment(prefix);
-	return lastSegment !== void 0 && /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(lastSegment);
-}
-function isUpdateJsonKey(key) {
-	return key.endsWith(`${S3_DIRECTORY_DELIMITER}update.json`);
-}
-function isUuidChannelUpdateJsonKey(key, rootPrefix, uuidChannels) {
-	const [channel, platform, target, fileName, ...rest] = getRelativeDirectoryPrefix(key, rootPrefix).split(S3_DIRECTORY_DELIMITER);
-	return channel !== void 0 && uuidChannels.has(channel) && (platform === "ios" || platform === "android") && target !== void 0 && target.length > 0 && fileName === "update.json" && rest.length === 0;
-}
-async function mapWithConcurrency(items, concurrency, mapper) {
-	const results = [];
-	let nextIndex = 0;
-	const workerCount = Math.min(concurrency, items.length);
-	await Promise.all(Array.from({ length: workerCount }, async () => {
-		while (nextIndex < items.length) {
-			const index = nextIndex;
-			nextIndex += 1;
-			const item = items[index];
-			if (item === void 0) break;
-			results[index] = await mapper(item, index);
-		}
-	}));
-	return results.filter((result) => result !== void 0);
-}
-/**
-* Loads JSON data from S3.
-* Returns null if NoSuchKey error occurs.
-*/
-async function loadJsonFromS3(client, bucket, key) {
-	try {
-		const { Body } = await client.send(new GetObjectCommand({
-			Bucket: bucket,
-			Key: key
-		}));
-		if (!Body) return null;
-		const bodyContents = await streamToString(Body);
-		return JSON.parse(bodyContents);
-	} catch (e) {
-		if (e instanceof NoSuchKey) return null;
-		if (isArchivedS3ObjectError(e)) throw createArchivedS3ObjectError({
-			bucket,
-			key,
-			error: e
-		});
-		throw e;
-	}
-}
-/**
-* Converts data to JSON string and uploads to S3.
-*/
-async function uploadJsonToS3(client, bucket, key, data) {
-	const Body = JSON.stringify(data);
-	const ContentType = src_default.getType(key) ?? "application/json";
-	await client.send(new PutObjectCommand({
-		Bucket: bucket,
-		Key: key,
-		Body,
-		ContentType,
-		CacheControl: "max-age=31536000"
-	}));
-}
-async function listObjectsInS3(client, bucketName, prefix, rootPrefix = "") {
-	const normalizedRootPrefix = normalizeDirectoryPrefix(rootPrefix);
-	const listPrefix = async (currentPrefix, delimiter = S3_DIRECTORY_DELIMITER) => {
-		let continuationToken;
-		const keys = [];
-		const commonPrefixes = /* @__PURE__ */ new Set();
-		do {
-			const response = await client.send(new ListObjectsV2Command({
-				Bucket: bucketName,
-				Prefix: currentPrefix,
-				Delimiter: delimiter ?? void 0,
-				ContinuationToken: continuationToken
-			}));
-			const found = (response.Contents ?? []).map((item) => item.Key).filter((key) => !!key);
-			keys.push(...found);
-			for (const commonPrefix of response.CommonPrefixes ?? []) if (commonPrefix.Prefix) commonPrefixes.add(commonPrefix.Prefix);
-			continuationToken = response.NextContinuationToken;
-		} while (continuationToken);
-		return {
-			commonPrefixes: Array.from(commonPrefixes),
-			keys
-		};
-	};
-	const collectUpdateJsonKeys = async (currentPrefix) => {
-		const { commonPrefixes, keys } = await listPrefix(currentPrefix);
-		const depth = getDirectoryDepth(currentPrefix, normalizedRootPrefix);
-		if (depth >= 2) return [...keys.filter(isUpdateJsonKey), ...commonPrefixes.map((commonPrefix) => `${commonPrefix}update.json`)];
-		const uuidPrefixes = depth === 0 ? commonPrefixes.filter(isLegacyBundleStorageDirectoryPrefix) : [];
-		const uuidPrefixSet = new Set(uuidPrefixes);
-		const nestedKeys = await mapWithConcurrency(depth === 0 ? commonPrefixes.filter((commonPrefix) => !uuidPrefixSet.has(commonPrefix)) : depth === 1 ? commonPrefixes.filter(isPlatformDirectoryPrefix) : commonPrefixes, S3_LIST_OBJECTS_CONCURRENCY, (nextPrefix) => collectUpdateJsonKeys(nextPrefix));
-		const uuidChannels = new Set(uuidPrefixes.map(getLastDirectorySegment).filter((segment) => !!segment));
-		const uuidChannelKeys = (await mapWithConcurrency(Array.from(new Set(Array.from(uuidChannels, (channel) => `${normalizedRootPrefix}${channel[0]}`))), S3_LIST_OBJECTS_CONCURRENCY, async (scanPrefix) => (await listPrefix(scanPrefix, null)).keys)).flat().filter((key) => isUuidChannelUpdateJsonKey(key, normalizedRootPrefix, uuidChannels));
-		return [...nestedKeys.flat(), ...uuidChannelKeys];
-	};
-	const normalizedPrefix = normalizeDirectoryPrefix(prefix);
-	return Array.from(new Set(await collectUpdateJsonKeys(normalizedPrefix)));
-}
-async function deleteObjectInS3(client, bucketName, key) {
-	await client.send(new DeleteObjectCommand({
-		Bucket: bucketName,
-		Key: key
-	}));
-}
-/**
-* Invalidates CloudFront cache for the given paths.
-*/
-async function invalidateCloudFront(client, distributionId, paths, options) {
-	if (paths.length === 0) return;
-	const timestamp = Date.now();
-	try {
-		const response = await client.send(new CreateInvalidationCommand({
-			DistributionId: distributionId,
-			InvalidationBatch: {
-				CallerReference: `invalidation-${timestamp}`,
-				Paths: {
-					Quantity: paths.length,
-					Items: paths
-				}
-			}
-		}));
-		if (!options?.shouldWaitForInvalidation) return;
-		const invalidationId = response.Invalidation?.Id;
-		if (!invalidationId) throw new Error("CloudFront invalidation response is missing Invalidation.Id");
-		if (response.Invalidation?.Status === "Completed") return;
-		const timeoutMs = DEFAULT_INVALIDATION_TIMEOUT_MS;
-		const pollIntervalMs = DEFAULT_INVALIDATION_POLL_INTERVAL_MS;
-		const deadline = Date.now() + timeoutMs;
-		while (Date.now() < deadline) {
-			await sleep(pollIntervalMs);
-			if ((await client.send(new GetInvalidationCommand({
-				DistributionId: distributionId,
-				Id: invalidationId
-			}))).Invalidation?.Status === "Completed") return;
-		}
-		throw new Error(`Timed out waiting for CloudFront invalidation ${invalidationId} to complete after ${timeoutMs}ms`);
-	} catch (error) {
-		if (options?.shouldWaitForInvalidation) throw error;
-		const message = error instanceof Error ? error.message : "Unknown invalidation error";
-		console.warn(`[hot-updater/aws] CloudFront invalidation failed for distribution ${distributionId}; continuing without cache invalidation.`, {
-			error: message,
-			paths
-		});
-	}
-}
-const s3Database = createBlobDatabasePlugin({
-	name: "s3Database",
-	factory: (config) => {
-		const { basePath, bucketName, cloudfrontDistributionId, apiBasePath = "/api/check-update", shouldWaitForInvalidation = false, ...s3Config } = config;
-		const client = new S3Client(applyS3RuntimeAwsConfig(s3Config));
-		const { fromStorageKey, toStorageKey } = createDatabaseKeyBuilder(basePath);
-		const rootPrefix = toStorageKey("");
-		const cloudfrontClient = cloudfrontDistributionId ? new CloudFrontClient({
-			credentials: s3Config.credentials,
-			region: s3Config.region
-		}) : void 0;
-		return {
-			apiBasePath,
-			listObjects: (prefix) => listObjectsInS3(client, bucketName, toStorageKey(prefix), rootPrefix).then((keys) => keys.map(fromStorageKey)),
-			loadObject: (key) => loadJsonFromS3(client, bucketName, toStorageKey(key)),
-			uploadObject: (key, data) => uploadJsonToS3(client, bucketName, toStorageKey(key), data),
-			deleteObject: (key) => deleteObjectInS3(client, bucketName, toStorageKey(key)),
-			shouldSkipLoadObjectError: (error) => error instanceof Error && error.name === "S3ArchivedObjectError",
-			invalidatePaths: (pathsToInvalidate) => {
-				if (cloudfrontClient && cloudfrontDistributionId && pathsToInvalidate.length > 0) return invalidateCloudFront(cloudfrontClient, cloudfrontDistributionId, pathsToInvalidate, { shouldWaitForInvalidation });
-				return Promise.resolve();
-			}
-		};
-	}
-});
-//#endregion
-//#region src/s3Storage.ts
-const s3Storage = createUniversalStoragePlugin({
-	name: "s3Storage",
-	supportedProtocol: "s3",
-	factory: (config) => {
-		const { bucketName, ...s3Config } = config;
-		const client = new S3Client(applyS3RuntimeAwsConfig(s3Config));
-		const normalizedBasePath = config.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
-		const getStorageKey = createStorageKeyBuilder(normalizedBasePath);
-		const getListPrefix = (prefix = "") => {
-			const value = [normalizedBasePath, prefix.replace(/^\/+|\/+$/g, "")].filter(Boolean).join("/");
-			return value ? `${value}/` : "";
-		};
-		const getRelativeKey = (key) => {
-			if (!normalizedBasePath) return key;
-			const basePrefix = `${normalizedBasePath}/`;
-			return key.startsWith(basePrefix) ? key.slice(basePrefix.length) : key;
-		};
-		return {
-			node: {
-				async listObjects(prefix) {
-					const objects = [];
-					let continuationToken;
-					do {
-						const response = await client.send(new ListObjectsV2Command({
-							Bucket: bucketName,
-							ContinuationToken: continuationToken,
-							Prefix: getListPrefix(prefix)
-						}));
-						for (const object of response.Contents ?? []) {
-							if (!object.Key) continue;
-							objects.push({
-								key: getRelativeKey(object.Key),
-								lastModifiedAt: object.LastModified,
-								size: object.Size ?? 0,
-								storageUri: `s3://${bucketName}/${object.Key}`
-							});
-						}
-						continuationToken = response.NextContinuationToken;
-					} while (continuationToken);
-					return objects;
-				},
-				async deleteObjects(relativeKeys) {
-					const keys = relativeKeys.map((key) => getStorageKey(key));
-					for (let offset = 0; offset < keys.length; offset += 1e3) {
-						const batch = keys.slice(offset, offset + 1e3);
-						if (batch.length === 0) continue;
-						const response = await client.send(new DeleteObjectsCommand({
-							Bucket: bucketName,
-							Delete: {
-								Objects: batch.map((Key) => ({ Key })),
-								Quiet: true
-							}
-						}));
-						if (response.Errors && response.Errors.length > 0) throw new Error(`Failed to delete ${response.Errors.length} S3 object(s).`);
-					}
-				},
-				async delete(storageUri) {
-					const { bucket, key } = parseStorageUri(storageUri, "s3");
-					if (bucket !== bucketName) throw new Error(`Bucket name mismatch: expected "${bucketName}", but found "${bucket}".`);
-					const listCommand = new ListObjectsV2Command({
-						Bucket: bucketName,
-						Prefix: key
-					});
-					const listResponse = await client.send(listCommand);
-					if (listResponse.Contents && listResponse.Contents.length > 0) {
-						const deleteCommand = new DeleteObjectsCommand({
-							Bucket: bucketName,
-							Delete: {
-								Objects: listResponse.Contents.map((obj) => ({ Key: obj.Key })),
-								Quiet: true
-							}
-						});
-						await client.send(deleteCommand);
-						return;
-					}
-					throw new Error("Bundle Not Found");
-				},
-				async upload(key, filePath) {
-					const Body = await fs.readFile(filePath);
-					const ContentType = getContentType(filePath);
-					const Key = getStorageKey(key, path.basename(filePath));
-					const response = await new Upload({
-						client,
-						params: {
-							ContentType,
-							Bucket: bucketName,
-							Key,
-							Body,
-							CacheControl: "max-age=31536000"
-						}
-					}).done();
-					if (!response.Bucket || !response.Key) throw new Error("Upload Failed");
-					return { storageUri: `s3://${bucketName}/${Key}` };
-				},
-				async exists(storageUri) {
-					const { bucket, key } = parseStorageUri(storageUri, "s3");
-					if (bucket !== bucketName) throw new Error(`Bucket name mismatch: expected "${bucketName}", but found "${bucket}".`);
-					try {
-						await client.send(new HeadObjectCommand({
-							Bucket: bucketName,
-							Key: key
-						}));
-						return true;
-					} catch (error) {
-						if (error instanceof Error && (error.name === "NotFound" || error.name === "NoSuchKey")) return false;
-						throw error;
-					}
-				},
-				async downloadFile(storageUri, filePath) {
-					const { bucket, key } = parseStorageUri(storageUri, "s3");
-					if (bucket !== bucketName) throw new Error(`Bucket name mismatch: expected "${bucketName}", but found "${bucket}".`);
-					const response = await client.send(new GetObjectCommand({
-						Bucket: bucket,
-						Key: key
-					}));
-					if (!response.Body) throw new Error("S3 object body is empty");
-					await fs.mkdir(path.dirname(filePath), { recursive: true });
-					await fs.writeFile(filePath, await response.Body.transformToByteArray());
-				}
-			},
-			runtime: {
-				async readText(storageUri) {
-					const { bucket, key } = parseStorageUri(storageUri, "s3");
-					if (bucket !== bucketName) throw new Error(`Bucket name mismatch: expected "${bucketName}", but found "${bucket}".`);
-					try {
-						const response = await client.send(new GetObjectCommand({
-							Bucket: bucket,
-							Key: key
-						}));
-						if (!response.Body) return null;
-						return response.Body.transformToString();
-					} catch (error) {
-						if (error instanceof Error && error.name === "NoSuchKey") return null;
-						throw error;
-					}
-				},
-				async getDownloadUrl(storageUri) {
-					const { bucket, key } = parseStorageUri(storageUri, "s3");
-					if (!bucket || !key) throw new Error("Invalid S3 storage URI: missing bucket or key");
-					try {
-						const signedUrl = await getSignedUrl(client, new GetObjectCommand({
-							Bucket: bucket,
-							Key: key
-						}), { expiresIn: 3600 });
-						if (!signedUrl) throw new Error("Failed to presign S3 URL");
-						return { fileUrl: signedUrl };
-					} catch (e) {
-						throw new Error(e instanceof Error ? `Failed to presign S3 URL: ${e.message}` : "Failed to presign S3 URL");
-					}
-				}
-			}
-		};
-	}
-});
-//#endregion
-//#region src/withCloudFrontSignedUrl.ts
+//#region src/cloudFrontDownloadUrl.ts
 const ONE_YEAR_IN_SECONDS = 3600 * 24 * 365;
 const privateKeyCache = /* @__PURE__ */ new Map();
 const getPrivateKeyFromSsm = async (region, parameterName) => {
-	if (!region) throw new Error(`Invalid AWS region format: ${region}. Expected format like 'us-east-1' or 'ap-southeast-1'`);
-	const parameter = (await new SSM(applySsmRuntimeAwsConfig({ region })).getParameter({
+	const value = (await new SSM(applySsmRuntimeAwsConfig({ region })).getParameter({
 		Name: parameterName,
 		WithDecryption: true
-	})).Parameter;
-	if (!parameter) throw new Error(`Failed to retrieve private key from SSM parameter: ${parameterName}`);
-	const parameterValue = parameter.Value;
-	if (!parameterValue) throw new Error(`Failed to retrieve private key from SSM parameter: ${parameterName}`);
-	let keyPair;
-	try {
-		keyPair = JSON.parse(parameterValue);
-	} catch (error) {
-		throw new Error(`Invalid JSON format in SSM parameter: ${parameterName}. ${error instanceof Error ? error.message : String(error)}`);
-	}
-	const privateKey = keyPair.privateKey;
-	if (!privateKey || typeof privateKey !== "string") throw new Error(`Invalid private key format in SSM parameter: ${parameterName}`);
+	})).Parameter?.Value;
+	if (!value) throw new Error(`CloudFront private key is missing: ${parameterName}`);
+	const privateKey = JSON.parse(value).privateKey;
+	if (typeof privateKey !== "string" || privateKey.length === 0) throw new Error(`Invalid CloudFront private key: ${parameterName}`);
 	return privateKey;
 };
 const resolvePrivateKey = (config) => {
-	if ("getPrivateKey" in config && typeof config.getPrivateKey === "function") return config.getPrivateKey();
+	if (config.getPrivateKey) return config.getPrivateKey();
 	const cacheKey = `${config.ssmRegion}:${config.ssmParameterName}`;
-	const cachedPrivateKey = privateKeyCache.get(cacheKey);
-	if (cachedPrivateKey) return cachedPrivateKey;
-	const privateKeyPromise = getPrivateKeyFromSsm(config.ssmRegion, config.ssmParameterName).catch((error) => {
+	const cached = privateKeyCache.get(cacheKey);
+	if (cached) return cached;
+	const pending = getPrivateKeyFromSsm(config.ssmRegion, config.ssmParameterName).catch((error) => {
 		privateKeyCache.delete(cacheKey);
 		throw error;
 	});
-	privateKeyCache.set(cacheKey, privateKeyPromise);
-	return privateKeyPromise;
+	privateKeyCache.set(cacheKey, pending);
+	return pending;
 };
-const resolvePublicBaseUrl = async (config, context) => {
-	const publicBaseUrl = typeof config.publicBaseUrl === "function" ? await config.publicBaseUrl(context) : config.publicBaseUrl;
-	if (!publicBaseUrl) throw new Error("CloudFront publicBaseUrl resolver returned an empty URL");
-	return publicBaseUrl;
+const cloudFrontDownloadUrl = (config) => async ({ storageUri }) => {
+	const storageUrl = new URL(storageUri);
+	if (storageUrl.protocol !== "s3:") throw new Error("CloudFront download URLs require an s3 storage URI.");
+	const url = new URL(config.publicBaseUrl);
+	url.pathname = storageUrl.pathname;
+	url.search = "";
+	return { url: getSignedUrl({
+		url: url.toString(),
+		keyPairId: config.keyPairId,
+		privateKey: await resolvePrivateKey(config),
+		dateLessThan: new Date(Date.now() + (config.expiresSeconds ?? ONE_YEAR_IN_SECONDS) * 1e3).toISOString()
+	}) };
 };
-const withCloudFrontSignedUrl = (storageFactory, config) => {
-	return () => {
-		const baseStorage = storageFactory();
-		return {
-			...baseStorage,
-			name: `${baseStorage.name}WithCloudFrontSignedUrl`,
-			profiles: {
-				...baseStorage.profiles,
-				runtime: {
-					...baseStorage.profiles.runtime,
-					async getDownloadUrl(storageUri, context) {
-						const storageUrl = new URL(storageUri);
-						if (storageUrl.protocol !== "s3:") return baseStorage.profiles.runtime.getDownloadUrl(storageUri, context);
-						const [privateKey, publicBaseUrl] = await Promise.all([resolvePrivateKey(config), resolvePublicBaseUrl(config, context)]);
-						const url = new URL(publicBaseUrl);
-						url.pathname = storageUrl.pathname;
-						url.search = "";
-						return { fileUrl: getSignedUrl$1({
-							url: url.toString(),
-							keyPairId: config.keyPairId,
-							privateKey,
-							dateLessThan: new Date(Date.now() + (config.expiresSeconds ?? ONE_YEAR_IN_SECONDS) * 1e3).toISOString()
-						}) };
+//#endregion
+//#region src/s3Storage.ts
+const isObjectNotFoundError = (error) => error instanceof Error && (error.name === "NotFound" || error.name === "NoSuchKey");
+function s3Storage(config) {
+	const { bucketName, basePath, downloadUrlSigningKey, getDownloadUrl: configuredGetDownloadUrl, ...s3Config } = config;
+	const getDownloadUrl = configuredGetDownloadUrl ?? (downloadUrlSigningKey ? createStorageDownloadUrl(downloadUrlSigningKey) : void 0);
+	const client = new S3Client(applyS3RuntimeAwsConfig(s3Config));
+	const normalizedBasePath = basePath?.replace(/^\/+|\/+$/g, "") ?? "";
+	const getStorageKey = createStorageKeyBuilder(normalizedBasePath);
+	const getListPrefix = (prefix = "") => {
+		const value = [normalizedBasePath, prefix.replace(/^\/+|\/+$/g, "")].filter(Boolean).join("/");
+		return value ? `${value}/` : "";
+	};
+	const getRelativeKey = (key) => {
+		if (!normalizedBasePath) return key;
+		const basePrefix = `${normalizedBasePath}/`;
+		return key.startsWith(basePrefix) ? key.slice(basePrefix.length) : key;
+	};
+	const parseAndValidate = (storageUri) => {
+		const parsed = parseStorageUri(storageUri, "s3");
+		if (parsed.bucket !== bucketName) throw new Error(`Bucket name mismatch: expected "${bucketName}", but found "${parsed.bucket}".`);
+		return parsed;
+	};
+	return createStoragePlugin({
+		name: "s3Storage",
+		protocol: "s3",
+		async listObjects(prefix) {
+			const objects = [];
+			let continuationToken;
+			do {
+				const response = await client.send(new ListObjectsV2Command({
+					Bucket: bucketName,
+					ContinuationToken: continuationToken,
+					Prefix: getListPrefix(prefix)
+				}));
+				for (const object of response.Contents ?? []) {
+					if (!object.Key) continue;
+					objects.push({
+						key: getRelativeKey(object.Key),
+						lastModifiedAt: object.LastModified,
+						size: object.Size ?? 0,
+						storageUri: `s3://${bucketName}/${object.Key}`
+					});
+				}
+				continuationToken = response.NextContinuationToken;
+			} while (continuationToken);
+			return objects;
+		},
+		async deleteObjects(relativeKeys) {
+			const keys = relativeKeys.map((key) => getStorageKey(key));
+			for (let offset = 0; offset < keys.length; offset += 1e3) {
+				const batch = keys.slice(offset, offset + 1e3);
+				if (batch.length === 0) continue;
+				const response = await client.send(new DeleteObjectsCommand({
+					Bucket: bucketName,
+					Delete: {
+						Objects: batch.map((Key) => ({ Key })),
+						Quiet: true
 					}
+				}));
+				if (response.Errors && response.Errors.length > 0) throw new Error(`Failed to delete ${response.Errors.length} S3 object(s).`);
+			}
+		},
+		async put({ key, body, contentLength, contentType }) {
+			const storageKey = getStorageKey(key);
+			const response = await new Upload({
+				client,
+				params: {
+					Body: body,
+					Bucket: bucketName,
+					CacheControl: "max-age=31536000",
+					...contentLength === void 0 ? {} : { ContentLength: contentLength },
+					ContentType: contentType,
+					Key: storageKey
 				}
+			}).done();
+			if (!response.Bucket || !response.Key) throw new Error("Upload failed");
+			return { storageUri: createStorageUri({
+				bucket: bucketName,
+				key: storageKey,
+				protocol: "s3"
+			}) };
+		},
+		async get({ storageUri }) {
+			const { key } = parseAndValidate(storageUri);
+			try {
+				const response = await client.send(new GetObjectCommand({
+					Bucket: bucketName,
+					Key: key
+				}));
+				if (!response.Body) return { response: null };
+				const headers = new Headers();
+				if (response.ContentType) headers.set("content-type", response.ContentType);
+				if (response.ContentLength !== void 0) headers.set("content-length", String(response.ContentLength));
+				return { response: new Response(response.Body.transformToWebStream(), { headers }) };
+			} catch (error) {
+				if (isObjectNotFoundError(error)) return { response: null };
+				throw error;
 			}
-		};
-	};
-};
-//#endregion
-//#region src/s3LambdaEdgeStorage.ts
-const awsLambdaEdgeStorage = (config, hooks) => {
-	return withCloudFrontSignedUrl(s3Storage(config, hooks), config);
-};
-const s3LambdaEdgeStorage = awsLambdaEdgeStorage;
+		},
+		...getDownloadUrl ? { async getDownloadUrl(input) {
+			parseAndValidate(input.storageUri);
+			return getDownloadUrl(input);
+		} } : {},
+		async exists({ storageUri }) {
+			const { key } = parseAndValidate(storageUri);
+			try {
+				await client.send(new HeadObjectCommand({
+					Bucket: bucketName,
+					Key: key
+				}));
+				return { exists: true };
+			} catch (error) {
+				if (isObjectNotFoundError(error)) return { exists: false };
+				throw error;
+			}
+		},
+		async delete({ storageUri }) {
+			const { key } = parseAndValidate(storageUri);
+			await client.send(new DeleteObjectCommand({
+				Bucket: bucketName,
+				Key: key
+			}));
+			return { deleted: true };
+		}
+	});
+}
 //#endregion
-export { awsLambdaEdgeStorage, s3Database, s3LambdaEdgeStorage, s3Storage, withCloudFrontSignedUrl };
+export { DYNAMODB_UPDATE_INDEX_NAME, cloudFrontDownloadUrl, dynamoDB, s3Storage };