From: stephan Date: Fri, 6 Mar 2026 22:21:06 +0000 (+0000) Subject: Get "opfs" and "opfs-wl" properly split. Speedtest1 and the concurrency tester are... X-Git-Tag: major-release~100^2~9 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=2251f0c4cc7823e338902c4c83675c4cfdc2ceb4;p=thirdparty%2Fsqlite.git Get "opfs" and "opfs-wl" properly split. Speedtest1 and the concurrency tester are happy with opfs-wl but it is not yet plugged in to tester1. FossilOrigin-Name: 12dcd5425967b6306f3e3178babeac130962edb78e6298d545a429a1a20457cc --- diff --git a/ext/wasm/api/opfs-common-shared.c-pp.js b/ext/wasm/api/opfs-common-shared.c-pp.js index 734b211c09..0bbaed930e 100644 --- a/ext/wasm/api/opfs-common-shared.c-pp.js +++ b/ext/wasm/api/opfs-common-shared.c-pp.js @@ -423,9 +423,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ /** Must be called by the VFS's main installation routine and passed the options object that function receives and a reference to that - function itself (which is assumed to have a defaultProxyUri - property set on it. See sqlite3-vfs-opfs{,-wl}.c-pp.js for - examples. + function itself (we don't need this anymore). It throws if OPFS is not available. @@ -446,9 +444,9 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ - Call opfvs.bindVfs() */ - opfsUtil.initOptions = function callee(options, callee){ + opfsUtil.initOptions = function callee(vfsName, options){ const urlParams = new URL(globalThis.location.href).searchParams; - if(urlParams.has('opfs-disable')){ + if(urlParams.has(vfsName+'-disable')){ //sqlite3.config.warn('Explicitly not installing "opfs" VFS due to opfs-disable flag.'); return; } @@ -458,10 +456,23 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ return; } options = util.nu(options); + options.vfsName = vfsName; options.verbose ??= urlParams.has('opfs-verbose') ? (+urlParams.get('opfs-verbose') || 2) : 1; options.sanityChecks ??= urlParams.has('opfs-sanity-check'); - options.proxyUri ??= callee.defaultProxyUri; + + if( true ){ + /* Doing this from one scope up does not work */ + opfsUtil.proxyUri = "sqlite3-opfs-async-proxy.js"; + if( sqlite3.scriptInfo?.sqlite3Dir ){ + opfsUtil.proxyUri = ( + sqlite3.scriptInfo.sqlite3Dir + opfsUtil.proxyUri + ); + } + //sqlite3.config.error("proxyUri =",opfsUtil.proxyUri, sqlite3.scriptInfo); + } + + options.proxyUri ??= opfsUtil.proxyUri; if('function' === typeof options.proxyUri){ options.proxyUri = options.proxyUri(); } @@ -474,7 +485,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ options.workerId ??= (Math.random() * 10000000) | 0; } //sqlite3.config.warn("opfsUtil options =",JSON.stringify(options), 'urlParams =', urlParams); - return options; + return opfsUtil.options = options; }; /** @@ -498,8 +509,9 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ only cloneable or sharable objects. After the worker's "inited" message arrives, other types of data may be added to it. */ - opfsUtil.createVfsState = function(vfsName, options){ + opfsUtil.createVfsState = function(){ const state = util.nu(); + const options = opfsUtil.options; state.verbose = options.verbose; const loggers = [ @@ -507,8 +519,10 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ sqlite3.config.warn, sqlite3.config.log ]; + const vfsName = options.vfsName + || toss("Maintenance required: missing VFS name"); const logImpl = (level,...args)=>{ - if(state.verbose>level) loggers[level]("OPFS syncer:",...args); + if(state.verbose>level) loggers[level](vfsName+":",...args); }; const log = (...args)=>logImpl(2, ...args), warn = (...args)=>logImpl(1, ...args), @@ -544,7 +558,6 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ */ ); - const isWebLocker = 'opfs-wl'===vfsName; opfsVfs.metrics = util.nu({ counters: util.nu(), dump: function(){ @@ -588,7 +601,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ of this value is also used for determining how long to wait on lock contention to free up. */ - state.asyncIdleWaitTime = isWebLocker ? 250 : 150; + state.asyncIdleWaitTime = 150; /** Whether the async counterpart should log exceptions to @@ -771,7 +784,7 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ (see sqlite3-opfs-async-proxy.c-pp.js). */ const opRun = opfsVfs.opRun = (op,...args)=>{ - const opNdx = state.opIds[op] || toss("Invalid op ID:",op); + const opNdx = state.opIds[op] || toss(opfsVfs.vfsName+": Invalid op ID:",op); state.s11n.serialize(...args); Atomics.store(state.sabOPView, state.opIds.rc, -1); Atomics.store(state.sabOPView, state.opIds.whichOp, opNdx); @@ -1088,12 +1101,14 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ promiseWasRejected = false; return promiseResolve_(sqlite3); }; + const options = opfsUtil.options; let proxyUri = options.proxyUri +( (options.proxyUri.indexOf('?')<0) ? '?' : '&' )+'vfs='+vfsName; if( options.workerId ){ proxyUri += '&opfs-async-proxy-id='+encodeURIComponent(options.workerId); } + //sqlite3.config.error("proxyUri",options.proxyUri, (new Error())); const W = opfsVfs.worker = //#if target:es6-bundler-friendly (()=>{ diff --git a/ext/wasm/api/sqlite3-opfs-async-proxy.c-pp.js b/ext/wasm/api/sqlite3-opfs-async-proxy.c-pp.js index e83cdf416d..797407e2c4 100644 --- a/ext/wasm/api/sqlite3-opfs-async-proxy.c-pp.js +++ b/ext/wasm/api/sqlite3-opfs-async-proxy.c-pp.js @@ -51,7 +51,8 @@ */ "use strict"; const urlParams = new URL(globalThis.location.href).searchParams; -if( !urlParams.has('vfs') ){ +const vfsName = urlParams.get('vfs'); +if( !vfsName ){ throw new Error("Expecting vfs=opfs|opfs-wl URL argument for this worker"); } const workerId = urlParams.get('opfs-async-proxy-id') @@ -111,12 +112,13 @@ const installAsyncProxy = function(){ */ const __openFiles = Object.create(null); /** - __implicitLocks is a Set of sqlite3_file pointers (integers) which were - "auto-locked". i.e. those for which we obtained a sync access - handle without an explicit xLock() call. Such locks will be - released during db connection idle time, whereas a sync access - handle obtained via xLock(), or subsequently xLock()'d after - auto-acquisition, will not be released until xUnlock() is called. + __implicitLocks is a Set of sqlite3_file pointers (integers) + which were "auto-locked". i.e. those for which we necessarily + obtain a sync access handle without an explicit xLock() call + guarding access. Such locks will be released during + `waitLoop()`'s idle time, whereas a sync access handle obtained + via xLock(), or subsequently xLock()'d after auto-acquisition, + will not be released until xUnlock() is called. Maintenance reminder: if we relinquish auto-locks at the end of the operation which acquires them, we pay a massive performance @@ -853,16 +855,21 @@ const installAsyncProxy = function(){ wPost('opfs-async-loaded'); }).catch((e)=>error("error initializing OPFS asyncer:",e)); }/*installAsyncProxy()*/; -if(!globalThis.SharedArrayBuffer){ +if(globalThis.window === globalThis){ + wPost('opfs-unavailable', + "This code cannot run from the main thread.", + "Load it as a Worker from a separate Worker."); +}else if(!globalThis.SharedArrayBuffer){ wPost('opfs-unavailable', "Missing SharedArrayBuffer API.", "The server must emit the COOP/COEP response headers to enable that."); }else if(!globalThis.Atomics){ wPost('opfs-unavailable', "Missing Atomics API.", "The server must emit the COOP/COEP response headers to enable that."); +}else if('opfs-wl'===vfsName && !globalThis.Atomics.waitAsync){ + wPost('opfs-unavailable',"Missing required Atomics.waitSync() for "+vfsName); }else if(!globalThis.FileSystemHandle || !globalThis.FileSystemDirectoryHandle || - !globalThis.FileSystemFileHandle || - !globalThis.FileSystemFileHandle.prototype.createSyncAccessHandle || + !globalThis.FileSystemFileHandle?.prototype?.createSyncAccessHandle || !navigator?.storage?.getDirectory){ wPost('opfs-unavailable',"Missing required OPFS APIs."); }else{ diff --git a/ext/wasm/api/sqlite3-vfs-opfs-wl.c-pp.js b/ext/wasm/api/sqlite3-vfs-opfs-wl.c-pp.js index 8119b32469..c1d34f192d 100644 --- a/ext/wasm/api/sqlite3-vfs-opfs-wl.c-pp.js +++ b/ext/wasm/api/sqlite3-vfs-opfs-wl.c-pp.js @@ -49,63 +49,60 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ Quirks specific to this VFS: - - Because WebLocks effectively block until they return, they will - effectively hang on locks rather than returning SQLITE_BUSY. + - The (officially undocumented) 'opfs-wl-disable' URL + argument will disable OPFS, making this function a no-op. Aside from locking differences in the VFSes, this function otherwise behaves the same as sqlite3-vfs-opfs.c-pp.js:installOpfsVfs(). */ -const installOpfsWlVfs = async function callee(options){ - options = opfsUtil.initOptions(options, callee); +const installOpfsWlVfs = async function(options){ + options = opfsUtil.initOptions('opfs-wl',options); if( !options ) return sqlite3; options.verbose = 2; const capi = sqlite3.capi, - debug = (...args)=>sqlite3.config.warn("opfs-wl:",...args), - state = opfsUtil.createVfsState('opfs-wl', options), + state = opfsUtil.createVfsState(), opfsVfs = state.vfs, metrics = opfsVfs.metrics.counters, mTimeStart = opfsVfs.mTimeStart, mTimeEnd = opfsVfs.mTimeEnd, + opRun = opfsVfs.opRun, + debug = (...args)=>sqlite3.config.debug("opfs-wl:",...args), + warn = (...args)=>sqlite3.config.warn("opfs-wl:",...args), __openFiles = opfsVfs.__openFiles; - //debug("state",JSON.stringify(state,false,' ')); - /* At this point, createVfsState() has populated state and opfsVfs - with any code common to both the "opfs" and "opfs-wl" VFSes. Now - comes the VFS-dependent work... */ + + //debug("state",JSON.stringify(options)); + /* + At this point, createVfsState() has populated: + + - state: the configuration object we share with the async proxy. + + - opfsVfs: an sqlite3_vfs instance with lots of JS state attached + to it. + + with any code common to both the "opfs" and "opfs-wl" VFSes. Now + comes the VFS-dependent work... + */ return opfsVfs.bindVfs(util.nu({ - xLock: function(pFile,lockType){ + xLock: function(pFile,lockType){ mTimeStart('xLock'); - ++metrics.xLock.count; + //debug("xLock()..."); const f = __openFiles[pFile]; - let rc = 0; - /* All OPFS locks are exclusive locks. If xLock() has - previously succeeded, do nothing except record the lock - type. If no lock is active, have the async counterpart - lock the file. */ - if( f.lockType ) { - f.lockType = lockType; - }else{ - rc = opRun('xLock', pFile, lockType); - if( 0===rc ) f.lockType = lockType; - } + const rc = opRun('xLock', pFile, lockType); + if( !rc ) f.lockType = lockType; mTimeEnd(); return rc; }, xUnlock: function(pFile,lockType){ mTimeStart('xUnlock'); - ++metrics.xUnlock.count; const f = __openFiles[pFile]; - let rc = 0; - if( capi.SQLITE_LOCK_NONE === lockType - && f.lockType ){ - rc = opRun('xUnlock', pFile, lockType); - } - if( 0===rc ) f.lockType = lockType; + const rc = opRun('xUnlock', pFile, lockType); + if( !rc ) f.lockType = lockType; mTimeEnd(); return rc; } }), function(sqlite3, vfs){ - //debug("registered VFS"); + /* Post-VFS-registration initialization... */ if(sqlite3.oo1){ const OpfsWlDb = function(...args){ const opt = sqlite3.oo1.DB.dbCtorHelper.normalizeArgs(...args); @@ -115,25 +112,20 @@ const installOpfsWlVfs = async function callee(options){ OpfsWlDb.prototype = Object.create(sqlite3.oo1.DB.prototype); sqlite3.oo1.OpfsWlDb = OpfsWlDb; OpfsWlDb.importDb = opfsUtil.importDb; - }/*extend sqlite3.oo1*/ + /* The "opfs" VFS variant adds a + oo1.DB.dbCtorHelper.setVfsPostOpenCallback() callback to set + a high busy_timeout. That was a design mis-decision and is + inconsistent with sqlite3_open() and friends, but is retained + against the risk of introducing regressions if it's removed. + This variant does not repeat that mistake. + */ + } })/*bindVfs()*/; }/*installOpfsWlVfs()*/; -installOpfsWlVfs.defaultProxyUri = "sqlite3-opfs-async-proxy.js"; globalThis.sqlite3ApiBootstrap.initializersAsync.push(async (sqlite3)=>{ - try{ - let proxyJs = installOpfsWlVfs.defaultProxyUri; - if( sqlite3.scriptInfo?.sqlite3Dir ){ - installOpfsWlVfs.defaultProxyUri = - sqlite3.scriptInfo.sqlite3Dir + proxyJs; - //sqlite3.config.warn("installOpfsWlVfs.defaultProxyUri =",installOpfsWlVfs.defaultProxyUri); - } - return installOpfsWlVfs().catch((e)=>{ - sqlite3.config.warn("Ignoring inability to install OPFS-WL sqlite3_vfs:",e); - }); - }catch(e){ - sqlite3.config.error("installOpfsWlVfs() exception:",e); - return Promise.reject(e); - } + return installOpfsWlVfs().catch((e)=>{ + sqlite3.config.warn("Ignoring inability to install the 'opfs-wl' sqlite3_vfs:",e); + }); }); }/*sqlite3ApiBootstrap.initializers.push()*/); //#endif target:node diff --git a/ext/wasm/api/sqlite3-vfs-opfs.c-pp.js b/ext/wasm/api/sqlite3-vfs-opfs.c-pp.js index ebe74e38b6..05e6a3f09f 100644 --- a/ext/wasm/api/sqlite3-vfs-opfs.c-pp.js +++ b/ext/wasm/api/sqlite3-vfs-opfs.c-pp.js @@ -60,7 +60,8 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ The argument may optionally be a plain object with the following configuration options: - - proxyUri: name of the async proxy JS file. + - proxyUri: name of the async proxy JS file or a synchronous function + which, when called, returns such a name. - verbose (=2): an integer 0-3. 0 disables all logging, 1 enables logging of errors. 2 enables logging of warnings and errors. 3 @@ -80,12 +81,13 @@ globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){ as there are legitimate non-error reasons for OPFS not to be available. */ -const installOpfsVfs = async function callee(options){ - options = opfsUtil.initOptions(options, callee); +const installOpfsVfs = async function(options){ + options = opfsUtil.initOptions('opfs',options); if( !options ) return sqlite3; const capi = sqlite3.capi, - state = opfsUtil.createVfsState('opfs', options), + state = opfsUtil.createVfsState(), opfsVfs = state.vfs, + metrics = opfsVfs.metrics.counters, mTimeStart = opfsVfs.mTimeStart, mTimeEnd = opfsVfs.mTimeEnd, opRun = opfsVfs.opRun, @@ -94,32 +96,51 @@ const installOpfsVfs = async function callee(options){ __openFiles = opfsVfs.__openFiles; //debug("options:",JSON.stringify(options)); - /* At this point, createVfsState() has populated `state` and - `opfsVfs` with any code common to both the "opfs" and "opfs-wl" - VFSes. Now comes the VFS-dependent work... */ + /* + At this point, createVfsState() has populated: + + - state: the configuration object we share with the async proxy. + + - opfsVfs: an sqlite3_vfs instance with lots of JS state attached + to it. + + with any code common to both the "opfs" and "opfs-wl" VFSes. Now + comes the VFS-dependent work... + */ return opfsVfs.bindVfs(util.nu({ xLock: function(pFile,lockType){ mTimeStart('xLock'); - //debug("xLock()..."); + ++metrics.xLock.count; const f = __openFiles[pFile]; - const rc = opRun('xLock', pFile, lockType); - if( rc ){ - warn("xLock() rc ",rc); - }else{ + let rc = 0; + /* All OPFS locks are exclusive locks. If xLock() has + previously succeeded, do nothing except record the lock + type. If no lock is active, have the async counterpart + lock the file. */ + if( f.lockType ) { f.lockType = lockType; + }else{ + rc = opRun('xLock', pFile, lockType); + if( 0===rc ) f.lockType = lockType; } mTimeEnd(); return rc; }, xUnlock: function(pFile,lockType){ mTimeStart('xUnlock'); + ++metrics.xUnlock.count; const f = __openFiles[pFile]; - const rc = opRun('xUnlock', pFile, lockType); + let rc = 0; + if( capi.SQLITE_LOCK_NONE === lockType + && f.lockType ){ + rc = opRun('xUnlock', pFile, lockType); + } if( 0===rc ) f.lockType = lockType; mTimeEnd(); return rc; } }), function(sqlite3, vfs){ + /* Post-VFS-registration initialization... */ if(sqlite3.oo1){ const OpfsDb = function(...args){ const opt = sqlite3.oo1.DB.dbCtorHelper.normalizeArgs(...args); @@ -129,7 +150,11 @@ const installOpfsVfs = async function callee(options){ OpfsDb.prototype = Object.create(sqlite3.oo1.DB.prototype); sqlite3.oo1.OpfsDb = OpfsDb; OpfsDb.importDb = opfsUtil.importDb; - if( false ){ + if( true ){ + /* 2026-03-06: this was a design mis-decision and is + inconsistent with sqlite3_open() and friends, but is + retained against the risk of introducing regressions if + it's removed. */ sqlite3.oo1.DB.dbCtorHelper.setVfsPostOpenCallback( opfsVfs.pointer, function(oo1Db, sqlite3){ @@ -143,22 +168,10 @@ const installOpfsVfs = async function callee(options){ }/*extend sqlite3.oo1*/ })/*bindVfs()*/; }/*installOpfsVfs()*/; -installOpfsVfs.defaultProxyUri = "sqlite3-opfs-async-proxy.js"; globalThis.sqlite3ApiBootstrap.initializersAsync.push(async (sqlite3)=>{ - try{ - let proxyJs = installOpfsVfs.defaultProxyUri; - if( sqlite3.scriptInfo?.sqlite3Dir ){ - installOpfsVfs.defaultProxyUri = - sqlite3.scriptInfo.sqlite3Dir + proxyJs; - //sqlite3.config.warn("installOpfsVfs.defaultProxyUri =",installOpfsVfs.defaultProxyUri); - } - return installOpfsVfs().catch((e)=>{ - sqlite3.config.warn("Ignoring inability to install OPFS sqlite3_vfs:",e); - }); - }catch(e){ - sqlite3.config.error("installOpfsVfs() exception:",e); - return Promise.reject(e); - } + return installOpfsVfs().catch((e)=>{ + sqlite3.config.warn("Ignoring inability to install 'opfs' sqlite3_vfs:",e); + }) }); }/*sqlite3ApiBootstrap.initializers.push()*/); //#endif target:node diff --git a/manifest b/manifest index 0974a04f21..72316086e1 100644 --- a/manifest +++ b/manifest @@ -1,5 +1,5 @@ -C Minor\scleanups\sand\sdocs.\sTeach\sthe\sOPFS\sconcurrency\stester\sto\sdeal\swith\sSQLITE_BUSY\sinstead\sof\sfailing. -D 2026-03-06T19:33:25.647 +C Get\s"opfs"\sand\s"opfs-wl"\sproperly\ssplit.\sSpeedtest1\sand\sthe\sconcurrency\stester\sare\shappy\swith\sopfs-wl\sbut\sit\sis\snot\syet\splugged\sin\sto\stester1. +D 2026-03-06T22:21:06.784 F .fossil-settings/binary-glob 61195414528fb3ea9693577e1980230d78a1f8b0a54c78cf1b9b24d0a409ed6a x F .fossil-settings/empty-dirs dbb81e8fc0401ac46a1491ab34a7f2c7c0452f2f06b54ebb845d024ca8283ef1 F .fossil-settings/ignore-glob 35175cdfcf539b2318cb04a9901442804be81cd677d8b889fcc9149c21f239ea @@ -585,7 +585,7 @@ F ext/wasm/api/README.md a905d5c6bfc3e2df875bd391d6d6b7b48d41b43bdee02ad115b4724 F ext/wasm/api/extern-post-js.c-pp.js d9f42ecbedc784c0d086bc37800e52946a14f7a21600b291daa3f963c314f930 F ext/wasm/api/extern-pre-js.js cc61c09c7a24a07dbecb4c352453c3985170cec12b4e7e7e7a4d11d43c5c8f41 F ext/wasm/api/opfs-common-inline.c-pp.js 5be8d6d91963849e218221b48206ae55612630bb2cd7f30b1b6fcf7a9e374b76 -F ext/wasm/api/opfs-common-shared.c-pp.js eccb37a2347b8b17a664401cd8ef0ee0a7e18cb81939ee4ef404905e8e9188bf +F ext/wasm/api/opfs-common-shared.c-pp.js b41b71ac06264e2d2db9a08e9cd7d5ee0e5730d224a4e81e0c42b0928028844e F ext/wasm/api/post-js-footer.js a50c1a2c4d008aede7b2aa1f18891a7ee71437c2f415b8aeb3db237ddce2935b F ext/wasm/api/post-js-header.js f35d2dcf1ab7f22a93d565f8e0b622a2934fc4e743edf3b708e4dd8140eeff55 F ext/wasm/api/pre-js.c-pp.js 9234ea680a2f6a2a177e8dcd934bdc5811a9f8409165433a252b87f4c07bba6f @@ -594,12 +594,12 @@ F ext/wasm/api/sqlite3-api-oo1.c-pp.js 45454631265d9ce82685f1a64e1650ee19c8e121c F ext/wasm/api/sqlite3-api-prologue.js 98fedc159c9239b226d19567d7172300dee5ffce176e5fa2f62dd1f17d088385 F ext/wasm/api/sqlite3-api-worker1.c-pp.js 1041dd645e8e821c082b628cd8d9acf70c667430f9d45167569633ffc7567938 F ext/wasm/api/sqlite3-license-version-header.js 98d90255a12d02214db634e041c8e7f2f133d9361a8ebf000ba9c9af4c6761cc -F ext/wasm/api/sqlite3-opfs-async-proxy.c-pp.js c19ca5986bceb60561973635bd68acbb93f5e1752b1d1b7f4cae20abaa8d5bd1 +F ext/wasm/api/sqlite3-opfs-async-proxy.c-pp.js 6025b22ebb92f9216e68d85c4e27c228e148f4d081e306f27d0a50342e56ec37 F ext/wasm/api/sqlite3-vfs-helper.c-pp.js 3f828cc66758acb40e9c5b4dcfd87fd478a14c8fb7f0630264e6c7fa0e57515d F ext/wasm/api/sqlite3-vfs-kvvfs.c-pp.js a61dd2b4d919d2d5d83c5c7e49b89ecbff2525ff81419f6a6dbaecaf3819c490 F ext/wasm/api/sqlite3-vfs-opfs-sahpool.c-pp.js 1575ea6bbcf2da1e6df6892c17521a0c1c1c199a672e9090176ea0b88de48bd9 -F ext/wasm/api/sqlite3-vfs-opfs-wl.c-pp.js 8233c5f9021b0213134e2adbaf6036b8f1dffd4747083a4087c1c19ae107f962 -F ext/wasm/api/sqlite3-vfs-opfs.c-pp.js f3bef4dbb8364a37471e4bc33e9b1e52795596456090007aaeae25acc35d2e85 +F ext/wasm/api/sqlite3-vfs-opfs-wl.c-pp.js f65903e15f49a5475eaf8fd3f35971d4c4c4b43f0a00167f1a2c98389cf84900 +F ext/wasm/api/sqlite3-vfs-opfs.c-pp.js 872c29aa760b05c2703185368a39b4b2e1a8abf15c29ee7e23ee8ca7cdcbed9d F ext/wasm/api/sqlite3-vtab-helper.c-pp.js 366596d8ff73d4cefb938bbe95bc839d503c3fab6c8335ce4bf52f0d8a7dee81 F ext/wasm/api/sqlite3-wasm.c 45bb20e19b245136711f9b78584371233975811b6560c29ed9b650e225417e29 F ext/wasm/api/sqlite3-worker1-promiser.c-pp.js aa9715f661fb700459a5a6cb1c32a4d6a770723b47aa9ac0e16c2cf87d622a66 @@ -2191,8 +2191,8 @@ F tool/warnings-clang.sh bbf6a1e685e534c92ec2bfba5b1745f34fb6f0bc2a362850723a9ee F tool/warnings.sh d924598cf2f55a4ecbc2aeb055c10bd5f48114793e7ba25f9585435da29e7e98 F tool/win/sqlite.vsix deb315d026cc8400325c5863eef847784a219a2f F tool/winmain.c 00c8fb88e365c9017db14c73d3c78af62194d9644feaf60e220ab0f411f3604c -P ba81d95febc5fd0f9bbb2685fef5b1b10f9991751f2bdfafba80c15877af1cef -R 5bd89f58e70b2c6dcff7610e01717205 +P 247ffed141f66a6a5a396a3e002995a9f00c70333271199200530066e77956c4 +R d5ab78b2216c6ac5e35f6ab8d6aa4867 U stephan -Z 52bcc9f2059e4acc631f2cd7a59885ba +Z 836eb4f55d744876555cc67389157d1f # Remove this line to create a well-formed Fossil manifest. diff --git a/manifest.uuid b/manifest.uuid index e3c556d7b3..31efc532c3 100644 --- a/manifest.uuid +++ b/manifest.uuid @@ -1 +1 @@ -247ffed141f66a6a5a396a3e002995a9f00c70333271199200530066e77956c4 +12dcd5425967b6306f3e3178babeac130962edb78e6298d545a429a1a20457cc