Add files using upload-large-folder tool

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5ac.test

@@ -0,0 +1,278 @@
+# 2014 June 17
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is testing the FTS5 module.
+#
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+set testprefix fts5ac
+
+# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
+ifcapable !fts5 {
+  finish_test
+  return
+}
+
+foreach_detail_mode $testprefix {
+
+set data {
+    0   {p o q e z k z p n f y u z y n y}   {l o o l v v k}
+    1   {p k h h p y l l h i p v n}         {p p l u r i f a j g e r r x w}
+    2   {l s z j k i m p s}                 {l w e j t j e e i t w r o p o}
+    3   {x g y m y m h p}                   {k j j b r e y y a k y}
+    4   {q m a i y i z}                     {o w a g k x g j m w e u k}
+    5   {k o a w y b s z}                   {s g l m m l m g p}
+    6   {d a q i z h b l c p k j g k}       {p x u j x t v c z}
+    7   {f d a g o c t i}                   {w f c x l d r k i j}
+    8   {y g w u b q p o m j y b p a e k}   {r i d k y w o z q m a t p}
+    9   {r k o m c c j s x m x m x m q r}   {y r c a q d z k n x n}
+    10  {k j q m g q a j d}                 {d d e z g w h c d o o g x d}
+    11  {j z u m o y q j f w e e w t r j w} {g m o r x n t n w i f g l z f}
+    12  {s y w a w d o h x m k}             {c w k z b p o r a}
+    13  {u t h x e g s k n g i}             {f j w g c s r}
+    14  {b f i c s u z t k}                 {c k q s j u i z o}
+    15  {n a f n u s w h y n s i q e w}     {x g e g a s s h n}
+    16  {k s q e j n p}                     {t r j f t o e k k l m i}
+    17  {g d t u w r o p m n m n p h b o u} {h s w o s l j e}
+    18  {f l q y q q g e e x j r}           {n b r r g e i r t x q k}
+    19  {f i r g o a w e p i l o a w}       {e k r z t d g h g i b d i e m}
+    20  {l d u u f p y}                     {g o m m u x m g l j t t x x u}
+    21  {m c d k x i c z l}                 {m i a i e u h}
+    22  {w b f o c g x y j}                 {z d w x d f h i p}
+    23  {w u i u x t c h k i b}             {b y k h b v r t g j}
+    24  {h f d j s w s b a p k}             {a q y u z e y m m j q r}
+    25  {d i x y x x k i y f s d j h z p n} {l l q m e t c w g y h t s v g}
+    26  {g s q w t d k x g f m j p k y}     {r m b x e l t d}
+    27  {j l s q u g y v e c l o}           {m f l m m m h g x x l n c}
+    28  {c t j g v r s b z j}               {l c f y d t q n}
+    29  {e x z y w i h l}                   {b n b x e y q e n u m}
+    30  {g y y h j b w r}                   {q b q f u s k c k g r}
+    31  {g u l x l b r c m z b u c}         {k g t b x k x n t e z d h o}
+    32  {w g v l z f b z h p s c v h}       {g e w v m h k r g w a r f q}
+    33  {c g n f u d o y o b}               {e y o h x x y y i z s b h a j}
+    34  {v y h c q u u s q y x x k s q}     {d n r m y k n t i r n w e}
+    35  {o u c x l e b t a}                 {y b a x y f z x r}
+    36  {x p h l j a a u u j h}             {x o f s z m b c q p}
+    37  {k q t i c a q n m v v}             {v r z e f m y o}
+    38  {r w t t t t r v v o e p g h}       {l w x a g a u h y}
+    39  {o p v g v b a g o}                 {j t q c r b b g y z}
+    40  {f s o r o d t h q f x l}           {r d b m k i f s t d l m y x j w}
+    41  {t m o t m f m f}                   {i p i q j v n v m b q}
+    42  {t x w a r l w d t b c o d o}       {a h f h w z d n s}
+    43  {t u q c d g p q x j o l c x c}     {m n t o z z j a y}
+    44  {v d i i k b f s z r v r z y}       {g n q y s x x m b x c l w}
+    45  {p v v a c s z y e o l}             {m v t u d k m k q b d c v z r}
+    46  {f y k l d r q w r s t r e}         {h m v r r l r r t f q e x y}
+    47  {w l n l t y x}                     {n h s l a f c h u f l x x m v n o}
+    48  {t n v i k e b p z p d j j l i o}   {i v z p g u e j s i k n h w d c}
+    49  {z v x p n l t a j c}               {e j l e n c e t a d}
+    50  {w u b x u i v h a i y m m r p m s} {s r h d o g z y f f x e}
+    51  {d c c x b c a x g}                 {p r a j v u y}
+    52  {f w g r c o d l t u e z h i}       {j l l s s b j m}
+    53  {p m t f k i x}                     {u v y a z g w v v m x h i}
+    54  {l c z g l o j i c d e b}           {b f v y w u i b e i y}
+    55  {r h c x f x a d s}                 {z x y k f l r b q c v}
+    56  {v x x c y h z x b g m o q n c}     {h n b i t g h a q b c o r u}
+    57  {d g l o h t b s b r}               {n u e p t i m u}
+    58  {t d y e t d c w u o s w x f c h}   {i o s v y b r d r}
+    59  {l b a p q n d r}                   {k d c c d n y q h g a o p e x}
+    60  {f r z v m p k r}                   {x x r i s b a g f c}
+    61  {s a z i e r f i w c n y v z t k s} {y y i r y n l s b w i e k n}
+    62  {n x p r e x q r m v i b y}         {f o o z n b s r q j}
+    63  {y j s u j x o n r q t f}           {f v k n v x u s o a d e f e}
+    64  {u s i l y c x q}                   {r k c h p c h b o s s u s p b}
+    65  {m p i o s h o}                     {s w h u n d m n q t y k b w c}
+    66  {l d f g m x x x o}                 {s w d d f b y j j h h t i y p j o}
+    67  {c b m h f n v w n h}               {i r w i e x r w l z p x u g u l s}
+    68  {y a h u h i m a y q}               {d d r x h e v q n z y c j}
+    69  {c x f d x o n p o b r t b l p l}   {m i t k b x v f p t m l l y r o}
+    70  {u t l w w m s}                     {m f m o l t k o p e}
+    71  {f g q e l n d m z x q}             {z s i i i m f w w f n g p e q}
+    72  {n l h a v u o d f j d e x}         {v v s l f g d g r a j x i f z x}
+    73  {x v m v f i g q e w}               {r y s j i k m j j e d g r n o i f}
+    74  {g d y n o h p s y q z j d w n h w} {x o d l t j i b r d o r y}
+    75  {p g b i u r b e q d v o a g w m k} {q y z s f q o h}
+    76  {u z a q u f i f f b}               {b s p b a a d x r r i q f}
+    77  {w h h z t h p o a h h e e}         {h w r p h k z v y f r x}
+    78  {c a r k i a p u x}                 {f w l p t e m l}
+    79  {q q u k o t r k z}                 {f b m c w p s s o z}
+    80  {t i g v y q s r x m r x z e f}     {x o j w a u e y s j c b u p p r o}
+    81  {n j n h r l a r e o z w e}         {v o r r j a v b}
+    82  {i f i d k w d n h}                 {o i d z i z l m w s b q v u}
+    83  {m d g q q b k b w f q q p p}       {j m q f b y c i z k y q p l e a}
+    84  {m x o n y f g}                     {y c n x n q j i y c l h b r q z}
+    85  {v o z l n p c}                     {g n j n t b b x n c l d a g j v}
+    86  {z n a y f b t k k t d b z a v}     {r p c n r u k u}
+    87  {b q t x z e c w}                   {q a o a l o a h i m j r}
+    88  {j f h o x x a z g b a f a m i b}   {j z c z y x e x w t}
+    89  {t c t p r s u c q n}               {z x l i k n f q l n t}
+    90  {w t d q j g m r f k n}             {l e w f w w a l y q k i q t p c t}
+    91  {c b o k l i c b s j n m b l}       {y f p q o w g}
+    92  {f y d j o q t c c q m f j s t}     {f h e d y m o k}
+    93  {k x j r m a d o i z j}             {r t t t f e b r x i v j v g o}
+    94  {s f e a e t i h h d q p z t q}     {b k m k w h c}
+    95  {h b n j t k i h o q u}             {w n g i t o k c a m y p f l x c p}
+    96  {f c x p y r b m o l m o a}         {p c a q s u n n x d c f a o}
+    97  {u h h k m n k}                     {u b v n u a o c}
+    98  {s p e t c z d f n w f}             {l s f j b l c e s h}
+    99  {r c v w i v h a t a c v c r e}     {h h u m g o f b a e o}
+}
+
+foreach {tn2 sql} {
+  1  {}
+  2  {BEGIN}
+} {
+  reset_db
+  fts5_aux_test_functions db
+
+  do_execsql_test 1.$tn2.0 {
+    CREATE VIRTUAL TABLE xx USING fts5(x,y, detail=%DETAIL%);
+    INSERT INTO xx(xx, rank) VALUES('pgsz', 32);
+  }
+
+  execsql $sql
+
+  do_test 1.$tn2.1.1 {
+    foreach {id x y} $data {
+      execsql { INSERT INTO xx(rowid, x, y) VALUES($id, $x, $y) }
+    }
+    execsql { INSERT INTO xx(xx) VALUES('integrity-check') }
+  } {}
+
+
+  #-------------------------------------------------------------------------
+  #
+  do_execsql_test 1.$tn2.integrity {
+    INSERT INTO xx(xx) VALUES('integrity-check');
+  }
+
+  #-------------------------------------------------------------------------
+  #
+  foreach {tn expr} {
+    1.1 "a   AND b"
+    1.2 "a   OR b"
+    1.3 "o"
+    1.4 "b q"
+    1.5 "e a e"
+    1.6 "m d g q q b k b w f q q p p"
+    1.7 "l o o l v v k"
+    1.8 "a"
+    1.9 "b"
+    1.10 "c"
+    1.11 "no"
+    1.12 "L O O L V V K"
+    1.13 "a AND b AND c"
+    1.14 "x:a"
+
+    2.1 "x:a"
+    2.2 "y:a"
+    2.3 "x:b"
+    2.4 "y:b"
+
+    3.1 "{x}:a"
+    3.2 "{y}:a"
+    3.3 "{x}:b"
+    3.4 "{y}:b"
+
+    4.1 "{x y}:a"
+    4.2 "{y x}:a"
+    4.3 "{x x}:b"
+    4.4 "{y y}:b"
+
+    5.1 {{"x" "y"}:a}
+    5.2 {{"y" x}:a}
+    5.3 {{x "x"}:b}
+    5.4 {{"y" y}:b}
+
+    6.1 "b + q"
+    6.2 "e + a + e"
+    6.3 "m + d + g + q + q + b + k + b + w + f + q + q + p + p"
+    6.4 "l + o + o + l + v + v + k"
+    6.5 "L + O + O + L + V + V + K"
+
+    7.1 "a+b AND c"
+    7.2 "d+c AND u"
+    7.3 "d+c AND u+d"
+    7.4 "a+b OR c"
+    7.5 "d+c OR u"
+    7.6 "d+c OR u+d"
+
+    8.1 "NEAR(a b)"
+    8.2 "NEAR(r c)"
+    8.2 { NEAR(r c, 5) }
+    8.3 { NEAR(r c, 3) }
+    8.4 { NEAR(r c, 2) }
+    8.5 { NEAR(r c, 0) }
+    8.6 { NEAR(a b c) }
+    8.7 { NEAR(a b c, 8) }
+    8.8  { x : NEAR(r c) }
+    8.9  { y : NEAR(r c) }
+
+    9.1 { NEAR(r c) }
+    9.2 { NEAR(r c, 5) }
+    9.3 { NEAR(r c, 3) }
+    9.4 { NEAR(r c, 2) }
+    9.5 { NEAR(r c, 0) }
+    9.6 { NEAR(a b c) }
+    9.7 { NEAR(a b c, 8) }
+    9.8  { x : NEAR(r c) }
+    9.9  { y : NEAR(r c) }
+    9.10 { x : "r c" }
+    9.11 { y : "r c" }
+    9.12 { a AND b }
+    9.13 { a AND b AND c }
+    9.14a { a }
+    9.14b { a OR b }
+    9.15 { a OR b AND c }
+    9.16 { c AND b OR a }
+    9.17 { c AND (b OR a) }
+    9.18 { c NOT (b OR a) }
+    9.19 { (c NOT b) OR (a AND d) }
+  } {
+
+    if {[fts5_expr_ok $expr xx]==0} {
+      do_test 1.$tn2.$tn.OMITTED { list } [list]
+      continue
+    }
+
+    set res [fts5_query_data $expr xx]
+    do_execsql_test 1.$tn2.$tn.[llength $res].asc {
+      SELECT rowid, fts5_test_poslist(xx), fts5_test_collist(xx) 
+      FROM xx WHERE xx match $expr
+    } $res
+
+    set res [fts5_query_data $expr xx DESC]
+    do_execsql_test 1.$tn2.$tn.[llength $res].desc {
+      SELECT rowid, fts5_test_poslist(xx), fts5_test_collist(xx) 
+      FROM xx WHERE xx match $expr ORDER BY 1 DESC
+    } $res
+  }
+}
+
+}
+
+do_execsql_test 2.1 {
+  SELECT fts5_expr_tcl('a AND b');
+} {{AND [nearset -- {a}] [nearset -- {b}]}}
+
+do_test 2.2.1  { nearset {{a b c}} -- a } {0.0.0}
+do_test 2.2.2  { nearset {{a b c}} -- c } {0.0.2}
+
+foreach {tn expr tclexpr} {
+  1 {a b} {AND [N $x -- {a}] [N $x -- {b}]}
+} {
+  do_execsql_test 2.3.$tn {
+    SELECT fts5_expr_tcl($expr, 'N $x')
+  } [list $tclexpr]
+}
+
+finish_test

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5ae.test

@@ -0,0 +1,311 @@
+# 2014 June 17
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is testing the FTS5 module.
+#
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+set testprefix fts5ae
+
+# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
+ifcapable !fts5 {
+  finish_test
+  return
+}
+
+foreach_detail_mode $testprefix {
+
+do_execsql_test 1.0 {
+  CREATE VIRTUAL TABLE t1 USING fts5(a, b, detail=%DETAIL%);
+  INSERT INTO t1(t1, rank) VALUES('pgsz', 32);
+}
+
+do_execsql_test 1.1 {
+  INSERT INTO t1 VALUES('hello', 'world');
+  SELECT rowid FROM t1 WHERE t1 MATCH 'hello' ORDER BY rowid ASC;
+} {1}
+
+do_execsql_test 1.2 {
+  INSERT INTO t1 VALUES('world', 'hello');
+  SELECT rowid FROM t1 WHERE t1 MATCH 'hello' ORDER BY rowid ASC;
+} {1 2}
+
+do_execsql_test 1.3 {
+  INSERT INTO t1 VALUES('world', 'world');
+  SELECT rowid FROM t1 WHERE t1 MATCH 'hello' ORDER BY rowid ASC;
+} {1 2}
+
+do_execsql_test 1.4.1 {
+  INSERT INTO t1 VALUES('hello', 'hello');
+}
+
+do_execsql_test 1.4.2 {
+  SELECT rowid FROM t1 WHERE t1 MATCH 'hello' ORDER BY rowid ASC;
+} {1 2 4}
+
+fts5_aux_test_functions db
+
+#-------------------------------------------------------------------------
+# 
+do_execsql_test 2.0 {
+  CREATE VIRTUAL TABLE t2 USING fts5(x, y, detail=%DETAIL%);
+  INSERT INTO t2 VALUES('u t l w w m s', 'm f m o l t k o p e');
+  INSERT INTO t2 VALUES('f g q e l n d m z x q', 'z s i i i m f w w f n g p');
+}
+
+do_execsql_test 2.1 {
+  SELECT rowid, fts5_test_poslist(t2) FROM t2 
+  WHERE t2 MATCH 'm' ORDER BY rowid;
+} {
+  1 {0.0.5 0.1.0 0.1.2} 
+  2 {0.0.7 0.1.5}
+}
+
+do_execsql_test 2.2 {
+  SELECT rowid, fts5_test_poslist(t2) FROM t2 
+  WHERE t2 MATCH 'u OR q' ORDER BY rowid;
+} {
+  1 {0.0.0}
+  2 {1.0.2 1.0.10}
+}
+
+if {[detail_is_full]} {
+  do_execsql_test 2.3 {
+    SELECT rowid, fts5_test_poslist(t2) FROM t2 
+      WHERE t2 MATCH 'y:o' ORDER BY rowid;
+  } {
+    1 {0.1.3 0.1.7}
+  }
+}
+
+#-------------------------------------------------------------------------
+# 
+do_execsql_test 3.0 {
+  CREATE VIRTUAL TABLE t3 USING fts5(x, y, detail=%DETAIL%);
+  INSERT INTO t3 VALUES( 'j f h o x x a z g b a f a m i b', 'j z c z y x w t');
+  INSERT INTO t3 VALUES( 'r c', '');
+}
+
+if {[detail_is_full]} {
+  do_execsql_test 3.1 {
+    SELECT rowid, fts5_test_poslist(t3) FROM t3 WHERE t3 MATCH 'NEAR(a b)';
+  } {
+    1 {0.0.6 1.0.9 0.0.10 0.0.12 1.0.15}
+  }
+
+  do_execsql_test 3.2 {
+    SELECT rowid, fts5_test_poslist(t3) FROM t3 WHERE t3 MATCH 'NEAR(r c)';
+  } {
+    2 {0.0.0 1.0.1}
+  }
+}
+
+do_execsql_test 3.3 {
+  INSERT INTO t3 
+  VALUES('k x j r m a d o i z j', 'r t t t f e b r x i v j v g o');
+  SELECT rowid, fts5_test_poslist(t3) 
+  FROM t3 WHERE t3 MATCH 'a OR b AND c';
+} {
+  1 {0.0.6 1.0.9 0.0.10 0.0.12 1.0.15 2.1.2}
+  3 0.0.5 
+}
+
+#-------------------------------------------------------------------------
+# 
+do_execsql_test 4.0 {
+  CREATE VIRTUAL TABLE t4 USING fts5(x, y, detail=%DETAIL%);
+  INSERT INTO t4 
+  VALUES('k x j r m a d o i z j', 'r t t t f e b r x i v j v g o');
+}
+
+do_execsql_test 4.1 {
+  SELECT rowid, fts5_test_poslist(t4) FROM t4 WHERE t4 MATCH 'a OR b AND c';
+} {
+  1 0.0.5
+}
+
+#-------------------------------------------------------------------------
+# Test that the xColumnSize() and xColumnAvgsize() APIs work.
+#
+reset_db
+fts5_aux_test_functions db
+
+do_execsql_test 5.1 {
+  CREATE VIRTUAL TABLE t5 USING fts5(x, y, detail=%DETAIL%);
+  INSERT INTO t5 VALUES('a b c d', 'e f g h i j');
+  INSERT INTO t5 VALUES('', 'a');
+  INSERT INTO t5 VALUES('a', '');
+}
+do_execsql_test 5.2 {
+  SELECT rowid, fts5_test_columnsize(t5) FROM t5 WHERE t5 MATCH 'a'
+  ORDER BY rowid DESC;
+} {
+  3 {1 0}
+  2 {0 1}
+  1 {4 6}
+}
+
+do_execsql_test 5.3 {
+  SELECT rowid, fts5_test_columntext(t5) FROM t5 WHERE t5 MATCH 'a'
+  ORDER BY rowid DESC;
+} {
+  3 {a {}}
+  2 {{} a}
+  1 {{a b c d} {e f g h i j}}
+}
+
+do_execsql_test 5.4 {
+  SELECT rowid, fts5_test_columntotalsize(t5) FROM t5 WHERE t5 MATCH 'a'
+  ORDER BY rowid DESC;
+} {
+  3 {5 7}
+  2 {5 7}
+  1 {5 7}
+}
+
+do_execsql_test 5.5 {
+  INSERT INTO t5 VALUES('x y z', 'v w x y z');
+  SELECT rowid, fts5_test_columntotalsize(t5) FROM t5 WHERE t5 MATCH 'a'
+  ORDER BY rowid DESC;
+} {
+  3 {8 12}
+  2 {8 12}
+  1 {8 12}
+}
+
+#-------------------------------------------------------------------------
+# Test the xTokenize() API
+#
+reset_db
+fts5_aux_test_functions db
+do_execsql_test 6.1 {
+  CREATE VIRTUAL TABLE t6 USING fts5(x, y, detail=%DETAIL%);
+  INSERT INTO t6 VALUES('There are more', 'things in heaven and earth');
+  INSERT INTO t6 VALUES(', Horatio, Than are', 'dreamt of in your philosophy.');
+}
+
+do_execsql_test 6.2 {
+  SELECT rowid, fts5_test_tokenize(t6) FROM t6 WHERE t6 MATCH 't*'
+} {
+  1 {{there are more} {things in heaven and earth}}
+  2 {{horatio than are} {dreamt of in your philosophy}}
+}
+
+#-------------------------------------------------------------------------
+# Test the xQueryPhrase() API
+#
+reset_db
+fts5_aux_test_functions db
+do_execsql_test 7.1 {
+  CREATE VIRTUAL TABLE t7 USING fts5(x, y, detail=%DETAIL%);
+}
+do_test 7.2 {
+  foreach {x y} {
+    {q i b w s a a e l o} {i b z a l f p t e u}
+    {b a z t a l o x d i} {b p a d b f h d w y}
+    {z m h n p p u i e g} {v h d v b x j j c z}
+    {a g i m v a u c b i} {p k s o t l r t b m}
+    {v v c j o d a s c p} {f f v o k p o f o g}
+  } {
+    execsql {INSERT INTO t7 VALUES($x, $y)}
+  }
+  execsql { SELECT count(*) FROM t7 }
+} {5}
+
+foreach {tn q res} {
+  1 a {{4 2}}
+  2 b {{3 4}}
+  3 c {{2 1}}
+  4 d {{2 2}}
+  5 {a AND b} {{4 2} {3 4}}
+  6 {a OR b OR c OR d} {{4 2} {3 4} {2 1} {2 2}}
+} {
+  do_execsql_test 7.3.$tn { 
+    SELECT fts5_test_queryphrase(t7) FROM t7 WHERE t7 MATCH $q LIMIT 1
+  } [list $res]
+}
+
+do_execsql_test 7.4 {
+  SELECT fts5_test_rowcount(t7) FROM t7 WHERE t7 MATCH 'a';
+} {5 5 5 5}
+
+#do_execsql_test 7.4 {
+#  SELECT rowid, bm25debug(t7) FROM t7 WHERE t7 MATCH 'a';
+#} {5 5 5 5}
+#
+
+#-------------------------------------------------------------------------
+#
+do_test 8.1 {
+  execsql { CREATE VIRTUAL TABLE t8 USING fts5(x, y, detail=%DETAIL%) }
+  foreach {rowid x y} {
+     0 {A o}   {o o o C o o o o o o o o}
+     1 {o o B} {o o o C C o o o o o o o}
+     2 {A o o} {o o o o D D o o o o o o}
+     3 {o B}   {o o o o o D o o o o o o}
+     4 {E o G} {H o o o o o o o o o o o}
+     5 {F o G} {I o J o o o o o o o o o}
+     6 {E o o} {H o J o o o o o o o o o}
+     7 {o o o} {o o o o o o o o o o o o}
+     9 {o o o} {o o o o o o o o o o o o}
+  } {
+    execsql { INSERT INTO t8(rowid, x, y) VALUES($rowid, $x, $y) }
+  }
+} {}
+
+foreach {tn q res} {
+  1 {a} {0 2}
+  2 {b} {3 1}
+  3 {c} {1 0}
+  4 {d} {2 3}
+  5 {g AND (e OR f)} {5 4}
+  6 {j AND (h OR i)} {5 6}
+} {
+  do_execsql_test 8.2.$tn.1 {
+    SELECT rowid FROM t8 WHERE t8 MATCH $q ORDER BY bm25(t8);
+  } $res
+
+  do_execsql_test 8.2.$tn.2 {
+    SELECT rowid FROM t8 WHERE t8 MATCH $q ORDER BY +rank;
+  } $res
+
+  do_execsql_test 8.2.$tn.3 {
+    SELECT rowid FROM t8 WHERE t8 MATCH $q ORDER BY rank;
+  } $res
+}
+
+#-------------------------------------------------------------------------
+# Test xPhraseCount() for some different queries.
+#
+do_test 9.1 {
+  execsql { CREATE VIRTUAL TABLE t9 USING fts5(x) }
+  foreach x {
+    "a b c" "d e f"
+  } {
+    execsql { INSERT INTO t9 VALUES($x) }
+  }
+} {}
+
+foreach {tn q cnt} {
+  1 {a AND b}      2
+  2 {a OR b}       2
+  3 {a OR b OR c}  3
+  4 {NEAR(a b)}    2
+} {
+  do_execsql_test 9.2.$tn {
+    SELECT fts5_test_phrasecount(t9) FROM t9 WHERE t9 MATCH $q LIMIT 1
+  } $cnt
+}
+
+}
+
+finish_test

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5auxdata.test

@@ -0,0 +1,114 @@
+# 2014 Dec 20
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# Tests focusing on the fts5 xSetAuxdata() and xGetAuxdata() APIs.
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+set testprefix fts5auxdata
+
+# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
+ifcapable !fts5 {
+  finish_test
+  return
+}
+
+do_execsql_test 1.0 {
+  CREATE VIRTUAL TABLE f1 USING fts5(a, b);
+  INSERT INTO f1(rowid, a, b) VALUES(1, 'a', 'b1');
+  INSERT INTO f1(rowid, a, b) VALUES(2, 'a', 'b2');
+  INSERT INTO f1(rowid, a, b) VALUES(3, 'a', 'b3');
+  INSERT INTO f1(rowid, a, b) VALUES(4, 'a', 'b4');
+  INSERT INTO f1(rowid, a, b) VALUES(5, 'a', 'b5');
+}
+
+proc aux_function_1 {cmd tn} {
+  switch [$cmd xRowid] {
+    1 {
+      do_test $tn.1 [list $cmd xGetAuxdata 0 ] {}
+      $cmd xSetAuxdata "one"
+    }
+
+    2 {
+      do_test $tn.2 [list $cmd xGetAuxdata 0 ] {one}
+      $cmd xSetAuxdata "two"
+    }
+
+    3 {
+      do_test $tn.3 [list $cmd xGetAuxdata 0 ] {two}
+    }
+
+    4 {
+      do_test $tn.4 [list $cmd xGetAuxdata 1 ] {two}
+    }
+
+    5 {
+      do_test $tn.5 [list $cmd xGetAuxdata 0 ] {}
+    }
+  }
+}
+
+sqlite3_fts5_create_function db aux_function_1 aux_function_1
+db eval { 
+  SELECT aux_function_1(f1, 1) FROM f1 WHERE f1 MATCH 'a'
+  ORDER BY rowid ASC
+}
+
+proc aux_function_2 {cmd tn inst} {
+  if {$inst == "A"} {
+    switch [$cmd xRowid] {
+      1 {
+        do_test $tn.1.$inst [list $cmd xGetAuxdata 0 ] {}
+        $cmd xSetAuxdata "one $inst"
+      }
+      2 {
+        do_test $tn.2.$inst [list $cmd xGetAuxdata 0 ] "one $inst"
+        $cmd xSetAuxdata "two $inst"
+      }
+      3 {
+        do_test $tn.3.$inst [list $cmd xGetAuxdata 0 ] "two $inst"
+      }
+      4 {
+        do_test $tn.4.$inst [list $cmd xGetAuxdata 1 ] "two $inst"
+      }
+      5 {
+        do_test $tn.5.$inst [list $cmd xGetAuxdata 0 ] {}
+      }
+    }
+  } else {
+    switch [$cmd xRowid] {
+      1 {
+        do_test $tn.1.$inst [list $cmd xGetAuxdata 0 ] "one A"
+      }
+      2 {
+        do_test $tn.2.$inst [list $cmd xGetAuxdata 0 ] "two A"
+      }
+      3 {
+        do_test $tn.3.$inst [list $cmd xGetAuxdata 0 ] "two A"
+      }
+      4 {
+        do_test $tn.4.$inst [list $cmd xGetAuxdata 0 ] {}
+      }
+      5 {
+        do_test $tn.5.$inst [list $cmd xGetAuxdata 0 ] {}
+      }
+    }
+  }
+}
+
+sqlite3_fts5_create_function db aux_function_2 aux_function_2
+db eval { 
+  SELECT aux_function_2(f1, 2, 'A'), aux_function_2(f1, 2, 'B') 
+  FROM f1 WHERE f1 MATCH 'a'
+  ORDER BY rowid ASC
+}
+
+finish_test

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5corrupt7.test

@@ -0,0 +1,128 @@
+# 2023 April 30
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+set testprefix fts5corrupt7
+
+# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
+ifcapable !fts5 {
+  finish_test
+  return
+}
+sqlite3_fts5_may_be_corrupt 1
+
+do_execsql_test 1.0 {
+  CREATE VIRTUAL TABLE t1 USING fts5(x);
+  INSERT INTO t1(t1, rank) VALUES('pgsz', 32);
+}
+
+set doc [string repeat "a b " 30]
+
+do_execsql_test 1.1 {
+  BEGIN;
+    INSERT INTO t1(rowid, x) VALUES(123, $doc);
+    INSERT INTO t1(rowid, x) VALUES(124, $doc);
+  COMMIT;
+}
+
+execsql_pp {
+  SELECT id, fts5_decode(id, block), quote(block) FROM t1_data
+}
+
+set rows [db eval { SELECT rowid FROM t1_data }]
+db_save_and_close
+
+foreach r $rows {
+  db_restore_and_reopen
+
+  proc edit_block {b} {
+    binary scan $b c* in
+    set out [lreplace $in 0 1 255 255]
+    binary format c* $out
+  }
+  db func edit_block edit_block
+
+  do_execsql_test 1.2.$r.1 {
+    UPDATE t1_data SET block = edit_block(block) WHERE rowid=$r;
+  }
+
+  do_execsql_test 1.2.$r.2 {
+    INSERT INTO t1(t1, rank) VALUES('secure-delete', 1);
+  }
+
+  do_test 1.2.$r.3 {
+    catchsql { DELETE FROM t1 WHERE rowid=123; }
+    catchsql { DELETE FROM t1 WHERE rowid=124; }
+    set {} {}
+  } {}
+
+  db close
+}
+
+foreach r $rows {
+set r 137438953475
+  db_restore_and_reopen
+
+  proc edit_block {b} {
+    binary scan $b c* in
+    set out [lreplace $in end end 127]
+    binary format c* $out
+  }
+  db func edit_block edit_block
+
+  do_execsql_test 1.2.$r.1 {
+    UPDATE t1_data SET block = edit_block(block) WHERE rowid=$r;
+  }
+
+  do_execsql_test 1.2.$r.2 {
+    INSERT INTO t1(t1, rank) VALUES('secure-delete', 1);
+  }
+
+  do_test 1.2.$r.3 {
+    catchsql { DELETE FROM t1 WHERE rowid=124; }
+    catchsql { DELETE FROM t1 WHERE rowid=123; }
+    set {} {}
+  } {}
+
+  db close
+}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 2.0 {
+  CREATE VIRTUAL TABLE t1 USING fts5(x);
+  BEGIN;
+    INSERT INTO t1 VALUES('abc');
+    INSERT INTO t1 VALUES('b d d d');
+  COMMIT;
+  INSERT INTO t1(t1, rank) VALUES('secure-delete', 1);
+}
+
+execsql_pp {
+  SELECT id, quote(block) FROM t1_data
+}
+
+do_execsql_test 2.1 {
+  SELECT quote(block) FROM t1_data WHERE id > 10;
+}        {X'0000001A04306162630102020101620202020101640206030303040806'}
+
+do_execsql_test 2.2 {
+  UPDATE t1_data SET 
+    block=X'0000001A04306162630102025501620202020101640206030303040806'
+  WHERE id>10
+}
+
+do_catchsql_test 2.3 {
+  DELETE FROM t1 WHERE rowid = 1
+} {1 {database disk image is malformed}}
+
+finish_test

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5determin.test

@@ -0,0 +1,65 @@
+# 2016 March 21
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is testing the FTS5 module.
+#
+# Specifically, that the fts5 module is deterministic. At one point, when
+# segment ids were allocated using sqlite3_randomness(), this was not the
+# case.
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+set testprefix fts5aa
+return_if_no_fts5 
+
+proc do_determin_test {tn} {
+  uplevel [list
+    do_execsql_test $tn {
+      SELECT (SELECT md5sum(id, block) FROM t1_data)==
+             (SELECT md5sum(id, block) FROM t2_data),
+             (SELECT md5sum(id, block) FROM t1_data)==
+             (SELECT md5sum(id, block) FROM t3_data)
+    } {1 1}
+  ]
+}
+
+foreach_detail_mode $::testprefix {
+  do_execsql_test 1.0 {
+    CREATE VIRTUAL TABLE t1 USING fts5(a, b, prefix="1 2", detail=%DETAIL%);
+    CREATE VIRTUAL TABLE t2 USING fts5(a, b, prefix="1 2", detail=%DETAIL%);
+    CREATE VIRTUAL TABLE t3 USING fts5(a, b, prefix="1 2", detail=%DETAIL%);
+  }
+
+  do_test 1.1 {
+    foreach t {t1 t2 t3} {
+      execsql [string map [list TBL $t] {
+        INSERT INTO TBL VALUES('a b c', 'd e f');
+        INSERT INTO TBL VALUES('c1 c2 c3', 'c1 c2 c3');
+        INSERT INTO TBL VALUES('xyzxyzxyz', 'xyzxyzxyz');
+      }]
+    }
+  } {}
+
+  do_determin_test 1.2
+
+  do_test 1.3 {
+    foreach t {t1 t2 t3} {
+      execsql [string map [list TBL $t] {
+        INSERT INTO TBL(TBL) VALUES('optimize');
+      }]
+    }
+  } {}
+
+  do_determin_test 1.4
+}
+
+
+finish_test

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5expr.test

@@ -0,0 +1,52 @@
+# 2024 August 8
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is testing the FTS5 module.
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+set testprefix fts5expr
+
+# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
+ifcapable !fts5 {
+  finish_test
+  return
+}
+
+do_execsql_test 1.0 {
+  CREATE VIRTUAL TABLE x1 USING fts5(a);
+  INSERT INTO x1(rowid, a) VALUES (113, 'fts5 expr test');
+}
+
+do_execsql_test 1.1 {
+  SELECT rowid FROM x1('expr');
+} {113}
+
+for {set ii 0} {$ii < 300} {incr ii} {
+  set expr "expr "
+  append expr [string repeat "NOT abcd " $ii]
+
+  if {$ii<257} {
+    set res {0 113}
+  } else {
+    set res {1 {fts5 expression tree is too large (maximum depth 256)}}
+  }
+  do_catchsql_test 1.1.$ii {
+    SELECT rowid FROM x1($expr)
+  } $res
+}
+
+do_execsql_test 1.2 {
+  SELECT rowid FROM x1 WHERE a MATCH '"..."'
+} {}
+
+finish_test
+

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5full.test

@@ -0,0 +1,42 @@
+# 2014 Dec 20
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# Test that SQLITE_FULL is returned if the FTS5 table cannot find a free 
+# segid to use. In practice this can only really happen when automerge and
+# crisismerge are both disabled.
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+set testprefix fts5full
+
+# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
+ifcapable !fts5 {
+  finish_test
+  return
+}
+
+do_execsql_test 1.0 {
+  CREATE VIRTUAL TABLE x8 USING fts5(i);
+  INSERT INTO x8(x8, rank) VALUES('automerge', 0);
+  INSERT INTO x8(x8, rank) VALUES('crisismerge', 100000);
+}
+
+db func rnddoc fts5_rnddoc
+do_test 1.1 {
+  list [catch {
+    for {set i 0} {$i < 2500} {incr i} {
+      execsql { INSERT INTO x8 VALUES( rnddoc(5) ); }
+    }
+  } msg] $msg
+} {0 {}}
+
+
+finish_test

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5query.test

@@ -0,0 +1,91 @@
+# 2015 October 27
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is testing the FTS5 module.
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+set testprefix fts5query
+
+# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
+ifcapable !fts5 {
+  finish_test
+  return
+}
+
+for {set tn 1 ; set pgsz 64} {$tn<32} {incr tn; incr pgsz 16} {
+  reset_db
+  do_test 1.$tn.1 {
+    execsql {
+      CREATE VIRTUAL TABLE t1 USING fts5(x);
+      INSERT INTO t1(t1, rank) VALUES('pgsz', $pgsz);
+      BEGIN;
+    }
+    foreach x [list aaa bbb ccc ddd eee fff ggg hhh iii jjj] {
+      set doc [string repeat "$x " 30]
+      execsql { INSERT INTO t1 VALUES($doc) }
+    }
+    execsql COMMIT
+  } {}
+
+  do_execsql_test 1.$tn.2 {
+    INSERT INTO t1(t1) VALUES('integrity-check');
+  }
+
+  set ret 1
+  foreach x [list a b c d e f g h i j] {
+    do_execsql_test 1.$tn.3.$ret {
+      SELECT rowid FROM t1 WHERE t1 MATCH $x || '*';
+    } $ret
+    incr ret
+  }
+}
+
+for {set tn 1 ; set pgsz 64} {$tn<32} {incr tn; incr pgsz 16} {
+  reset_db
+  do_test 2.$tn.1 {
+    execsql {
+      CREATE VIRTUAL TABLE t1 USING fts5(x);
+      INSERT INTO t1(t1, rank) VALUES('pgsz', $pgsz);
+      BEGIN;
+    }
+    foreach x [list bbb ddd fff hhh jjj lll nnn ppp rrr ttt] {
+      set doc [string repeat "$x " 30]
+      execsql { INSERT INTO t1 VALUES($doc) }
+    }
+    execsql COMMIT
+  } {}
+
+  do_execsql_test 2.$tn.2 {
+    INSERT INTO t1(t1) VALUES('integrity-check');
+  }
+
+  set ret 1
+  foreach x [list a c e g i k m o q s u] {
+    do_execsql_test 2.$tn.3.$ret {
+      SELECT rowid FROM t1 WHERE t1 MATCH $x || '*';
+    } {}
+    incr ret
+  }
+}
+
+reset_db
+do_execsql_test 3.0 {
+  CREATE VIRTUAL TABLE x1 USING fts5(a);
+  INSERT INTO x1(rowid, a) VALUES(-1000000000000, 'toyota');
+  INSERT INTO x1(rowid, a) VALUES(1, 'tarago');
+}
+do_execsql_test 3.1 {
+  SELECT rowid FROM x1('t*');
+} {-1000000000000 1}
+
+
+finish_test

local-test-sqlite3-delta-02/afc-sqlite3/ext/fts5/test/fts5tokenizer3.test

@@ -0,0 +1,77 @@
+# 2024 Aug 10
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# Tests focusing on the built-in fts5 tokenizers. 
+#
+
+source [file join [file dirname [info script]] fts5_common.tcl]
+set testprefix fts5tokenizer3
+
+# If SQLITE_ENABLE_FTS5 is not defined, omit this file.
+ifcapable !fts5 {
+  finish_test
+  return
+}
+
+
+proc get_sod {args} { return "split_on_dot" }
+proc get_lowercase    {args} { return "lowercase" }
+
+proc lowercase {flags txt} {
+  set n [string length $txt]
+  sqlite3_fts5_token [string tolower $txt] 0 $n
+  return 0
+}
+
+proc split_on_dot {flags txt} {
+  set iOff 0
+  foreach t [split $txt "."] {
+    set n [string length $txt]
+    sqlite3_fts5_token $t $iOff [expr $iOff+$n]
+    incr iOff [expr {$n+1}]
+  }
+  return ""
+}
+
+foreach {tn script} {
+  1 {
+    sqlite3_fts5_create_tokenizer db lowercase get_lowercase
+    sqlite3_fts5_create_tokenizer -parent lowercase db split_on_dot get_sod
+  }
+  2 {
+    sqlite3_fts5_create_tokenizer -v2 db lowercase get_lowercase
+    sqlite3_fts5_create_tokenizer -parent lowercase db split_on_dot get_sod
+  }
+  3 {
+    sqlite3_fts5_create_tokenizer db lowercase get_lowercase
+    sqlite3_fts5_create_tokenizer -v2 -parent lowercase db split_on_dot get_sod
+  }
+  4 {
+    sqlite3_fts5_create_tokenizer -v2 db lowercase get_lowercase
+    sqlite3_fts5_create_tokenizer -v2 -parent lowercase db split_on_dot get_sod
+  }
+} {
+  reset_db
+  eval $script
+
+  do_execsql_test 1.$tn.0 {
+    CREATE VIRTUAL TABLE t1 USING fts5(x, tokenize=split_on_dot);
+    CREATE VIRTUAL TABLE t1vocab USING fts5vocab(t1, instance);
+    INSERT INTO t1 VALUES('ABC.Def.ghi');
+  }
+
+  do_execsql_test 1.$tn.1 {
+    SELECT term FROM t1vocab ORDER BY 1
+  } {abc def ghi}
+}
+
+
+finish_test

local-test-sqlite3-delta-02/afc-sqlite3/ext/recover/recoverpgsz.test

@@ -0,0 +1,97 @@
+# 2022 October 14
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+
+source [file join [file dirname [info script]] recover_common.tcl]
+
+db close
+sqlite3_test_control_pending_byte 0x1000000
+
+set testprefix recoverpgsz
+
+foreach {pgsz bOverflow} {
+  512 0 1024 0 2048 0 4096 0 8192 0 16384 0 32768 0 65536 0
+  512 1 1024 1 2048 1 4096 1 8192 1 16384 1 32768 1 65536 1
+} {
+  reset_db
+  execsql "PRAGMA page_size = $pgsz"
+  execsql "PRAGMA auto_vacuum = 0"
+  do_execsql_test 1.$pgsz.$bOverflow.1 {
+    CREATE TABLE t1(a, b, c);
+    CREATE INDEX i1 ON t1(b, a, c);
+    INSERT INTO t1(a, b) VALUES(1, 2), (3, 4), (5, 6);
+    DELETE FROM t1 WHERE a=3;
+  }
+  if {$bOverflow} {
+    do_execsql_test 1.$pgsz.$bOverflow.1a {
+      UPDATE t1 SET c = randomblob(100000);
+    }
+  }
+  db close
+
+
+  set fd [open test.db]
+  fconfigure $fd -translation binary
+  seek $fd $pgsz
+  set pg1 [read $fd $pgsz]
+  set pg2 [read $fd $pgsz]
+  close $fd
+
+  set fd2 [open test.db2 w]
+  fconfigure $fd2 -translation binary
+  seek $fd2 $pgsz
+  puts -nonewline $fd2 $pg1
+  close $fd2
+
+  sqlite3 db2 test.db2
+  do_test 1.$pgsz.$bOverflow.2 {
+    set R [sqlite3_recover_init db2 main test.db3]
+    $R run
+    $R finish
+  } {}
+
+  sqlite3 db3 test.db3
+  do_test 1.$pgsz.$bOverflow.3 {
+    db3 eval { SELECT * FROM sqlite_schema }
+    db3 eval { PRAGMA page_size } 
+  } $pgsz
+
+  db2 close
+  db3 close
+
+  forcedelete test.db3
+  forcedelete test.db2
+
+  set fd2 [open test.db2 w]
+  fconfigure $fd2 -translation binary
+  seek $fd2 $pgsz
+  puts -nonewline $fd2 $pg2
+  close $fd2
+
+  sqlite3 db2 test.db2
+  do_test 1.$pgsz.$bOverflow.4 {
+    set R [sqlite3_recover_init db2 main test.db3]
+    $R run
+    $R finish
+  } {}
+
+  sqlite3 db3 test.db3
+  do_test 1.$pgsz.$bOverflow.5 {
+    db3 eval { SELECT * FROM sqlite_schema }
+    db3 eval { PRAGMA page_size } 
+  } $pgsz
+
+  db2 close
+  db3 close
+}
+
+
+finish_test

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/EXPORTED_FUNCTIONS.sqlite3-see

@@ -0,0 +1,5 @@
+_sqlite3_key
+_sqlite3_key_v2
+_sqlite3_rekey
+_sqlite3_rekey_v2
+_sqlite3_activate_see

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/extern-post-js.c-pp.js

@@ -0,0 +1,126 @@
+
+/* ^^^^ ACHTUNG: blank line at the start is necessary because
+   Emscripten will not add a newline in some cases and we need
+   a blank line for a sed-based kludge for the ES6 build. */
+/* extern-post-js.js must be appended to the resulting sqlite3.js
+   file. It gets its name from being used as the value for the
+   --extern-post-js=... Emscripten flag. Note that this code, unlike
+   most of the associated JS code, runs outside of the
+   Emscripten-generated module init scope, in the current
+   global scope. */
+//#if target=es6-module
+const toExportForESM =
+//#endif
+(function(){
+  /**
+     In order to hide the sqlite3InitModule()'s resulting
+     Emscripten module from downstream clients (and simplify our
+     documentation by being able to elide those details), we hide that
+     function and expose a hand-written sqlite3InitModule() to return
+     the sqlite3 object (most of the time).
+
+     Unfortunately, we cannot modify the module-loader/exporter-based
+     impls which Emscripten installs at some point in the file above
+     this.
+  */
+  const originalInit = sqlite3InitModule;
+  if(!originalInit){
+    throw new Error("Expecting globalThis.sqlite3InitModule to be defined by the Emscripten build.");
+  }
+  /**
+     We need to add some state which our custom Module.locateFile()
+     can see, but an Emscripten limitation currently prevents us from
+     attaching it to the sqlite3InitModule function object:
+
+     https://github.com/emscripten-core/emscripten/issues/18071
+
+     The only(?) current workaround is to temporarily stash this state
+     into the global scope and delete it when sqlite3InitModule()
+     is called.
+  */
+  const initModuleState = globalThis.sqlite3InitModuleState = Object.assign(Object.create(null),{
+    moduleScript: globalThis?.document?.currentScript,
+    isWorker: ('undefined' !== typeof WorkerGlobalScope),
+    location: globalThis.location,
+    urlParams:  globalThis?.location?.href
+      ? new URL(globalThis.location.href).searchParams
+      : new URLSearchParams()
+  });
+  initModuleState.debugModule =
+    initModuleState.urlParams.has('sqlite3.debugModule')
+    ? (...args)=>console.warn('sqlite3.debugModule:',...args)
+    : ()=>{};
+
+  if(initModuleState.urlParams.has('sqlite3.dir')){
+    initModuleState.sqlite3Dir = initModuleState.urlParams.get('sqlite3.dir') +'/';
+  }else if(initModuleState.moduleScript){
+    const li = initModuleState.moduleScript.src.split('/');
+    li.pop();
+    initModuleState.sqlite3Dir = li.join('/') + '/';
+  }
+
+  globalThis.sqlite3InitModule = function ff(...args){
+    //console.warn("Using replaced sqlite3InitModule()",globalThis.location);
+    return originalInit(...args).then((EmscriptenModule)=>{
+//#if wasmfs
+      if('undefined'!==typeof WorkerGlobalScope &&
+         EmscriptenModule['ENVIRONMENT_IS_PTHREAD']){
+        /** Workaround for wasmfs-generated worker, which calls this
+            routine from each individual thread and requires that its
+            argument be returned. The conditional criteria above are
+            fragile, based solely on inspection of the offending code,
+            not public Emscripten details. */
+        //console.warn("sqlite3InitModule() returning E-module.",EmscriptenModule);
+        return EmscriptenModule;
+      }
+//#endif
+      //console.warn("sqlite3InitModule() returning sqlite3 object.");
+      const s = EmscriptenModule.sqlite3;
+      s.scriptInfo = initModuleState;
+      //console.warn("sqlite3.scriptInfo =",s.scriptInfo);
+      if(ff.__isUnderTest) s.__isUnderTest = true;
+      const f = s.asyncPostInit;
+      delete s.asyncPostInit;
+      return f();
+    }).catch((e)=>{
+      console.error("Exception loading sqlite3 module:",e);
+      throw e;
+    });
+  };
+  globalThis.sqlite3InitModule.ready = originalInit.ready;
+
+  if(globalThis.sqlite3InitModuleState.moduleScript){
+    const sim = globalThis.sqlite3InitModuleState;
+    let src = sim.moduleScript.src.split('/');
+    src.pop();
+    sim.scriptDir = src.join('/') + '/';
+  }
+  initModuleState.debugModule('sqlite3InitModuleState =',initModuleState);
+  if(0){
+    console.warn("Replaced sqlite3InitModule()");
+    console.warn("globalThis.location.href =",globalThis.location.href);
+    if('undefined' !== typeof document){
+      console.warn("document.currentScript.src =",
+                   document?.currentScript?.src);
+    }
+  }
+//#ifnot target=es6-module
+// Emscripten does not inject these module-loader bits in ES6 module
+// builds and including them here breaks JS bundlers, so elide them
+// from ESM builds.
+  /* Replace the various module exports performed by the Emscripten
+     glue... */
+  if (typeof exports === 'object' && typeof module === 'object'){
+    module.exports = sqlite3InitModule;
+  }else if (typeof exports === 'object'){
+    exports["sqlite3InitModule"] = sqlite3InitModule;
+  }
+  /* AMD modules get injected in a way we cannot override,
+     so we can't handle those here. */
+//#endif // !target=es6-module
+  return globalThis.sqlite3InitModule /* required for ESM */;
+})();
+//#if target=es6-module
+sqlite3InitModule = toExportForESM;
+export default sqlite3InitModule;
+//#endif

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/extern-pre-js.js

@@ -0,0 +1,7 @@
+/* extern-pre-js.js must be prepended to the resulting sqlite3.js
+   file. This file is currently only used for holding snippets during
+   test and development.
+
+   It gets its name from being used as the value for the
+   --extern-pre-js=... Emscripten flag.
+*/

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/sqlite3-api-glue.c-pp.js

@@ -0,0 +1,1922 @@
+/*
+  2022-07-22
+
+  The author disclaims copyright to this source code.  In place of a
+  legal notice, here is a blessing:
+
+  *   May you do good and not evil.
+  *   May you find forgiveness for yourself and forgive others.
+  *   May you share freely, never taking more than you give.
+
+  ***********************************************************************
+
+  This file glues together disparate pieces of JS which are loaded in
+  previous steps of the sqlite3-api.js bootstrapping process:
+  sqlite3-api-prologue.js, whwasmutil.js, and jaccwabyt.js. It
+  initializes the main API pieces so that the downstream components
+  (e.g. sqlite3-api-oo1.js) have all of the infrastructure that they
+  need.
+*/
+globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
+  'use strict';
+  const toss = (...args)=>{throw new Error(args.join(' '))};
+  const toss3 = sqlite3.SQLite3Error.toss;
+  const capi = sqlite3.capi, wasm = sqlite3.wasm, util = sqlite3.util;
+  globalThis.WhWasmUtilInstaller(wasm);
+  delete globalThis.WhWasmUtilInstaller;
+
+  if(0){
+    /**
+       Please keep this block around as a maintenance reminder
+       that we cannot rely on this type of check.
+
+       This block fails on Safari, per a report at
+       https://sqlite.org/forum/forumpost/e5b20e1feb.
+
+       It turns out that what Safari serves from the indirect function
+       table (e.g. wasm.functionEntry(X)) is anonymous functions which
+       wrap the WASM functions, rather than returning the WASM
+       functions themselves. That means comparison of such functions
+       is useless for determining whether or not we have a specific
+       function from wasm.exports. i.e. if function X is indirection
+       function table entry N then wasm.exports.X is not equal to
+       wasm.functionEntry(N) in Safari, despite being so in the other
+       browsers.
+    */
+    /**
+       Find a mapping for SQLITE_WASM_DEALLOC, which the API
+       guarantees is a WASM pointer to the same underlying function as
+       wasm.dealloc() (noting that wasm.dealloc() is permitted to be a
+       JS wrapper around the WASM function). There is unfortunately no
+       O(1) algorithm for finding this pointer: we have to walk the
+       WASM indirect function table to find it. However, experience
+       indicates that that particular function is always very close to
+       the front of the table (it's been entry #3 in all relevant
+       tests).
+    */
+    const dealloc = wasm.exports[sqlite3.config.deallocExportName];
+    const nFunc = wasm.functionTable().length;
+    let i;
+    for(i = 0; i < nFunc; ++i){
+      const e = wasm.functionEntry(i);
+      if(dealloc === e){
+        capi.SQLITE_WASM_DEALLOC = i;
+        break;
+      }
+    }
+    if(dealloc !== wasm.functionEntry(capi.SQLITE_WASM_DEALLOC)){
+      toss("Internal error: cannot find function pointer for SQLITE_WASM_DEALLOC.");
+    }
+  }
+
+  /**
+     Signatures for the WASM-exported C-side functions. Each entry
+     is an array with 2+ elements:
+
+     [ "c-side name",
+       "result type" (wasm.xWrap() syntax),
+       [arg types in xWrap() syntax]
+       // ^^^ this needn't strictly be an array: it can be subsequent
+       // elements instead: [x,y,z] is equivalent to x,y,z
+     ]
+
+     Note that support for the API-specific data types in the
+     result/argument type strings gets plugged in at a later phase in
+     the API initialization process.
+  */
+  wasm.bindingSignatures = [
+    // Please keep these sorted by function name!
+    ["sqlite3_aggregate_context","void*", "sqlite3_context*", "int"],
+    /* sqlite3_auto_extension() has a hand-written binding. */
+    /* sqlite3_bind_blob() and sqlite3_bind_text() have hand-written
+       bindings to permit more flexible inputs. */
+    ["sqlite3_bind_double","int", "sqlite3_stmt*", "int", "f64"],
+    ["sqlite3_bind_int","int", "sqlite3_stmt*", "int", "int"],
+    ["sqlite3_bind_null",undefined, "sqlite3_stmt*", "int"],
+    ["sqlite3_bind_parameter_count", "int", "sqlite3_stmt*"],
+    ["sqlite3_bind_parameter_index","int", "sqlite3_stmt*", "string"],
+    ["sqlite3_bind_parameter_name", "string", "sqlite3_stmt*", "int"],
+    ["sqlite3_bind_pointer", "int",
+     "sqlite3_stmt*", "int", "*", "string:static", "*"],
+    ["sqlite3_busy_handler","int", [
+      "sqlite3*",
+      new wasm.xWrap.FuncPtrAdapter({
+        signature: 'i(pi)',
+        contextKey: (argv,argIndex)=>argv[0/* sqlite3* */]
+      }),
+      "*"
+    ]],
+    ["sqlite3_busy_timeout","int", "sqlite3*", "int"],
+    /* sqlite3_cancel_auto_extension() has a hand-written binding. */
+    /* sqlite3_close_v2() is implemented by hand to perform some
+       extra work. */
+    ["sqlite3_changes", "int", "sqlite3*"],
+    ["sqlite3_clear_bindings","int", "sqlite3_stmt*"],
+    ["sqlite3_collation_needed", "int", "sqlite3*", "*", "*"/*=>v(ppis)*/],
+    ["sqlite3_column_blob","*", "sqlite3_stmt*", "int"],
+    ["sqlite3_column_bytes","int", "sqlite3_stmt*", "int"],
+    ["sqlite3_column_count", "int", "sqlite3_stmt*"],
+    ["sqlite3_column_decltype", "string", "sqlite3_stmt*", "int"],
+    ["sqlite3_column_double","f64", "sqlite3_stmt*", "int"],
+    ["sqlite3_column_int","int", "sqlite3_stmt*", "int"],
+    ["sqlite3_column_name","string", "sqlite3_stmt*", "int"],
+    ["sqlite3_column_text","string", "sqlite3_stmt*", "int"],
+    ["sqlite3_column_type","int", "sqlite3_stmt*", "int"],
+    ["sqlite3_column_value","sqlite3_value*", "sqlite3_stmt*", "int"],
+    ["sqlite3_commit_hook", "void*", [
+      "sqlite3*",
+      new wasm.xWrap.FuncPtrAdapter({
+        name: 'sqlite3_commit_hook',
+        signature: 'i(p)',
+        contextKey: (argv)=>argv[0/* sqlite3* */]
+      }),
+      '*'
+    ]],
+    ["sqlite3_compileoption_get", "string", "int"],
+    ["sqlite3_compileoption_used", "int", "string"],
+    ["sqlite3_complete", "int", "string:flexible"],
+    ["sqlite3_context_db_handle", "sqlite3*", "sqlite3_context*"],
+    /* sqlite3_create_collation() and sqlite3_create_collation_v2()
+       use hand-written bindings to simplify passing of the callback
+       function. */
+    /* sqlite3_create_function(), sqlite3_create_function_v2(), and
+       sqlite3_create_window_function() use hand-written bindings to
+       simplify handling of their function-type arguments. */
+    ["sqlite3_data_count", "int", "sqlite3_stmt*"],
+    ["sqlite3_db_filename", "string", "sqlite3*", "string"],
+    ["sqlite3_db_handle", "sqlite3*", "sqlite3_stmt*"],
+    ["sqlite3_db_name", "string", "sqlite3*", "int"],
+    ["sqlite3_db_readonly", "int", "sqlite3*", "string"],
+    ["sqlite3_db_status", "int", "sqlite3*", "int", "*", "*", "int"],
+    ["sqlite3_errcode", "int", "sqlite3*"],
+    ["sqlite3_errmsg", "string", "sqlite3*"],
+    ["sqlite3_error_offset", "int", "sqlite3*"],
+    ["sqlite3_errstr", "string", "int"],
+    ["sqlite3_exec", "int", [
+      "sqlite3*", "string:flexible",
+      new wasm.xWrap.FuncPtrAdapter({
+        signature: 'i(pipp)',
+        bindScope: 'transient',
+        callProxy: (callback)=>{
+          let aNames;
+          return (pVoid, nCols, pColVals, pColNames)=>{
+            try {
+              const aVals = wasm.cArgvToJs(nCols, pColVals);
+              if(!aNames) aNames = wasm.cArgvToJs(nCols, pColNames);
+              return callback(aVals, aNames) | 0;
+            }catch(e){
+              /* If we set the db error state here, the higher-level
+                 exec() call replaces it with its own, so we have no way
+                 of reporting the exception message except the console. We
+                 must not propagate exceptions through the C API. Though
+                 we make an effort to report OOM here, sqlite3_exec()
+                 translates that into SQLITE_ABORT as well. */
+              return e.resultCode || capi.SQLITE_ERROR;
+            }
+          }
+        }
+      }),
+      "*", "**"
+    ]],
+    ["sqlite3_expanded_sql", "string", "sqlite3_stmt*"],
+    ["sqlite3_extended_errcode", "int", "sqlite3*"],
+    ["sqlite3_extended_result_codes", "int", "sqlite3*", "int"],
+    ["sqlite3_file_control", "int", "sqlite3*", "string", "int", "*"],
+    ["sqlite3_finalize", "int", "sqlite3_stmt*"],
+    ["sqlite3_free", undefined,"*"],
+    ["sqlite3_get_autocommit", "int", "sqlite3*"],
+    ["sqlite3_get_auxdata", "*", "sqlite3_context*", "int"],
+    ["sqlite3_initialize", undefined],
+    ["sqlite3_interrupt", undefined, "sqlite3*"],
+    ["sqlite3_is_interrupted", "int", "sqlite3*"],
+    ["sqlite3_keyword_count", "int"],
+    ["sqlite3_keyword_name", "int", ["int", "**", "*"]],
+    ["sqlite3_keyword_check", "int", ["string", "int"]],
+    ["sqlite3_libversion", "string"],
+    ["sqlite3_libversion_number", "int"],
+    ["sqlite3_limit", "int", ["sqlite3*", "int", "int"]],
+    ["sqlite3_malloc", "*","int"],
+    ["sqlite3_open", "int", "string", "*"],
+    ["sqlite3_open_v2", "int", "string", "*", "int", "string"],
+    /* sqlite3_prepare_v2() and sqlite3_prepare_v3() are handled
+       separately due to us requiring two different sets of semantics
+       for those, depending on how their SQL argument is provided. */
+    /* sqlite3_randomness() uses a hand-written wrapper to extend
+       the range of supported argument types. */
+    ["sqlite3_realloc", "*","*","int"],
+    ["sqlite3_reset", "int", "sqlite3_stmt*"],
+    /* sqlite3_reset_auto_extension() has a hand-written binding. */
+    ["sqlite3_result_blob", undefined, "sqlite3_context*", "*", "int", "*"],
+    ["sqlite3_result_double", undefined, "sqlite3_context*", "f64"],
+    ["sqlite3_result_error", undefined, "sqlite3_context*", "string", "int"],
+    ["sqlite3_result_error_code", undefined, "sqlite3_context*", "int"],
+    ["sqlite3_result_error_nomem", undefined, "sqlite3_context*"],
+    ["sqlite3_result_error_toobig", undefined, "sqlite3_context*"],
+    ["sqlite3_result_int", undefined, "sqlite3_context*", "int"],
+    ["sqlite3_result_null", undefined, "sqlite3_context*"],
+    ["sqlite3_result_pointer", undefined,
+     "sqlite3_context*", "*", "string:static", "*"],
+    ["sqlite3_result_subtype", undefined, "sqlite3_value*", "int"],
+    ["sqlite3_result_text", undefined, "sqlite3_context*", "string", "int", "*"],
+    ["sqlite3_result_zeroblob", undefined, "sqlite3_context*", "int"],
+    ["sqlite3_rollback_hook", "void*", [
+      "sqlite3*",
+      new wasm.xWrap.FuncPtrAdapter({
+        name: 'sqlite3_rollback_hook',
+        signature: 'v(p)',
+        contextKey: (argv)=>argv[0/* sqlite3* */]
+      }),
+      '*'
+    ]],
+    ["sqlite3_set_auxdata", undefined, [
+      "sqlite3_context*", "int", "*",
+      new wasm.xWrap.FuncPtrAdapter({
+        name: 'xDestroyAuxData',
+        signature: 'v(*)',
+        contextKey: (argv, argIndex)=>argv[0/* sqlite3_context* */]
+      })
+    ]],
+    ["sqlite3_shutdown", undefined],
+    ["sqlite3_sourceid", "string"],
+    ["sqlite3_sql", "string", "sqlite3_stmt*"],
+    ["sqlite3_status", "int", "int", "*", "*", "int"],
+    ["sqlite3_step", "int", "sqlite3_stmt*"],
+    ["sqlite3_stmt_busy", "int", "sqlite3_stmt*"],
+    ["sqlite3_stmt_readonly", "int", "sqlite3_stmt*"],
+    ["sqlite3_stmt_status", "int", "sqlite3_stmt*", "int", "int"],
+    ["sqlite3_strglob", "int", "string","string"],
+    ["sqlite3_stricmp", "int", "string", "string"],
+    ["sqlite3_strlike", "int", "string", "string","int"],
+    ["sqlite3_strnicmp", "int", "string", "string", "int"],
+    ["sqlite3_table_column_metadata", "int",
+     "sqlite3*", "string", "string", "string",
+     "**", "**", "*", "*", "*"],
+    ["sqlite3_total_changes", "int", "sqlite3*"],
+    ["sqlite3_trace_v2", "int", [
+      "sqlite3*", "int",
+      new wasm.xWrap.FuncPtrAdapter({
+        name: 'sqlite3_trace_v2::callback',
+        signature: 'i(ippp)',
+        contextKey: (argv,argIndex)=>argv[0/* sqlite3* */]
+      }),
+      "*"
+    ]],
+    ["sqlite3_txn_state", "int", ["sqlite3*","string"]],
+    /* Note that sqlite3_uri_...() have very specific requirements for
+       their first C-string arguments, so we cannot perform any value
+       conversion on those. */
+    ["sqlite3_uri_boolean", "int", "sqlite3_filename", "string", "int"],
+    ["sqlite3_uri_key", "string", "sqlite3_filename", "int"],
+    ["sqlite3_uri_parameter", "string", "sqlite3_filename", "string"],
+    ["sqlite3_user_data","void*", "sqlite3_context*"],
+    ["sqlite3_value_blob", "*", "sqlite3_value*"],
+    ["sqlite3_value_bytes","int", "sqlite3_value*"],
+    ["sqlite3_value_double","f64", "sqlite3_value*"],
+    ["sqlite3_value_dup", "sqlite3_value*", "sqlite3_value*"],
+    ["sqlite3_value_free", undefined, "sqlite3_value*"],
+    ["sqlite3_value_frombind", "int", "sqlite3_value*"],
+    ["sqlite3_value_int","int", "sqlite3_value*"],
+    ["sqlite3_value_nochange", "int", "sqlite3_value*"],
+    ["sqlite3_value_numeric_type", "int", "sqlite3_value*"],
+    ["sqlite3_value_pointer", "*", "sqlite3_value*", "string:static"],
+    ["sqlite3_value_subtype", "int", "sqlite3_value*"],
+    ["sqlite3_value_text", "string", "sqlite3_value*"],
+    ["sqlite3_value_type", "int", "sqlite3_value*"],
+    ["sqlite3_vfs_find", "*", "string"],
+    ["sqlite3_vfs_register", "int", "sqlite3_vfs*", "int"],
+    ["sqlite3_vfs_unregister", "int", "sqlite3_vfs*"]
+  ]/*wasm.bindingSignatures*/;
+
+  if( !!wasm.exports.sqlite3_progress_handler ){
+    wasm.bindingSignatures.push(
+      ["sqlite3_progress_handler", undefined, [
+        "sqlite3*", "int", new wasm.xWrap.FuncPtrAdapter({
+          name: 'xProgressHandler',
+          signature: 'i(p)',
+          bindScope: 'context',
+          contextKey: (argv,argIndex)=>argv[0/* sqlite3* */]
+        }), "*"
+      ]]
+    );
+  }
+
+  if( !!wasm.exports.sqlite3_stmt_explain ){
+    wasm.bindingSignatures.push(
+      ["sqlite3_stmt_explain", "int", "sqlite3_stmt*", "int"],
+      ["sqlite3_stmt_isexplain", "int", "sqlite3_stmt*"]
+    );
+  }
+
+  if( !!wasm.exports.sqlite3_set_authorizer ){
+    wasm.bindingSignatures.push(
+      ["sqlite3_set_authorizer", "int", [
+        "sqlite3*",
+        new wasm.xWrap.FuncPtrAdapter({
+          name: "sqlite3_set_authorizer::xAuth",
+          signature: "i(pi"+"ssss)",
+          contextKey: (argv, argIndex)=>argv[0/*(sqlite3*)*/],
+          callProxy: (callback)=>{
+            return (pV, iCode, s0, s1, s2, s3)=>{
+              try{
+                s0 = s0 && wasm.cstrToJs(s0); s1 = s1 && wasm.cstrToJs(s1);
+                s2 = s2 && wasm.cstrToJs(s2); s3 = s3 && wasm.cstrToJs(s3);
+                return callback(pV, iCode, s0, s1, s2, s3) || 0;
+              }catch(e){
+                return e.resultCode || capi.SQLITE_ERROR;
+              }
+            }
+          }
+        }),
+        "*"/*pUserData*/
+      ]]
+    );
+  }/* sqlite3_set_authorizer() */
+
+  if(false && wasm.compileOptionUsed('SQLITE_ENABLE_NORMALIZE')){
+    /* ^^^ "the problem" is that this is an optional feature and the
+       build-time function-export list does not currently take
+       optional features into account. */
+    wasm.bindingSignatures.push(["sqlite3_normalized_sql", "string", "sqlite3_stmt*"]);
+  }
+
+//#if enable-see
+  if(wasm.exports.sqlite3_key_v2 instanceof Function){
+    /**
+       This code is capable of using an SEE build but note that an SEE
+       WASM build is generally incompatible with SEE's license
+       conditions. It is permitted for use internally in organizations
+       which have licensed SEE, but not for public sites because
+       exposing an SEE build of sqlite3.wasm effectively provides all
+       clients with a working copy of the commercial SEE code.
+    */
+    wasm.bindingSignatures.push(
+      ["sqlite3_key", "int", "sqlite3*", "string", "int"],
+      ["sqlite3_key_v2","int","sqlite3*","string","*","int"],
+      ["sqlite3_rekey", "int", "sqlite3*", "string", "int"],
+      ["sqlite3_rekey_v2", "int", "sqlite3*", "string", "*", "int"],
+      ["sqlite3_activate_see", undefined, "string"]
+    );
+  }
+//#endif enable-see
+
+  /**
+     Functions which require BigInt (int64) support are separated from
+     the others because we need to conditionally bind them or apply
+     dummy impls, depending on the capabilities of the environment.
+     (That said: we never actually build without BigInt support,
+     and such builds are untested.)
+
+     Note that not all of these functions directly require int64
+     but are only for use with APIs which require int64. For example,
+     the vtab-related functions.
+  */
+  wasm.bindingSignatures.int64 = [
+    ["sqlite3_bind_int64","int", ["sqlite3_stmt*", "int", "i64"]],
+    ["sqlite3_changes64","i64", ["sqlite3*"]],
+    ["sqlite3_column_int64","i64", ["sqlite3_stmt*", "int"]],
+    ["sqlite3_deserialize", "int", "sqlite3*", "string", "*", "i64", "i64", "int"]
+    /* Careful! Short version: de/serialize() are problematic because they
+       might use a different allocator than the user for managing the
+       deserialized block. de/serialize() are ONLY safe to use with
+       sqlite3_malloc(), sqlite3_free(), and its 64-bit variants. Because
+       of this, the canonical builds of sqlite3.wasm/js guarantee that
+       sqlite3.wasm.alloc() and friends use those allocators. Custom builds
+       may not guarantee that, however. */,
+    ["sqlite3_last_insert_rowid", "i64", ["sqlite3*"]],
+    ["sqlite3_malloc64", "*","i64"],
+    ["sqlite3_msize", "i64", "*"],
+    ["sqlite3_overload_function", "int", ["sqlite3*","string","int"]],
+    ["sqlite3_realloc64", "*","*", "i64"],
+    ["sqlite3_result_int64", undefined, "*", "i64"],
+    ["sqlite3_result_zeroblob64", "int", "*", "i64"],
+    ["sqlite3_serialize","*", "sqlite3*", "string", "*", "int"],
+    ["sqlite3_set_last_insert_rowid", undefined, ["sqlite3*", "i64"]],
+    ["sqlite3_status64", "int", "int", "*", "*", "int"],
+    ["sqlite3_total_changes64", "i64", ["sqlite3*"]],
+    ["sqlite3_update_hook", "*", [
+      "sqlite3*",
+      new wasm.xWrap.FuncPtrAdapter({
+        name: 'sqlite3_update_hook',
+        signature: "v(iippj)",
+        contextKey: (argv)=>argv[0/* sqlite3* */],
+        callProxy: (callback)=>{
+          return (p,op,z0,z1,rowid)=>{
+            callback(p, op, wasm.cstrToJs(z0), wasm.cstrToJs(z1), rowid);
+          };
+        }
+      }),
+      "*"
+    ]],
+    ["sqlite3_uri_int64", "i64", ["sqlite3_filename", "string", "i64"]],
+    ["sqlite3_value_int64","i64", "sqlite3_value*"]
+  ];
+
+  if( wasm.bigIntEnabled && !!wasm.exports.sqlite3_declare_vtab ){
+    wasm.bindingSignatures.int64.push(
+      ["sqlite3_create_module", "int",
+       ["sqlite3*","string","sqlite3_module*","*"]],
+      ["sqlite3_create_module_v2", "int",
+       ["sqlite3*","string","sqlite3_module*","*","*"]],
+      ["sqlite3_declare_vtab", "int", ["sqlite3*", "string:flexible"]],
+      ["sqlite3_drop_modules", "int", ["sqlite3*", "**"]],
+      ["sqlite3_vtab_collation","string","sqlite3_index_info*","int"],
+      ["sqlite3_vtab_distinct","int", "sqlite3_index_info*"],
+      ["sqlite3_vtab_in","int", "sqlite3_index_info*", "int", "int"],
+      ["sqlite3_vtab_in_first", "int", "sqlite3_value*", "**"],
+      ["sqlite3_vtab_in_next", "int", "sqlite3_value*", "**"],
+      /*["sqlite3_vtab_config" is variadic and requires a hand-written
+        proxy.] */
+      ["sqlite3_vtab_nochange","int", "sqlite3_context*"],
+      ["sqlite3_vtab_on_conflict","int", "sqlite3*"],
+      ["sqlite3_vtab_rhs_value","int", "sqlite3_index_info*", "int", "**"]
+    );
+  }/* virtual table APIs */
+
+  if(wasm.bigIntEnabled && !!wasm.exports.sqlite3_preupdate_hook){
+    wasm.bindingSignatures.int64.push(
+      ["sqlite3_preupdate_blobwrite", "int", "sqlite3*"],
+      ["sqlite3_preupdate_count", "int", "sqlite3*"],
+      ["sqlite3_preupdate_depth", "int", "sqlite3*"],
+      ["sqlite3_preupdate_hook", "*", [
+        "sqlite3*",
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'sqlite3_preupdate_hook',
+          signature: "v(ppippjj)",
+          contextKey: (argv)=>argv[0/* sqlite3* */],
+          callProxy: (callback)=>{
+            return (p,db,op,zDb,zTbl,iKey1,iKey2)=>{
+              callback(p, db, op, wasm.cstrToJs(zDb), wasm.cstrToJs(zTbl),
+                       iKey1, iKey2);
+            };
+          }
+        }),
+        "*"
+      ]],
+      ["sqlite3_preupdate_new", "int", ["sqlite3*", "int", "**"]],
+      ["sqlite3_preupdate_old", "int", ["sqlite3*", "int", "**"]]
+    );
+  } /* preupdate API */
+
+  // Add session/changeset APIs...
+  if(wasm.bigIntEnabled
+     && !!wasm.exports.sqlite3changegroup_add
+     && !!wasm.exports.sqlite3session_create
+     && !!wasm.exports.sqlite3_preupdate_hook /* required by the session API */){
+    /**
+       FuncPtrAdapter options for session-related callbacks with the
+       native signature "i(ps)". This proxy converts the 2nd argument
+       from a C string to a JS string before passing the arguments on
+       to the client-provided JS callback.
+    */
+    const __ipsProxy = {
+      signature: 'i(ps)',
+      callProxy:(callback)=>{
+        return (p,s)=>{
+          try{return callback(p, wasm.cstrToJs(s)) | 0}
+          catch(e){return e.resultCode || capi.SQLITE_ERROR}
+        }
+      }
+    };
+
+    wasm.bindingSignatures.int64.push(...[
+      ['sqlite3changegroup_add', 'int', ['sqlite3_changegroup*', 'int', 'void*']],
+      ['sqlite3changegroup_add_strm', 'int', [
+        'sqlite3_changegroup*',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xInput', signature: 'i(ppp)', bindScope: 'transient'
+        }),
+        'void*'
+      ]],
+      ['sqlite3changegroup_delete', undefined, ['sqlite3_changegroup*']],
+      ['sqlite3changegroup_new', 'int', ['**']],
+      ['sqlite3changegroup_output', 'int', ['sqlite3_changegroup*', 'int*', '**']],
+      ['sqlite3changegroup_output_strm', 'int', [
+        'sqlite3_changegroup*',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xOutput', signature: 'i(ppi)', bindScope: 'transient'
+        }),
+        'void*'
+      ]],
+      ['sqlite3changeset_apply', 'int', [
+        'sqlite3*', 'int', 'void*',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xFilter', bindScope: 'transient', ...__ipsProxy
+        }),
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xConflict', signature: 'i(pip)', bindScope: 'transient'
+        }),
+        'void*'
+      ]],
+      ['sqlite3changeset_apply_strm', 'int', [
+        'sqlite3*',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xInput', signature: 'i(ppp)', bindScope: 'transient'
+        }),
+        'void*',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xFilter', bindScope: 'transient', ...__ipsProxy
+        }),
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xConflict', signature: 'i(pip)', bindScope: 'transient'
+        }),
+        'void*'
+      ]],
+      ['sqlite3changeset_apply_v2', 'int', [
+        'sqlite3*', 'int', 'void*',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xFilter', bindScope: 'transient', ...__ipsProxy
+        }),
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xConflict', signature: 'i(pip)', bindScope: 'transient'
+        }),
+        'void*', '**', 'int*', 'int'
+
+      ]],
+      ['sqlite3changeset_apply_v2_strm', 'int', [
+        'sqlite3*',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xInput', signature: 'i(ppp)', bindScope: 'transient'
+        }),
+        'void*',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xFilter', bindScope: 'transient', ...__ipsProxy
+        }),
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xConflict', signature: 'i(pip)', bindScope: 'transient'
+        }),
+        'void*', '**', 'int*', 'int'
+      ]],
+      ['sqlite3changeset_concat', 'int', ['int','void*', 'int', 'void*', 'int*', '**']],
+      ['sqlite3changeset_concat_strm', 'int', [
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xInputA', signature: 'i(ppp)', bindScope: 'transient'
+        }),
+        'void*',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xInputB', signature: 'i(ppp)', bindScope: 'transient'
+        }),
+        'void*',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xOutput', signature: 'i(ppi)', bindScope: 'transient'
+        }),
+        'void*'
+      ]],
+      ['sqlite3changeset_conflict', 'int', ['sqlite3_changeset_iter*', 'int', '**']],
+      ['sqlite3changeset_finalize', 'int', ['sqlite3_changeset_iter*']],
+      ['sqlite3changeset_fk_conflicts', 'int', ['sqlite3_changeset_iter*', 'int*']],
+      ['sqlite3changeset_invert', 'int', ['int', 'void*', 'int*', '**']],
+      ['sqlite3changeset_invert_strm', 'int', [
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xInput', signature: 'i(ppp)', bindScope: 'transient'
+        }),
+        'void*',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xOutput', signature: 'i(ppi)', bindScope: 'transient'
+        }),
+        'void*'
+      ]],
+      ['sqlite3changeset_new', 'int', ['sqlite3_changeset_iter*', 'int', '**']],
+      ['sqlite3changeset_next', 'int', ['sqlite3_changeset_iter*']],
+      ['sqlite3changeset_old', 'int', ['sqlite3_changeset_iter*', 'int', '**']],
+      ['sqlite3changeset_op', 'int', [
+        'sqlite3_changeset_iter*', '**', 'int*', 'int*','int*'
+      ]],
+      ['sqlite3changeset_pk', 'int', ['sqlite3_changeset_iter*', '**', 'int*']],
+      ['sqlite3changeset_start', 'int', ['**', 'int', '*']],
+      ['sqlite3changeset_start_strm', 'int', [
+        '**',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xInput', signature: 'i(ppp)', bindScope: 'transient'
+        }),
+        'void*'
+      ]],
+      ['sqlite3changeset_start_v2', 'int', ['**', 'int', '*', 'int']],
+      ['sqlite3changeset_start_v2_strm', 'int', [
+        '**',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xInput', signature: 'i(ppp)', bindScope: 'transient'
+        }),
+        'void*', 'int'
+      ]],
+      ['sqlite3session_attach', 'int', ['sqlite3_session*', 'string']],
+      ['sqlite3session_changeset', 'int', ['sqlite3_session*', 'int*', '**']],
+      ['sqlite3session_changeset_size', 'i64', ['sqlite3_session*']],
+      ['sqlite3session_changeset_strm', 'int', [
+        'sqlite3_session*',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xOutput', signature: 'i(ppp)', bindScope: 'transient'
+        }),
+        'void*'
+      ]],
+      ['sqlite3session_config', 'int', ['int', 'void*']],
+      ['sqlite3session_create', 'int', ['sqlite3*', 'string', '**']],
+      //sqlite3session_delete() is bound manually
+      ['sqlite3session_diff', 'int', ['sqlite3_session*', 'string', 'string', '**']],
+      ['sqlite3session_enable', 'int', ['sqlite3_session*', 'int']],
+      ['sqlite3session_indirect', 'int', ['sqlite3_session*', 'int']],
+      ['sqlite3session_isempty', 'int', ['sqlite3_session*']],
+      ['sqlite3session_memory_used', 'i64', ['sqlite3_session*']],
+      ['sqlite3session_object_config', 'int', ['sqlite3_session*', 'int', 'void*']],
+      ['sqlite3session_patchset', 'int', ['sqlite3_session*', '*', '**']],
+      ['sqlite3session_patchset_strm', 'int', [
+        'sqlite3_session*',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xOutput', signature: 'i(ppp)', bindScope: 'transient'
+        }),
+        'void*'
+      ]],
+      ['sqlite3session_table_filter', undefined, [
+        'sqlite3_session*',
+        new wasm.xWrap.FuncPtrAdapter({
+          name: 'xFilter', ...__ipsProxy,
+          contextKey: (argv,argIndex)=>argv[0/* (sqlite3_session*) */]
+        }),
+        '*'
+      ]]
+    ]);
+  }/*session/changeset APIs*/
+
+  /**
+     Functions which are intended solely for API-internal use by the
+     WASM components, not client code. These get installed into
+     sqlite3.util. Some of them get exposed to clients via variants
+     in sqlite3_js_...().
+
+     2024-01-11: these were renamed, with two underscores in the
+     prefix, to ensure that clients do not accidentally depend on
+     them.  They have always been documented as internal-use-only, so
+     no clients "should" be depending on the old names.
+  */
+  wasm.bindingSignatures.wasmInternal = [
+    ["sqlite3__wasm_db_reset", "int", "sqlite3*"],
+    ["sqlite3__wasm_db_vfs", "sqlite3_vfs*", "sqlite3*","string"],
+    [/* DO NOT USE. This is deprecated since 2023-08-11 because it can
+        trigger assert() in debug builds when used with file sizes
+        which are not sizes to a multiple of a valid db page size. */
+      "sqlite3__wasm_vfs_create_file", "int", "sqlite3_vfs*","string","*", "int"
+    ],
+    ["sqlite3__wasm_posix_create_file", "int", "string","*", "int"],
+    ["sqlite3__wasm_vfs_unlink", "int", "sqlite3_vfs*","string"],
+    ["sqlite3__wasm_qfmt_token","string:dealloc", "string","int"]
+  ];
+
+  /**
+     Install JS<->C struct bindings for the non-opaque struct types we
+     need... */
+  sqlite3.StructBinder = globalThis.Jaccwabyt({
+    heap: 0 ? wasm.memory : wasm.heap8u,
+    alloc: wasm.alloc,
+    dealloc: wasm.dealloc,
+    bigIntEnabled: wasm.bigIntEnabled,
+    memberPrefix: /* Never change this: this prefix is baked into any
+                     amount of code and client-facing docs. */ '$'
+  });
+  delete globalThis.Jaccwabyt;
+
+  {// wasm.xWrap() bindings...
+
+    /* Convert Arrays and certain TypedArrays to strings for
+       'string:flexible'-type arguments */
+    const __xString = wasm.xWrap.argAdapter('string');
+    wasm.xWrap.argAdapter(
+      'string:flexible', (v)=>__xString(util.flexibleString(v))
+    );
+
+    /**
+       The 'string:static' argument adapter treats its argument as
+       either...
+
+       - WASM pointer: assumed to be a long-lived C-string which gets
+         returned as-is.
+
+       - Anything else: gets coerced to a JS string for use as a map
+         key. If a matching entry is found (as described next), it is
+         returned, else wasm.allocCString() is used to create a a new
+         string, map its pointer to (''+v) for the remainder of the
+         application's life, and returns that pointer value for this
+         call and all future calls which are passed a
+         string-equivalent argument.
+
+       Use case: sqlite3_bind_pointer() and sqlite3_result_pointer()
+       call for "a static string and preferably a string
+       literal." This converter is used to ensure that the string
+       value seen by those functions is long-lived and behaves as they
+       need it to.
+    */
+    wasm.xWrap.argAdapter(
+      'string:static',
+      function(v){
+        if(wasm.isPtr(v)) return v;
+        v = ''+v;
+        let rc = this[v];
+        return rc || (this[v] = wasm.allocCString(v));
+      }.bind(Object.create(null))
+    );
+
+    /**
+       Add some descriptive xWrap() aliases for '*' intended to (A)
+       initially improve readability/correctness of
+       wasm.bindingSignatures and (B) provide automatic conversion
+       from higher-level representations, e.g. capi.sqlite3_vfs to
+       `sqlite3_vfs*` via capi.sqlite3_vfs.pointer.
+    */
+    const __xArgPtr = wasm.xWrap.argAdapter('*');
+    const nilType = function(){
+      /*a class which no value can ever be an instance of*/
+    };
+    wasm.xWrap.argAdapter('sqlite3_filename', __xArgPtr)
+    ('sqlite3_context*', __xArgPtr)
+    ('sqlite3_value*', __xArgPtr)
+    ('void*', __xArgPtr)
+    ('sqlite3_changegroup*', __xArgPtr)
+    ('sqlite3_changeset_iter*', __xArgPtr)
+    ('sqlite3_session*', __xArgPtr)
+    ('sqlite3_stmt*', (v)=>
+      __xArgPtr((v instanceof (sqlite3?.oo1?.Stmt || nilType))
+           ? v.pointer : v))
+    ('sqlite3*', (v)=>
+      __xArgPtr((v instanceof (sqlite3?.oo1?.DB || nilType))
+           ? v.pointer : v))
+    /**
+       `sqlite3_vfs*`:
+
+       - v is-a string: use the result of sqlite3_vfs_find(v) but
+         throw if it returns 0.
+       - v is-a capi.sqlite3_vfs: use v.pointer.
+       - Else return the same as the `'*'` argument conversion.
+    */
+    ('sqlite3_vfs*', (v)=>{
+      if('string'===typeof v){
+        /* A NULL sqlite3_vfs pointer will be treated as the default
+           VFS in many contexts. We specifically do not want that
+           behavior here. */
+        return capi.sqlite3_vfs_find(v)
+          || sqlite3.SQLite3Error.toss(
+            capi.SQLITE_NOTFOUND,
+            "Unknown sqlite3_vfs name:", v
+          );
+      }
+      return __xArgPtr((v instanceof (capi.sqlite3_vfs || nilType))
+                       ? v.pointer : v);
+    });
+    if( wasm.exports.sqlite3_declare_vtab ){
+      wasm.xWrap.argAdapter('sqlite3_index_info*', (v)=>
+        __xArgPtr((v instanceof (capi.sqlite3_index_info || nilType))
+                  ? v.pointer : v))
+      ('sqlite3_module*', (v)=>
+        __xArgPtr((v instanceof (capi.sqlite3_module || nilType))
+                  ? v.pointer : v)
+      );
+    }
+
+    const __xRcPtr = wasm.xWrap.resultAdapter('*');
+    wasm.xWrap.resultAdapter('sqlite3*', __xRcPtr)
+    ('sqlite3_context*', __xRcPtr)
+    ('sqlite3_stmt*', __xRcPtr)
+    ('sqlite3_value*', __xRcPtr)
+    ('sqlite3_vfs*', __xRcPtr)
+    ('void*', __xRcPtr);
+
+    /**
+       Populate api object with sqlite3_...() by binding the "raw" wasm
+       exports into type-converting proxies using wasm.xWrap().
+    */
+    if(0 === wasm.exports.sqlite3_step.length){
+      /* This environment wraps exports in nullary functions, which means
+         we must disable the arg-count validation we otherwise perform
+         on the wrappers. */
+      wasm.xWrap.doArgcCheck = false;
+      sqlite3.config.warn(
+        "Disabling sqlite3.wasm.xWrap.doArgcCheck due to environmental quirks."
+      );
+    }
+    for(const e of wasm.bindingSignatures){
+      capi[e[0]] = wasm.xWrap.apply(null, e);
+    }
+    for(const e of wasm.bindingSignatures.wasmInternal){
+      util[e[0]] = wasm.xWrap.apply(null, e);
+    }
+
+    /* For C API functions which cannot work properly unless
+       wasm.bigIntEnabled is true, install a bogus impl which throws
+       if called when bigIntEnabled is false. The alternative would be
+       to elide these functions altogether, which seems likely to
+       cause more confusion. */
+    const fI64Disabled = function(fname){
+      return ()=>toss(fname+"() is unavailable due to lack",
+                      "of BigInt support in this build.");
+    };
+    for(const e of wasm.bindingSignatures.int64){
+      capi[e[0]] = wasm.bigIntEnabled
+        ? wasm.xWrap.apply(null, e)
+        : fI64Disabled(e[0]);
+    }
+
+    /* There's no need to expose bindingSignatures to clients,
+       implicitly making it part of the public interface. */
+    delete wasm.bindingSignatures;
+
+    if(wasm.exports.sqlite3__wasm_db_error){
+      const __db_err = wasm.xWrap(
+        'sqlite3__wasm_db_error', 'int', 'sqlite3*', 'int', 'string'
+      );
+      /**
+         Sets the given db's error state. Accepts:
+
+         - (sqlite3*, int code, string msg)
+         - (sqlite3*, Error e [,string msg = ''+e])
+
+         If passed a WasmAllocError, the message is ignored and the
+         result code is SQLITE_NOMEM. If passed any other Error type,
+         the result code defaults to SQLITE_ERROR unless the Error
+         object has a resultCode property, in which case that is used
+         (e.g. SQLite3Error has that). If passed a non-WasmAllocError
+         exception, the message string defaults to theError.message.
+
+         Returns the resulting code. Pass (pDb,0,0) to clear the error
+         state.
+       */
+      util.sqlite3__wasm_db_error = function(pDb, resultCode, message){
+        if(resultCode instanceof sqlite3.WasmAllocError){
+          resultCode = capi.SQLITE_NOMEM;
+          message = 0 /*avoid allocating message string*/;
+        }else if(resultCode instanceof Error){
+          message = message || ''+resultCode;
+          resultCode = (resultCode.resultCode || capi.SQLITE_ERROR);
+        }
+        return pDb ? __db_err(pDb, resultCode, message) : resultCode;
+      };
+    }else{
+      util.sqlite3__wasm_db_error = function(pDb,errCode,msg){
+        console.warn("sqlite3__wasm_db_error() is not exported.",arguments);
+        return errCode;
+      };
+    }
+  }/*xWrap() bindings*/
+
+  {/* Import C-level constants and structs... */
+    const cJson = wasm.xCall('sqlite3__wasm_enum_json');
+    if(!cJson){
+      toss("Maintenance required: increase sqlite3__wasm_enum_json()'s",
+           "static buffer size!");
+    }
+    //console.debug('wasm.ctype length =',wasm.cstrlen(cJson));
+    wasm.ctype = JSON.parse(wasm.cstrToJs(cJson));
+    // Groups of SQLITE_xyz macros...
+    const defineGroups = ['access', 'authorizer',
+                          'blobFinalizers', 'changeset',
+                          'config', 'dataTypes',
+                          'dbConfig', 'dbStatus',
+                          'encodings', 'fcntl', 'flock', 'ioCap',
+                          'limits', 'openFlags',
+                          'prepareFlags', 'resultCodes',
+                          'sqlite3Status',
+                          'stmtStatus', 'syncFlags',
+                          'trace', 'txnState', 'udfFlags',
+                          'version' ];
+    if(wasm.bigIntEnabled){
+      defineGroups.push('serialize', 'session', 'vtab');
+    }
+    for(const t of defineGroups){
+      for(const e of Object.entries(wasm.ctype[t])){
+        // ^^^ [k,v] there triggers a buggy code transformation via
+        // one of the Emscripten-driven optimizers.
+        capi[e[0]] = e[1];
+      }
+    }
+    if(!wasm.functionEntry(capi.SQLITE_WASM_DEALLOC)){
+      toss("Internal error: cannot resolve exported function",
+           "entry SQLITE_WASM_DEALLOC (=="+capi.SQLITE_WASM_DEALLOC+").");
+    }
+    const __rcMap = Object.create(null);
+    for(const t of ['resultCodes']){
+      for(const e of Object.entries(wasm.ctype[t])){
+        __rcMap[e[1]] = e[0];
+      }
+    }
+    /**
+       For the given integer, returns the SQLITE_xxx result code as a
+       string, or undefined if no such mapping is found.
+    */
+    capi.sqlite3_js_rc_str = (rc)=>__rcMap[rc];
+    /* Bind all registered C-side structs... */
+    const notThese = Object.assign(Object.create(null),{
+      // For each struct to NOT register, map its name to true:
+      WasmTestStruct: true,
+      /* We unregister the kvvfs VFS from Worker threads below. */
+      sqlite3_kvvfs_methods: !util.isUIThread(),
+      /* sqlite3_index_info and friends require int64: */
+      sqlite3_index_info: !wasm.bigIntEnabled,
+      sqlite3_index_constraint: !wasm.bigIntEnabled,
+      sqlite3_index_orderby: !wasm.bigIntEnabled,
+      sqlite3_index_constraint_usage: !wasm.bigIntEnabled
+    });
+    for(const s of wasm.ctype.structs){
+      if(!notThese[s.name]){
+        capi[s.name] = sqlite3.StructBinder(s);
+      }
+    }
+    if(capi.sqlite3_index_info){
+      /* Move these inner structs into sqlite3_index_info.  Binding
+      ** them to WASM requires that we create global-scope structs to
+      ** model them with, but those are no longer needed after we've
+      ** passed them to StructBinder. */
+      for(const k of ['sqlite3_index_constraint',
+                      'sqlite3_index_orderby',
+                      'sqlite3_index_constraint_usage']){
+        capi.sqlite3_index_info[k] = capi[k];
+        delete capi[k];
+      }
+      capi.sqlite3_vtab_config = wasm.xWrap(
+        'sqlite3__wasm_vtab_config','int',[
+          'sqlite3*', 'int', 'int']
+      );
+    }/* end vtab-related setup */
+  }/*end C constant and struct imports*/
+
+  /**
+     Internal helper to assist in validating call argument counts in
+     the hand-written sqlite3_xyz() wrappers. We do this only for
+     consistency with non-special-case wrappings.
+  */
+  const __dbArgcMismatch = (pDb,f,n)=>{
+    return util.sqlite3__wasm_db_error(pDb, capi.SQLITE_MISUSE,
+                                      f+"() requires "+n+" argument"+
+                                      (1===n?"":'s')+".");
+  };
+
+  /** Code duplication reducer for functions which take an encoding
+      argument and require SQLITE_UTF8.  Sets the db error code to
+      SQLITE_FORMAT, installs a descriptive error message,
+      and returns SQLITE_FORMAT. */
+  const __errEncoding = (pDb)=>{
+    return util.sqlite3__wasm_db_error(
+      pDb, capi.SQLITE_FORMAT, "SQLITE_UTF8 is the only supported encoding."
+    );
+  };
+
+  /**
+     __dbCleanupMap is infrastructure for recording registration of
+     UDFs and collations so that sqlite3_close_v2() can clean up any
+     automated JS-to-WASM function conversions installed by those.
+  */
+  const __argPDb = (pDb)=>wasm.xWrap.argAdapter('sqlite3*')(pDb);
+  const __argStr = (str)=>wasm.isPtr(str) ? wasm.cstrToJs(str) : str;
+  const __dbCleanupMap = function(
+    pDb, mode/*0=remove, >0=create if needed, <0=do not create if missing*/
+  ){
+    pDb = __argPDb(pDb);
+    let m = this.dbMap.get(pDb);
+    if(!mode){
+      this.dbMap.delete(pDb);
+      return m;
+    }else if(!m && mode>0){
+      this.dbMap.set(pDb, (m = Object.create(null)));
+    }
+    return m;
+  }.bind(Object.assign(Object.create(null),{
+    dbMap: new Map
+  }));
+
+  __dbCleanupMap.addCollation = function(pDb, name){
+    const m = __dbCleanupMap(pDb, 1);
+    if(!m.collation) m.collation = new Set;
+    m.collation.add(__argStr(name).toLowerCase());
+  };
+
+  __dbCleanupMap._addUDF = function(pDb, name, arity, map){
+    /* Map UDF name to a Set of arity values */
+    name = __argStr(name).toLowerCase();
+    let u = map.get(name);
+    if(!u) map.set(name, (u = new Set));
+    u.add((arity<0) ? -1 : arity);
+  };
+
+  __dbCleanupMap.addFunction = function(pDb, name, arity){
+    const m = __dbCleanupMap(pDb, 1);
+    if(!m.udf) m.udf = new Map;
+    this._addUDF(pDb, name, arity, m.udf);
+  };
+
+  if( wasm.exports.sqlite3_create_window_function ){
+    __dbCleanupMap.addWindowFunc = function(pDb, name, arity){
+      const m = __dbCleanupMap(pDb, 1);
+      if(!m.wudf) m.wudf = new Map;
+      this._addUDF(pDb, name, arity, m.wudf);
+    };
+  }
+
+  /**
+     Intended to be called _only_ from sqlite3_close_v2(),
+     passed its non-0 db argument.
+
+     This function frees up certain automatically-installed WASM
+     function bindings which were installed on behalf of the given db,
+     as those may otherwise leak.
+
+     Notable caveat: this is only ever run via
+     sqlite3.capi.sqlite3_close_v2(). If a client, for whatever
+     reason, uses sqlite3.wasm.exports.sqlite3_close_v2() (the
+     function directly exported from WASM), this cleanup will not
+     happen.
+
+     This is not a silver bullet for avoiding automation-related
+     leaks but represents "an honest effort."
+
+     The issue being addressed here is covered at:
+
+     https://sqlite.org/wasm/doc/trunk/api-c-style.md#convert-func-ptr
+  */
+  __dbCleanupMap.cleanup = function(pDb){
+    pDb = __argPDb(pDb);
+    //wasm.xWrap.FuncPtrAdapter.debugFuncInstall = false;
+    /**
+       Installing NULL functions in the C API will remove those
+       bindings. The FuncPtrAdapter which sits between us and the C
+       API will also treat that as an opportunity to
+       wasm.uninstallFunction() any WASM function bindings it has
+       installed for pDb.
+    */
+    const closeArgs = [pDb];
+    for(const name of [
+      'sqlite3_busy_handler',
+      'sqlite3_commit_hook',
+      'sqlite3_preupdate_hook',
+      'sqlite3_progress_handler',
+      'sqlite3_rollback_hook',
+      'sqlite3_set_authorizer',
+      'sqlite3_trace_v2',
+      'sqlite3_update_hook'
+    ]) {
+      const x = wasm.exports[name];
+      if( !x ){
+        /* assume it was built without this API */
+        continue;
+      }
+      closeArgs.length = x.length/*==argument count*/
+      /* recall that undefined entries translate to 0 when passed to
+         WASM. */;
+      try{ capi[name](...closeArgs) }
+      catch(e){
+        sqlite3.config.warn("close-time call of",name+"(",closeArgs,") threw:",e);
+      }
+    }
+    const m = __dbCleanupMap(pDb, 0);
+    if(!m) return;
+    if(m.collation){
+      for(const name of m.collation){
+        try{
+          capi.sqlite3_create_collation_v2(
+            pDb, name, capi.SQLITE_UTF8, 0, 0, 0
+          );
+        }catch(e){
+          /*ignored*/
+        }
+      }
+      delete m.collation;
+    }
+    let i;
+    for(i = 0; i < 2; ++i){ /* Clean up UDFs... */
+      const fmap = i ? m.wudf : m.udf;
+      if(!fmap) continue;
+      const func = i
+            ? capi.sqlite3_create_window_function
+            : capi.sqlite3_create_function_v2;
+      for(const e of fmap){
+        const name = e[0], arities = e[1];
+        const fargs = [pDb, name, 0/*arity*/, capi.SQLITE_UTF8, 0, 0, 0, 0, 0];
+        if(i) fargs.push(0);
+        for(const arity of arities){
+          try{ fargs[2] = arity; func.apply(null, fargs); }
+          catch(e){/*ignored*/}
+        }
+        arities.clear();
+      }
+      fmap.clear();
+    }
+    delete m.udf;
+    delete m.wudf;
+  }/*__dbCleanupMap.cleanup()*/;
+
+  {/* Binding of sqlite3_close_v2() */
+    const __sqlite3CloseV2 = wasm.xWrap("sqlite3_close_v2", "int", "sqlite3*");
+    capi.sqlite3_close_v2 = function(pDb){
+      if(1!==arguments.length) return __dbArgcMismatch(pDb, 'sqlite3_close_v2', 1);
+      if(pDb){
+        try{__dbCleanupMap.cleanup(pDb)} catch(e){/*ignored*/}
+      }
+      return __sqlite3CloseV2(pDb);
+    };
+  }/*sqlite3_close_v2()*/
+
+  if(capi.sqlite3session_create){
+    const __sqlite3SessionDelete = wasm.xWrap(
+      'sqlite3session_delete', undefined, ['sqlite3_session*']
+    );
+    capi.sqlite3session_delete = function(pSession){
+      if(1!==arguments.length){
+        return __dbArgcMismatch(pDb, 'sqlite3session_delete', 1);
+        /* Yes, we're returning a value from a void function. That seems
+           like the lesser evil compared to not maintaining arg-count
+           consistency as we do with other similar bindings. */
+      }
+      else if(pSession){
+        //wasm.xWrap.FuncPtrAdapter.debugFuncInstall = true;
+        capi.sqlite3session_table_filter(pSession, 0, 0);
+      }
+      __sqlite3SessionDelete(pSession);
+    };
+  }
+
+  {/* Bindings for sqlite3_create_collation[_v2]() */
+    // contextKey() impl for wasm.xWrap.FuncPtrAdapter
+    const contextKey = (argv,argIndex)=>{
+      return 'argv['+argIndex+']:'+argv[0/* sqlite3* */]+
+        ':'+wasm.cstrToJs(argv[1/* collation name */]).toLowerCase()
+    };
+    const __sqlite3CreateCollationV2 = wasm.xWrap(
+      'sqlite3_create_collation_v2', 'int', [
+        'sqlite3*', 'string', 'int', '*',
+        new wasm.xWrap.FuncPtrAdapter({
+          /* int(*xCompare)(void*,int,const void*,int,const void*) */
+          name: 'xCompare', signature: 'i(pipip)', contextKey
+        }),
+        new wasm.xWrap.FuncPtrAdapter({
+          /* void(*xDestroy(void*) */
+          name: 'xDestroy', signature: 'v(p)', contextKey
+        })
+      ]
+    );
+
+    /**
+       Works exactly like C's sqlite3_create_collation_v2() except that:
+
+       1) It returns capi.SQLITE_FORMAT if the 3rd argument contains
+          any encoding-related value other than capi.SQLITE_UTF8.  No
+          other encodings are supported. As a special case, if the
+          bottom 4 bits of that argument are 0, SQLITE_UTF8 is
+          assumed.
+
+       2) It accepts JS functions for its function-pointer arguments,
+          for which it will install WASM-bound proxies. The bindings
+          are "permanent," in that they will stay in the WASM environment
+          until it shuts down unless the client calls this again with the
+          same collation name and a value of 0 or null for the
+          the function pointer(s).
+
+       For consistency with the C API, it requires the same number of
+       arguments. It returns capi.SQLITE_MISUSE if passed any other
+       argument count.
+
+       Returns 0 on success, non-0 on error, in which case the error
+       state of pDb (of type `sqlite3*` or argument-convertible to it)
+       may contain more information.
+    */
+    capi.sqlite3_create_collation_v2 = function(pDb,zName,eTextRep,pArg,xCompare,xDestroy){
+      if(6!==arguments.length) return __dbArgcMismatch(pDb, 'sqlite3_create_collation_v2', 6);
+      else if( 0 === (eTextRep & 0xf) ){
+        eTextRep |= capi.SQLITE_UTF8;
+      }else if( capi.SQLITE_UTF8 !== (eTextRep & 0xf) ){
+        return __errEncoding(pDb);
+      }
+      try{
+        const rc = __sqlite3CreateCollationV2(pDb, zName, eTextRep, pArg, xCompare, xDestroy);
+        if(0===rc && xCompare instanceof Function){
+          __dbCleanupMap.addCollation(pDb, zName);
+        }
+        return rc;
+      }catch(e){
+        return util.sqlite3__wasm_db_error(pDb, e);
+      }
+    };
+
+    capi.sqlite3_create_collation = (pDb,zName,eTextRep,pArg,xCompare)=>{
+      return (5===arguments.length)
+        ? capi.sqlite3_create_collation_v2(pDb,zName,eTextRep,pArg,xCompare,0)
+        : __dbArgcMismatch(pDb, 'sqlite3_create_collation', 5);
+    };
+
+  }/*sqlite3_create_collation() and friends*/
+
+  {/* Special-case handling of sqlite3_create_function_v2()
+      and sqlite3_create_window_function(). */
+    /** FuncPtrAdapter for contextKey() for sqlite3_create_function()
+        and friends. */
+    const contextKey = function(argv,argIndex){
+      return (
+        argv[0/* sqlite3* */]
+          +':'+(argv[2/*number of UDF args*/] < 0 ? -1 : argv[2])
+          +':'+argIndex/*distinct for each xAbc callback type*/
+          +':'+wasm.cstrToJs(argv[1]).toLowerCase()
+      )
+    };
+
+    /**
+       JS proxies for the various sqlite3_create[_window]_function()
+       callbacks, structured in a form usable by wasm.xWrap.FuncPtrAdapter.
+    */
+    const __cfProxy = Object.assign(Object.create(null), {
+      xInverseAndStep: {
+        signature:'v(pip)', contextKey,
+        callProxy: (callback)=>{
+          return (pCtx, argc, pArgv)=>{
+            try{ callback(pCtx, ...capi.sqlite3_values_to_js(argc, pArgv)) }
+            catch(e){ capi.sqlite3_result_error_js(pCtx, e) }
+          };
+        }
+      },
+      xFinalAndValue: {
+        signature:'v(p)', contextKey,
+        callProxy: (callback)=>{
+          return (pCtx)=>{
+            try{ capi.sqlite3_result_js(pCtx, callback(pCtx)) }
+            catch(e){ capi.sqlite3_result_error_js(pCtx, e) }
+          };
+        }
+      },
+      xFunc: {
+        signature:'v(pip)', contextKey,
+        callProxy: (callback)=>{
+          return (pCtx, argc, pArgv)=>{
+            try{
+              capi.sqlite3_result_js(
+                pCtx,
+                callback(pCtx, ...capi.sqlite3_values_to_js(argc, pArgv))
+              );
+            }catch(e){
+              //console.error('xFunc() caught:',e);
+              capi.sqlite3_result_error_js(pCtx, e);
+            }
+          };
+        }
+      },
+      xDestroy: {
+        signature:'v(p)', contextKey,
+        //Arguable: a well-behaved destructor doesn't require a proxy.
+        callProxy: (callback)=>{
+          return (pVoid)=>{
+            try{ callback(pVoid) }
+            catch(e){ console.error("UDF xDestroy method threw:",e) }
+          };
+        }
+      }
+    })/*__cfProxy*/;
+
+    const __sqlite3CreateFunction = wasm.xWrap(
+      "sqlite3_create_function_v2", "int", [
+        "sqlite3*", "string"/*funcName*/, "int"/*nArg*/,
+        "int"/*eTextRep*/, "*"/*pApp*/,
+        new wasm.xWrap.FuncPtrAdapter({name: 'xFunc', ...__cfProxy.xFunc}),
+        new wasm.xWrap.FuncPtrAdapter({name: 'xStep', ...__cfProxy.xInverseAndStep}),
+        new wasm.xWrap.FuncPtrAdapter({name: 'xFinal', ...__cfProxy.xFinalAndValue}),
+        new wasm.xWrap.FuncPtrAdapter({name: 'xDestroy', ...__cfProxy.xDestroy})
+      ]
+    );
+
+    const __sqlite3CreateWindowFunction =
+          wasm.exports.sqlite3_create_window_function
+          ? wasm.xWrap(
+            "sqlite3_create_window_function", "int", [
+              "sqlite3*", "string"/*funcName*/, "int"/*nArg*/,
+              "int"/*eTextRep*/, "*"/*pApp*/,
+              new wasm.xWrap.FuncPtrAdapter({name: 'xStep', ...__cfProxy.xInverseAndStep}),
+              new wasm.xWrap.FuncPtrAdapter({name: 'xFinal', ...__cfProxy.xFinalAndValue}),
+              new wasm.xWrap.FuncPtrAdapter({name: 'xValue', ...__cfProxy.xFinalAndValue}),
+              new wasm.xWrap.FuncPtrAdapter({name: 'xInverse', ...__cfProxy.xInverseAndStep}),
+              new wasm.xWrap.FuncPtrAdapter({name: 'xDestroy', ...__cfProxy.xDestroy})
+            ]
+          )
+          : undefined;
+
+    /* Documented in the api object's initializer. */
+    capi.sqlite3_create_function_v2 = function f(
+      pDb, funcName, nArg, eTextRep, pApp,
+      xFunc,   //void (*xFunc)(sqlite3_context*,int,sqlite3_value**)
+      xStep,   //void (*xStep)(sqlite3_context*,int,sqlite3_value**)
+      xFinal,  //void (*xFinal)(sqlite3_context*)
+      xDestroy //void (*xDestroy)(void*)
+    ){
+      if( f.length!==arguments.length ){
+        return __dbArgcMismatch(pDb,"sqlite3_create_function_v2",f.length);
+      }else if( 0 === (eTextRep & 0xf) ){
+        eTextRep |= capi.SQLITE_UTF8;
+      }else if( capi.SQLITE_UTF8 !== (eTextRep & 0xf) ){
+        return __errEncoding(pDb);
+      }
+      try{
+        const rc = __sqlite3CreateFunction(pDb, funcName, nArg, eTextRep,
+                                           pApp, xFunc, xStep, xFinal, xDestroy);
+        if(0===rc && (xFunc instanceof Function
+                      || xStep instanceof Function
+                      || xFinal instanceof Function
+                      || xDestroy instanceof Function)){
+          __dbCleanupMap.addFunction(pDb, funcName, nArg);
+        }
+        return rc;
+      }catch(e){
+        console.error("sqlite3_create_function_v2() setup threw:",e);
+        return util.sqlite3__wasm_db_error(pDb, e, "Creation of UDF threw: "+e);
+      }
+    };
+
+    /* Documented in the api object's initializer. */
+    capi.sqlite3_create_function = function f(
+      pDb, funcName, nArg, eTextRep, pApp,
+      xFunc, xStep, xFinal
+    ){
+      return (f.length===arguments.length)
+        ? capi.sqlite3_create_function_v2(pDb, funcName, nArg, eTextRep,
+                                          pApp, xFunc, xStep, xFinal, 0)
+        : __dbArgcMismatch(pDb,"sqlite3_create_function",f.length);
+    };
+
+    /* Documented in the api object's initializer. */
+    if( __sqlite3CreateWindowFunction ){
+      capi.sqlite3_create_window_function = function f(
+        pDb, funcName, nArg, eTextRep, pApp,
+        xStep,   //void (*xStep)(sqlite3_context*,int,sqlite3_value**)
+        xFinal,  //void (*xFinal)(sqlite3_context*)
+        xValue,  //void (*xValue)(sqlite3_context*)
+        xInverse,//void (*xInverse)(sqlite3_context*,int,sqlite3_value**)
+        xDestroy //void (*xDestroy)(void*)
+      ){
+        if( f.length!==arguments.length ){
+          return __dbArgcMismatch(pDb,"sqlite3_create_window_function",f.length);
+        }else if( 0 === (eTextRep & 0xf) ){
+          eTextRep |= capi.SQLITE_UTF8;
+        }else if( capi.SQLITE_UTF8 !== (eTextRep & 0xf) ){
+          return __errEncoding(pDb);
+        }
+        try{
+          const rc = __sqlite3CreateWindowFunction(pDb, funcName, nArg, eTextRep,
+                                                   pApp, xStep, xFinal, xValue,
+                                                   xInverse, xDestroy);
+          if(0===rc && (xStep instanceof Function
+                        || xFinal instanceof Function
+                        || xValue instanceof Function
+                        || xInverse instanceof Function
+                        || xDestroy instanceof Function)){
+            __dbCleanupMap.addWindowFunc(pDb, funcName, nArg);
+          }
+          return rc;
+        }catch(e){
+          console.error("sqlite3_create_window_function() setup threw:",e);
+          return util.sqlite3__wasm_db_error(pDb, e, "Creation of UDF threw: "+e);
+        }
+      };
+    }else{
+      delete capi.sqlite3_create_window_function;
+    }
+    /**
+       A _deprecated_ alias for capi.sqlite3_result_js() which
+       predates the addition of that function in the public API.
+    */
+    capi.sqlite3_create_function_v2.udfSetResult =
+      capi.sqlite3_create_function.udfSetResult = capi.sqlite3_result_js;
+    if(capi.sqlite3_create_window_function){
+      capi.sqlite3_create_window_function.udfSetResult = capi.sqlite3_result_js;
+    }
+
+    /**
+       A _deprecated_ alias for capi.sqlite3_values_to_js() which
+       predates the addition of that function in the public API.
+    */
+    capi.sqlite3_create_function_v2.udfConvertArgs =
+      capi.sqlite3_create_function.udfConvertArgs = capi.sqlite3_values_to_js;
+    if(capi.sqlite3_create_window_function){
+      capi.sqlite3_create_window_function.udfConvertArgs = capi.sqlite3_values_to_js;
+    }
+
+    /**
+       A _deprecated_ alias for capi.sqlite3_result_error_js() which
+       predates the addition of that function in the public API.
+    */
+    capi.sqlite3_create_function_v2.udfSetError =
+      capi.sqlite3_create_function.udfSetError = capi.sqlite3_result_error_js;
+    if(capi.sqlite3_create_window_function){
+      capi.sqlite3_create_window_function.udfSetError = capi.sqlite3_result_error_js;
+    }
+
+  }/*sqlite3_create_function_v2() and sqlite3_create_window_function() proxies*/;
+
+  {/* Special-case handling of sqlite3_prepare_v2() and
+      sqlite3_prepare_v3() */
+
+    /**
+       Helper for string:flexible conversions which require a
+       byte-length counterpart argument. Passed a value and its
+       ostensible length, this function returns [V,N], where V is
+       either v or a transformed copy of v and N is either n, -1, or
+       the byte length of v (if it's a byte array or ArrayBuffer).
+    */
+    const __flexiString = (v,n)=>{
+      if('string'===typeof v){
+        n = -1;
+      }else if(util.isSQLableTypedArray(v)){
+        n = v.byteLength;
+        v = util.typedArrayToString(
+          (v instanceof ArrayBuffer) ? new Uint8Array(v) : v
+        );
+      }else if(Array.isArray(v)){
+        v = v.join("");
+        n = -1;
+      }
+      return [v, n];
+    };
+
+    /**
+       Scope-local holder of the two impls of sqlite3_prepare_v2/v3().
+    */
+    const __prepare = {
+      /**
+         This binding expects a JS string as its 2nd argument and
+         null as its final argument. In order to compile multiple
+         statements from a single string, the "full" impl (see
+         below) must be used.
+      */
+      basic: wasm.xWrap('sqlite3_prepare_v3',
+                        "int", ["sqlite3*", "string",
+                                "int"/*ignored for this impl!*/,
+                                "int", "**",
+                                "**"/*MUST be 0 or null or undefined!*/]),
+      /**
+         Impl which requires that the 2nd argument be a pointer
+         to the SQL string, instead of being converted to a
+         string. This variant is necessary for cases where we
+         require a non-NULL value for the final argument
+         (exec()'ing multiple statements from one input
+         string). For simpler cases, where only the first
+         statement in the SQL string is required, the wrapper
+         named sqlite3_prepare_v2() is sufficient and easier to
+         use because it doesn't require dealing with pointers.
+      */
+      full: wasm.xWrap('sqlite3_prepare_v3',
+                       "int", ["sqlite3*", "*", "int", "int",
+                               "**", "**"])
+    };
+
+    /* Documented in the capi object's initializer. */
+    capi.sqlite3_prepare_v3 = function f(pDb, sql, sqlLen, prepFlags, ppStmt, pzTail){
+      if(f.length!==arguments.length){
+        return __dbArgcMismatch(pDb,"sqlite3_prepare_v3",f.length);
+      }
+      const [xSql, xSqlLen] = __flexiString(sql, sqlLen);
+      switch(typeof xSql){
+          case 'string': return __prepare.basic(pDb, xSql, xSqlLen, prepFlags, ppStmt, null);
+          case 'number': return __prepare.full(pDb, xSql, xSqlLen, prepFlags, ppStmt, pzTail);
+          default:
+            return util.sqlite3__wasm_db_error(
+              pDb, capi.SQLITE_MISUSE,
+              "Invalid SQL argument type for sqlite3_prepare_v2/v3()."
+            );
+      }
+    };
+
+    /* Documented in the capi object's initializer. */
+    capi.sqlite3_prepare_v2 = function f(pDb, sql, sqlLen, ppStmt, pzTail){
+      return (f.length===arguments.length)
+        ? capi.sqlite3_prepare_v3(pDb, sql, sqlLen, 0, ppStmt, pzTail)
+        : __dbArgcMismatch(pDb,"sqlite3_prepare_v2",f.length);
+    };
+
+  }/*sqlite3_prepare_v2/v3()*/
+
+  {/*sqlite3_bind_text/blob()*/
+    const __bindText = wasm.xWrap("sqlite3_bind_text", "int", [
+      "sqlite3_stmt*", "int", "string", "int", "*"
+    ]);
+    const __bindBlob = wasm.xWrap("sqlite3_bind_blob", "int", [
+      "sqlite3_stmt*", "int", "*", "int", "*"
+    ]);
+
+    /** Documented in the capi object's initializer. */
+    capi.sqlite3_bind_text = function f(pStmt, iCol, text, nText, xDestroy){
+      if(f.length!==arguments.length){
+        return __dbArgcMismatch(capi.sqlite3_db_handle(pStmt),
+                                "sqlite3_bind_text", f.length);
+      }else if(wasm.isPtr(text) || null===text){
+        return __bindText(pStmt, iCol, text, nText, xDestroy);
+      }else if(text instanceof ArrayBuffer){
+        text = new Uint8Array(text);
+      }else if(Array.isArray(pMem)){
+        text = pMem.join('');
+      }
+      let p, n;
+      try{
+        if(util.isSQLableTypedArray(text)){
+          p = wasm.allocFromTypedArray(text);
+          n = text.byteLength;
+        }else if('string'===typeof text){
+          [p, n] = wasm.allocCString(text);
+        }else{
+          return util.sqlite3__wasm_db_error(
+            capi.sqlite3_db_handle(pStmt), capi.SQLITE_MISUSE,
+            "Invalid 3rd argument type for sqlite3_bind_text()."
+          );
+        }
+        return __bindText(pStmt, iCol, p, n, capi.SQLITE_WASM_DEALLOC);
+      }catch(e){
+        wasm.dealloc(p);
+        return util.sqlite3__wasm_db_error(
+          capi.sqlite3_db_handle(pStmt), e
+        );
+      }
+    }/*sqlite3_bind_text()*/;
+
+    /** Documented in the capi object's initializer. */
+    capi.sqlite3_bind_blob = function f(pStmt, iCol, pMem, nMem, xDestroy){
+      if(f.length!==arguments.length){
+        return __dbArgcMismatch(capi.sqlite3_db_handle(pStmt),
+                                "sqlite3_bind_blob", f.length);
+      }else if(wasm.isPtr(pMem) || null===pMem){
+        return __bindBlob(pStmt, iCol, pMem, nMem, xDestroy);
+      }else if(pMem instanceof ArrayBuffer){
+        pMem = new Uint8Array(pMem);
+      }else if(Array.isArray(pMem)){
+        pMem = pMem.join('');
+      }
+      let p, n;
+      try{
+        if(util.isBindableTypedArray(pMem)){
+          p = wasm.allocFromTypedArray(pMem);
+          n = nMem>=0 ? nMem : pMem.byteLength;
+        }else if('string'===typeof pMem){
+          [p, n] = wasm.allocCString(pMem);
+        }else{
+          return util.sqlite3__wasm_db_error(
+            capi.sqlite3_db_handle(pStmt), capi.SQLITE_MISUSE,
+            "Invalid 3rd argument type for sqlite3_bind_blob()."
+          );
+        }
+        return __bindBlob(pStmt, iCol, p, n, capi.SQLITE_WASM_DEALLOC);
+      }catch(e){
+        wasm.dealloc(p);
+        return util.sqlite3__wasm_db_error(
+          capi.sqlite3_db_handle(pStmt), e
+        );
+      }
+    }/*sqlite3_bind_blob()*/;
+
+  }/*sqlite3_bind_text/blob()*/
+
+  {/* sqlite3_config() */
+    /**
+       Wraps a small subset of the C API's sqlite3_config() options.
+       Unsupported options trigger the return of capi.SQLITE_NOTFOUND.
+       Passing fewer than 2 arguments triggers return of
+       capi.SQLITE_MISUSE.
+    */
+    capi.sqlite3_config = function(op, ...args){
+      if(arguments.length<2) return capi.SQLITE_MISUSE;
+      switch(op){
+          case capi.SQLITE_CONFIG_COVERING_INDEX_SCAN: // 20  /* int */
+          case capi.SQLITE_CONFIG_MEMSTATUS:// 9  /* boolean */
+          case capi.SQLITE_CONFIG_SMALL_MALLOC: // 27  /* boolean */
+          case capi.SQLITE_CONFIG_SORTERREF_SIZE: // 28  /* int nByte */
+          case capi.SQLITE_CONFIG_STMTJRNL_SPILL: // 26  /* int nByte */
+          case capi.SQLITE_CONFIG_URI:// 17  /* int */
+            return wasm.exports.sqlite3__wasm_config_i(op, args[0]);
+          case capi.SQLITE_CONFIG_LOOKASIDE: // 13  /* int int */
+            return wasm.exports.sqlite3__wasm_config_ii(op, args[0], args[1]);
+          case capi.SQLITE_CONFIG_MEMDB_MAXSIZE: // 29  /* sqlite3_int64 */
+            return wasm.exports.sqlite3__wasm_config_j(op, args[0]);
+          case capi.SQLITE_CONFIG_GETMALLOC: // 5 /* sqlite3_mem_methods* */
+          case capi.SQLITE_CONFIG_GETMUTEX: // 11  /* sqlite3_mutex_methods* */
+          case capi.SQLITE_CONFIG_GETPCACHE2: // 19  /* sqlite3_pcache_methods2* */
+          case capi.SQLITE_CONFIG_GETPCACHE: // 15  /* no-op */
+          case capi.SQLITE_CONFIG_HEAP: // 8  /* void*, int nByte, int min */
+          case capi.SQLITE_CONFIG_LOG: // 16  /* xFunc, void* */
+          case capi.SQLITE_CONFIG_MALLOC:// 4  /* sqlite3_mem_methods* */
+          case capi.SQLITE_CONFIG_MMAP_SIZE: // 22  /* sqlite3_int64, sqlite3_int64 */
+          case capi.SQLITE_CONFIG_MULTITHREAD: // 2 /* nil */
+          case capi.SQLITE_CONFIG_MUTEX: // 10  /* sqlite3_mutex_methods* */
+          case capi.SQLITE_CONFIG_PAGECACHE: // 7  /* void*, int sz, int N */
+          case capi.SQLITE_CONFIG_PCACHE2: // 18  /* sqlite3_pcache_methods2* */
+          case capi.SQLITE_CONFIG_PCACHE: // 14  /* no-op */
+          case capi.SQLITE_CONFIG_PCACHE_HDRSZ: // 24  /* int *psz */
+          case capi.SQLITE_CONFIG_PMASZ: // 25  /* unsigned int szPma */
+          case capi.SQLITE_CONFIG_SERIALIZED: // 3 /* nil */
+          case capi.SQLITE_CONFIG_SINGLETHREAD: // 1 /* nil */:
+          case capi.SQLITE_CONFIG_SQLLOG: // 21  /* xSqllog, void* */
+          case capi.SQLITE_CONFIG_WIN32_HEAPSIZE: // 23  /* int nByte */
+          default:
+          /* maintenance note: we specifically do not include
+             SQLITE_CONFIG_ROWID_IN_VIEW here, on the grounds that
+             it's only for legacy support and no apps written with
+             this API require that. */
+            return capi.SQLITE_NOTFOUND;
+      }
+    };
+  }/* sqlite3_config() */
+
+  {/*auto-extension bindings.*/
+    const __autoExtFptr = new Set;
+
+    capi.sqlite3_auto_extension = function(fPtr){
+      if( fPtr instanceof Function ){
+        fPtr = wasm.installFunction('i(ppp)', fPtr);
+      }else if( 1!==arguments.length || !wasm.isPtr(fPtr) ){
+        return capi.SQLITE_MISUSE;
+      }
+      const rc = wasm.exports.sqlite3_auto_extension(fPtr);
+      if( fPtr!==arguments[0] ){
+        if(0===rc) __autoExtFptr.add(fPtr);
+        else wasm.uninstallFunction(fPtr);
+      }
+      return rc;
+    };
+
+    capi.sqlite3_cancel_auto_extension = function(fPtr){
+     /* We do not do an automatic JS-to-WASM function conversion here
+        because it would be senseless: the converted pointer would
+        never possibly match an already-installed one. */;
+      if(!fPtr || 1!==arguments.length || !wasm.isPtr(fPtr)) return 0;
+      return wasm.exports.sqlite3_cancel_auto_extension(fPtr);
+      /* Note that it "cannot happen" that a client passes a pointer which
+         is in __autoExtFptr because __autoExtFptr only contains automatic
+         conversions created inside sqlite3_auto_extension() and
+         never exposed to the client. */
+    };
+
+    capi.sqlite3_reset_auto_extension = function(){
+      wasm.exports.sqlite3_reset_auto_extension();
+      for(const fp of __autoExtFptr) wasm.uninstallFunction(fp);
+      __autoExtFptr.clear();
+    };
+  }/* auto-extension */
+
+  const pKvvfs = capi.sqlite3_vfs_find("kvvfs");
+  if( pKvvfs ){/* kvvfs-specific glue */
+    if(util.isUIThread()){
+      const kvvfsMethods = new capi.sqlite3_kvvfs_methods(
+        wasm.exports.sqlite3__wasm_kvvfs_methods()
+      );
+      delete capi.sqlite3_kvvfs_methods;
+
+      const kvvfsMakeKey = wasm.exports.sqlite3__wasm_kvvfsMakeKeyOnPstack,
+            pstack = wasm.pstack;
+
+      const kvvfsStorage = (zClass)=>
+            ((115/*=='s'*/===wasm.peek(zClass))
+             ? sessionStorage : localStorage);
+
+      /**
+         Implementations for members of the object referred to by
+         sqlite3__wasm_kvvfs_methods(). We swap out the native
+         implementations with these, which use localStorage or
+         sessionStorage for their backing store.
+      */
+      const kvvfsImpls = {
+        xRead: (zClass, zKey, zBuf, nBuf)=>{
+          const stack = pstack.pointer,
+                astack = wasm.scopedAllocPush();
+          try {
+            const zXKey = kvvfsMakeKey(zClass,zKey);
+            if(!zXKey) return -3/*OOM*/;
+            const jKey = wasm.cstrToJs(zXKey);
+            const jV = kvvfsStorage(zClass).getItem(jKey);
+            if(!jV) return -1;
+            const nV = jV.length /* Note that we are relying 100% on v being
+                                    ASCII so that jV.length is equal to the
+                                    C-string's byte length. */;
+            if(nBuf<=0) return nV;
+            else if(1===nBuf){
+              wasm.poke(zBuf, 0);
+              return nV;
+            }
+            const zV = wasm.scopedAllocCString(jV);
+            if(nBuf > nV + 1) nBuf = nV + 1;
+            wasm.heap8u().copyWithin(zBuf, zV, zV + nBuf - 1);
+            wasm.poke(zBuf + nBuf - 1, 0);
+            return nBuf - 1;
+          }catch(e){
+            console.error("kvstorageRead()",e);
+            return -2;
+          }finally{
+            pstack.restore(stack);
+            wasm.scopedAllocPop(astack);
+          }
+        },
+        xWrite: (zClass, zKey, zData)=>{
+          const stack = pstack.pointer;
+          try {
+            const zXKey = kvvfsMakeKey(zClass,zKey);
+            if(!zXKey) return 1/*OOM*/;
+            const jKey = wasm.cstrToJs(zXKey);
+            kvvfsStorage(zClass).setItem(jKey, wasm.cstrToJs(zData));
+            return 0;
+          }catch(e){
+            console.error("kvstorageWrite()",e);
+            return capi.SQLITE_IOERR;
+          }finally{
+            pstack.restore(stack);
+          }
+        },
+        xDelete: (zClass, zKey)=>{
+          const stack = pstack.pointer;
+          try {
+            const zXKey = kvvfsMakeKey(zClass,zKey);
+            if(!zXKey) return 1/*OOM*/;
+            kvvfsStorage(zClass).removeItem(wasm.cstrToJs(zXKey));
+            return 0;
+          }catch(e){
+            console.error("kvstorageDelete()",e);
+            return capi.SQLITE_IOERR;
+          }finally{
+            pstack.restore(stack);
+          }
+        }
+      }/*kvvfsImpls*/;
+      for(const k of Object.keys(kvvfsImpls)){
+        kvvfsMethods[kvvfsMethods.memberKey(k)] =
+          wasm.installFunction(
+            kvvfsMethods.memberSignature(k),
+            kvvfsImpls[k]
+          );
+      }
+    }else{
+      /* Worker thread: unregister kvvfs to avoid it being used
+         for anything other than local/sessionStorage. It "can"
+         be used that way but it's not really intended to be. */
+      capi.sqlite3_vfs_unregister(pKvvfs);
+    }
+  }/*pKvvfs*/
+
+  /* Warn if client-level code makes use of FuncPtrAdapter. */
+  wasm.xWrap.FuncPtrAdapter.warnOnUse = true;
+
+  const StructBinder = sqlite3.StructBinder
+  /* we require a local alias b/c StructBinder is removed from the sqlite3
+     object during the final steps of the API cleanup. */;
+  /**
+     Installs a StructBinder-bound function pointer member of the
+     given name and function in the given StructBinder.StructType
+     target object.
+
+     It creates a WASM proxy for the given function and arranges for
+     that proxy to be cleaned up when tgt.dispose() is called. Throws
+     on the slightest hint of error, e.g. tgt is-not-a StructType,
+     name does not map to a struct-bound member, etc.
+
+     As a special case, if the given function is a pointer, then
+     `wasm.functionEntry()` is used to validate that it is a known
+     function. If so, it is used as-is with no extra level of proxying
+     or cleanup, else an exception is thrown. It is legal to pass a
+     value of 0, indicating a NULL pointer, with the caveat that 0
+     _is_ a legal function pointer in WASM but it will not be accepted
+     as such _here_. (Justification: the function at address zero must
+     be one which initially came from the WASM module, not a method we
+     want to bind to a virtual table or VFS.)
+
+     This function returns a proxy for itself which is bound to tgt
+     and takes 2 args (name,func). That function returns the same
+     thing as this one, permitting calls to be chained.
+
+     If called with only 1 arg, it has no side effects but returns a
+     func with the same signature as described above.
+
+     ACHTUNG: because we cannot generically know how to transform JS
+     exceptions into result codes, the installed functions do no
+     automatic catching of exceptions. It is critical, to avoid
+     undefined behavior in the C layer, that methods mapped via
+     this function do not throw. The exception, as it were, to that
+     rule is...
+
+     If applyArgcCheck is true then each JS function (as opposed to
+     function pointers) gets wrapped in a proxy which asserts that it
+     is passed the expected number of arguments, throwing if the
+     argument count does not match expectations. That is only intended
+     for dev-time usage for sanity checking, and may leave the C
+     environment in an undefined state.
+  */
+  const installMethod = function callee(
+    tgt, name, func, applyArgcCheck = callee.installMethodArgcCheck
+  ){
+    if(!(tgt instanceof StructBinder.StructType)){
+      toss("Usage error: target object is-not-a StructType.");
+    }else if(!(func instanceof Function) && !wasm.isPtr(func)){
+      toss("Usage errror: expecting a Function or WASM pointer to one.");
+    }
+    if(1===arguments.length){
+      return (n,f)=>callee(tgt, n, f, applyArgcCheck);
+    }
+    if(!callee.argcProxy){
+      callee.argcProxy = function(tgt, funcName, func,sig){
+        return function(...args){
+          if(func.length!==arguments.length){
+            toss("Argument mismatch for",
+                 tgt.structInfo.name+"::"+funcName
+                 +": Native signature is:",sig);
+          }
+          return func.apply(this, args);
+        }
+      };
+      /* An ondispose() callback for use with
+         StructBinder-created types. */
+      callee.removeFuncList = function(){
+        if(this.ondispose.__removeFuncList){
+          this.ondispose.__removeFuncList.forEach(
+            (v,ndx)=>{
+              if('number'===typeof v){
+                try{wasm.uninstallFunction(v)}
+                catch(e){/*ignore*/}
+              }
+              /* else it's a descriptive label for the next number in
+                 the list. */
+            }
+          );
+          delete this.ondispose.__removeFuncList;
+        }
+      };
+    }/*static init*/
+    const sigN = tgt.memberSignature(name);
+    if(sigN.length<2){
+      toss("Member",name,"does not have a function pointer signature:",sigN);
+    }
+    const memKey = tgt.memberKey(name);
+    const fProxy = (applyArgcCheck && !wasm.isPtr(func))
+    /** This middle-man proxy is only for use during development, to
+        confirm that we always pass the proper number of
+        arguments. We know that the C-level code will always use the
+        correct argument count. */
+          ? callee.argcProxy(tgt, memKey, func, sigN)
+          : func;
+    if(wasm.isPtr(fProxy)){
+      if(fProxy && !wasm.functionEntry(fProxy)){
+        toss("Pointer",fProxy,"is not a WASM function table entry.");
+      }
+      tgt[memKey] = fProxy;
+    }else{
+      const pFunc = wasm.installFunction(fProxy, tgt.memberSignature(name, true));
+      tgt[memKey] = pFunc;
+      if(!tgt.ondispose || !tgt.ondispose.__removeFuncList){
+        tgt.addOnDispose('ondispose.__removeFuncList handler',
+                         callee.removeFuncList);
+        tgt.ondispose.__removeFuncList = [];
+      }
+      tgt.ondispose.__removeFuncList.push(memKey, pFunc);
+    }
+    return (n,f)=>callee(tgt, n, f, applyArgcCheck);
+  }/*installMethod*/;
+  installMethod.installMethodArgcCheck = false;
+
+  /**
+     Installs methods into the given StructBinder.StructType-type
+     instance. Each entry in the given methods object must map to a
+     known member of the given StructType, else an exception will be
+     triggered.  See installMethod() for more details, including the
+     semantics of the 3rd argument.
+
+     As an exception to the above, if any two or more methods in the
+     2nd argument are the exact same function, installMethod() is
+     _not_ called for the 2nd and subsequent instances, and instead
+     those instances get assigned the same method pointer which is
+     created for the first instance. This optimization is primarily to
+     accommodate special handling of sqlite3_module::xConnect and
+     xCreate methods.
+
+     On success, returns its first argument. Throws on error.
+  */
+  const installMethods = function(
+    structInstance, methods, applyArgcCheck = installMethod.installMethodArgcCheck
+  ){
+    const seen = new Map /* map of <Function, memberName> */;
+    for(const k of Object.keys(methods)){
+      const m = methods[k];
+      const prior = seen.get(m);
+      if(prior){
+        const mkey = structInstance.memberKey(k);
+        structInstance[mkey] = structInstance[structInstance.memberKey(prior)];
+      }else{
+        installMethod(structInstance, k, m, applyArgcCheck);
+        seen.set(m, k);
+      }
+    }
+    return structInstance;
+  };
+
+  /**
+     Equivalent to calling installMethod(this,...arguments) with a
+     first argument of this object. If called with 1 or 2 arguments
+     and the first is an object, it's instead equivalent to calling
+     installMethods(this,...arguments).
+  */
+  StructBinder.StructType.prototype.installMethod = function callee(
+    name, func, applyArgcCheck = installMethod.installMethodArgcCheck
+  ){
+    return (arguments.length < 3 && name && 'object'===typeof name)
+      ? installMethods(this, ...arguments)
+      : installMethod(this, ...arguments);
+  };
+
+  /**
+     Equivalent to calling installMethods() with a first argument
+     of this object.
+  */
+  StructBinder.StructType.prototype.installMethods = function(
+    methods, applyArgcCheck = installMethod.installMethodArgcCheck
+  ){
+    return installMethods(this, methods, applyArgcCheck);
+  };
+
+});

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/sqlite3-opfs-async-proxy.js

@@ -0,0 +1,805 @@
+/*
+  2022-09-16
+
+  The author disclaims copyright to this source code.  In place of a
+  legal notice, here is a blessing:
+
+  *   May you do good and not evil.
+  *   May you find forgiveness for yourself and forgive others.
+  *   May you share freely, never taking more than you give.
+
+  ***********************************************************************
+
+  A Worker which manages asynchronous OPFS handles on behalf of a
+  synchronous API which controls it via a combination of Worker
+  messages, SharedArrayBuffer, and Atomics. It is the asynchronous
+  counterpart of the API defined in sqlite3-vfs-opfs.js.
+
+  Highly indebted to:
+
+  https://github.com/rhashimoto/wa-sqlite/blob/master/src/examples/OriginPrivateFileSystemVFS.js
+
+  for demonstrating how to use the OPFS APIs.
+
+  This file is to be loaded as a Worker. It does not have any direct
+  access to the sqlite3 JS/WASM bits, so any bits which it needs (most
+  notably SQLITE_xxx integer codes) have to be imported into it via an
+  initialization process.
+
+  This file represents an implementation detail of a larger piece of
+  code, and not a public interface. Its details may change at any time
+  and are not intended to be used by any client-level code.
+
+  2022-11-27: Chrome v108 changes some async methods to synchronous, as
+  documented at:
+
+  https://developer.chrome.com/blog/sync-methods-for-accesshandles/
+
+  Firefox v111 and Safari 16.4, both released in March 2023, also
+  include this.
+
+  We cannot change to the sync forms at this point without breaking
+  clients who use Chrome v104-ish or higher. truncate(), getSize(),
+  flush(), and close() are now (as of v108) synchronous. Calling them
+  with an "await", as we have to for the async forms, is still legal
+  with the sync forms but is superfluous. Calling the async forms with
+  theFunc().then(...) is not compatible with the change to
+  synchronous, but we do do not use those APIs that way. i.e. we don't
+  _need_ to change anything for this, but at some point (after Chrome
+  versions (approximately) 104-107 are extinct) should change our
+  usage of those methods to remove the "await".
+*/
+"use strict";
+const wPost = (type,...args)=>postMessage({type, payload:args});
+const installAsyncProxy = function(){
+  const toss = function(...args){throw new Error(args.join(' '))};
+  if(globalThis.window === globalThis){
+    toss("This code cannot run from the main thread.",
+         "Load it as a Worker from a separate Worker.");
+  }else if(!navigator?.storage?.getDirectory){
+    toss("This API requires navigator.storage.getDirectory.");
+  }
+
+  /**
+     Will hold state copied to this object from the syncronous side of
+     this API.
+  */
+  const state = Object.create(null);
+
+  /**
+     verbose:
+
+     0 = no logging output
+     1 = only errors
+     2 = warnings and errors
+     3 = debug, warnings, and errors
+  */
+  state.verbose = 1;
+
+  const loggers = {
+    0:console.error.bind(console),
+    1:console.warn.bind(console),
+    2:console.log.bind(console)
+  };
+  const logImpl = (level,...args)=>{
+    if(state.verbose>level) loggers[level]("OPFS asyncer:",...args);
+  };
+  const log =    (...args)=>logImpl(2, ...args);
+  const warn =   (...args)=>logImpl(1, ...args);
+  const error =  (...args)=>logImpl(0, ...args);
+
+  /**
+     __openFiles is a map of sqlite3_file pointers (integers) to
+     metadata related to a given OPFS file handles. The pointers are, in
+     this side of the interface, opaque file handle IDs provided by the
+     synchronous part of this constellation. Each value is an object
+     with a structure demonstrated in the xOpen() impl.
+  */
+  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.
+
+     Maintenance reminder: if we relinquish auto-locks at the end of the
+     operation which acquires them, we pay a massive performance
+     penalty: speedtest1 benchmarks take up to 4x as long. By delaying
+     the lock release until idle time, the hit is negligible.
+  */
+  const __implicitLocks = new Set();
+
+  /**
+     Expects an OPFS file path. It gets resolved, such that ".."
+     components are properly expanded, and returned. If the 2nd arg is
+     true, the result is returned as an array of path elements, else an
+     absolute path string is returned.
+  */
+  const getResolvedPath = function(filename,splitIt){
+    const p = new URL(
+      filename, 'file://irrelevant'
+    ).pathname;
+    return splitIt ? p.split('/').filter((v)=>!!v) : p;
+  };
+
+  /**
+     Takes the absolute path to a filesystem element. Returns an array
+     of [handleOfContainingDir, filename]. If the 2nd argument is truthy
+     then each directory element leading to the file is created along
+     the way. Throws if any creation or resolution fails.
+  */
+  const getDirForFilename = async function f(absFilename, createDirs = false){
+    const path = getResolvedPath(absFilename, true);
+    const filename = path.pop();
+    let dh = state.rootDir;
+    for(const dirName of path){
+      if(dirName){
+        dh = await dh.getDirectoryHandle(dirName, {create: !!createDirs});
+      }
+    }
+    return [dh, filename];
+  };
+
+  /**
+     If the given file-holding object has a sync handle attached to it,
+     that handle is removed and asynchronously closed. Though it may
+     sound sensible to continue work as soon as the close() returns
+     (noting that it's asynchronous), doing so can cause operations
+     performed soon afterwards, e.g. a call to getSyncHandle(), to fail
+     because they may happen out of order from the close(). OPFS does
+     not guaranty that the actual order of operations is retained in
+     such cases. i.e.  always "await" on the result of this function.
+  */
+  const closeSyncHandle = async (fh)=>{
+    if(fh.syncHandle){
+      log("Closing sync handle for",fh.filenameAbs);
+      const h = fh.syncHandle;
+      delete fh.syncHandle;
+      delete fh.xLock;
+      __implicitLocks.delete(fh.fid);
+      return h.close();
+    }
+  };
+
+  /**
+     A proxy for closeSyncHandle() which is guaranteed to not throw.
+
+     This function is part of a lock/unlock step in functions which
+     require a sync access handle but may be called without xLock()
+     having been called first. Such calls need to release that
+     handle to avoid locking the file for all of time. This is an
+     _attempt_ at reducing cross-tab contention but it may prove
+     to be more of a problem than a solution and may need to be
+     removed.
+  */
+  const closeSyncHandleNoThrow = async (fh)=>{
+    try{await closeSyncHandle(fh)}
+    catch(e){
+      warn("closeSyncHandleNoThrow() ignoring:",e,fh);
+    }
+  };
+
+  /* Release all auto-locks. */
+  const releaseImplicitLocks = async ()=>{
+    if(__implicitLocks.size){
+      /* Release all auto-locks. */
+      for(const fid of __implicitLocks){
+        const fh = __openFiles[fid];
+        await closeSyncHandleNoThrow(fh);
+        log("Auto-unlocked",fid,fh.filenameAbs);
+      }
+    }
+  };
+
+  /**
+     An experiment in improving concurrency by freeing up implicit locks
+     sooner. This is known to impact performance dramatically but it has
+     also shown to improve concurrency considerably.
+
+     If fh.releaseImplicitLocks is truthy and fh is in __implicitLocks,
+     this routine returns closeSyncHandleNoThrow(), else it is a no-op.
+  */
+  const releaseImplicitLock = async (fh)=>{
+    if(fh.releaseImplicitLocks && __implicitLocks.has(fh.fid)){
+      return closeSyncHandleNoThrow(fh);
+    }
+  };
+
+  /**
+     An error class specifically for use with getSyncHandle(), the goal
+     of which is to eventually be able to distinguish unambiguously
+     between locking-related failures and other types, noting that we
+     cannot currently do so because createSyncAccessHandle() does not
+     define its exceptions in the required level of detail.
+
+     2022-11-29: according to:
+
+     https://github.com/whatwg/fs/pull/21
+
+     NoModificationAllowedError will be the standard exception thrown
+     when acquisition of a sync access handle fails due to a locking
+     error. As of this writing, that error type is not visible in the
+     dev console in Chrome v109, nor is it documented in MDN, but an
+     error with that "name" property is being thrown from the OPFS
+     layer.
+  */
+  class GetSyncHandleError extends Error {
+    constructor(errorObject, ...msg){
+      super([
+        ...msg, ': '+errorObject.name+':',
+        errorObject.message
+      ].join(' '), {
+        cause: errorObject
+      });
+      this.name = 'GetSyncHandleError';
+    }
+  };
+
+  /**
+     Attempts to find a suitable SQLITE_xyz result code for Error
+     object e. Returns either such a translation or rc if if it does
+     not know how to translate the exception.
+  */
+  GetSyncHandleError.convertRc = (e,rc)=>{
+    if( e instanceof GetSyncHandleError ){
+      if( e.cause.name==='NoModificationAllowedError'
+        /* Inconsistent exception.name from Chrome/ium with the
+           same exception.message text: */
+          || (e.cause.name==='DOMException'
+              && 0===e.cause.message.indexOf('Access Handles cannot')) ){
+        return state.sq3Codes.SQLITE_BUSY;
+      }else if( 'NotFoundError'===e.cause.name ){
+        /**
+           Maintenance reminder: SQLITE_NOTFOUND, though it looks like
+           a good match, has different semantics than NotFoundError
+           and is not suitable here.
+        */
+        return state.sq3Codes.SQLITE_CANTOPEN;
+      }
+    }else if( 'NotFoundError'===e?.name ){
+      return state.sq3Codes.SQLITE_CANTOPEN;
+    }
+    return rc;
+  };
+
+  /**
+     Returns the sync access handle associated with the given file
+     handle object (which must be a valid handle object, as created by
+     xOpen()), lazily opening it if needed.
+
+     In order to help alleviate cross-tab contention for a dabase, if
+     an exception is thrown while acquiring the handle, this routine
+     will wait briefly and try again, up to some fixed number of
+     times. If acquisition still fails at that point it will give up
+     and propagate the exception. Client-level code will see that as
+     an I/O error.
+
+     2024-06-12: there is a rare race condition here which has been
+     reported a single time:
+
+     https://sqlite.org/forum/forumpost/9ee7f5340802d600
+
+     What appears to be happening is that file we're waiting for a
+     lock on is deleted while we wait. What currently happens here is
+     that a locking exception is thrown but the exception type is
+     NotFoundError. In such cases, we very probably should attempt to
+     re-open/re-create the file an obtain the lock on it (noting that
+     there's another race condition there). That's easy to say but
+     creating a viable test for that condition has proven challenging
+     so far.
+  */
+  const getSyncHandle = async (fh,opName)=>{
+    if(!fh.syncHandle){
+      const t = performance.now();
+      log("Acquiring sync handle for",fh.filenameAbs);
+      const maxTries = 6,
+            msBase = state.asyncIdleWaitTime * 2;
+      let i = 1, ms = msBase;
+      for(; true; ms = msBase * ++i){
+        try {
+          //if(i<3) toss("Just testing getSyncHandle() wait-and-retry.");
+          //TODO? A config option which tells it to throw here
+          //randomly every now and then, for testing purposes.
+          fh.syncHandle = await fh.fileHandle.createSyncAccessHandle();
+          break;
+        }catch(e){
+          if(i === maxTries){
+            throw new GetSyncHandleError(
+              e, "Error getting sync handle for",opName+"().",maxTries,
+              "attempts failed.",fh.filenameAbs
+            );
+          }
+          warn("Error getting sync handle for",opName+"(). Waiting",ms,
+               "ms and trying again.",fh.filenameAbs,e);
+          Atomics.wait(state.sabOPView, state.opIds.retry, 0, ms);
+        }
+      }
+      log("Got",opName+"() sync handle for",fh.filenameAbs,
+          'in',performance.now() - t,'ms');
+      if(!fh.xLock){
+        __implicitLocks.add(fh.fid);
+        log("Acquired implicit lock for",opName+"()",fh.fid,fh.filenameAbs);
+      }
+    }
+    return fh.syncHandle;
+  };
+
+  /**
+     Stores the given value at state.sabOPView[state.opIds.rc] and then
+     Atomics.notify()'s it.
+  */
+  const storeAndNotify = (opName, value)=>{
+    log(opName+"() => notify(",value,")");
+    Atomics.store(state.sabOPView, state.opIds.rc, value);
+    Atomics.notify(state.sabOPView, state.opIds.rc);
+  };
+
+  /**
+     Throws if fh is a file-holding object which is flagged as read-only.
+  */
+  const affirmNotRO = function(opName,fh){
+    if(fh.readOnly) toss(opName+"(): File is read-only: "+fh.filenameAbs);
+  };
+
+  /**
+     Gets set to true by the 'opfs-async-shutdown' command to quit the
+     wait loop. This is only intended for debugging purposes: we cannot
+     inspect this file's state while the tight waitLoop() is running and
+     need a way to stop that loop for introspection purposes.
+  */
+  let flagAsyncShutdown = false;
+
+  /**
+     Asynchronous wrappers for sqlite3_vfs and sqlite3_io_methods
+     methods, as well as helpers like mkdir().
+  */
+  const vfsAsyncImpls = {
+    'opfs-async-shutdown': async ()=>{
+      flagAsyncShutdown = true;
+      storeAndNotify('opfs-async-shutdown', 0);
+    },
+    mkdir: async (dirname)=>{
+      let rc = 0;
+      try {
+        await getDirForFilename(dirname+"/filepart", true);
+      }catch(e){
+        state.s11n.storeException(2,e);
+        rc = state.sq3Codes.SQLITE_IOERR;
+      }
+      storeAndNotify('mkdir', rc);
+    },
+    xAccess: async (filename)=>{
+      /* OPFS cannot support the full range of xAccess() queries
+         sqlite3 calls for. We can essentially just tell if the file
+         is accessible, but if it is then it's automatically writable
+         (unless it's locked, which we cannot(?) know without trying
+         to open it). OPFS does not have the notion of read-only.
+
+         The return semantics of this function differ from sqlite3's
+         xAccess semantics because we are limited in what we can
+         communicate back to our synchronous communication partner: 0 =
+         accessible, non-0 means not accessible.
+      */
+      let rc = 0;
+      try{
+        const [dh, fn] = await getDirForFilename(filename);
+        await dh.getFileHandle(fn);
+      }catch(e){
+        state.s11n.storeException(2,e);
+        rc = state.sq3Codes.SQLITE_IOERR;
+      }
+      storeAndNotify('xAccess', rc);
+    },
+    xClose: async function(fid/*sqlite3_file pointer*/){
+      const opName = 'xClose';
+      __implicitLocks.delete(fid);
+      const fh = __openFiles[fid];
+      let rc = 0;
+      if(fh){
+        delete __openFiles[fid];
+        await closeSyncHandle(fh);
+        if(fh.deleteOnClose){
+          try{ await fh.dirHandle.removeEntry(fh.filenamePart) }
+          catch(e){ warn("Ignoring dirHandle.removeEntry() failure of",fh,e) }
+        }
+      }else{
+        state.s11n.serialize();
+        rc = state.sq3Codes.SQLITE_NOTFOUND;
+      }
+      storeAndNotify(opName, rc);
+    },
+    xDelete: async function(...args){
+      const rc = await vfsAsyncImpls.xDeleteNoWait(...args);
+      storeAndNotify('xDelete', rc);
+    },
+    xDeleteNoWait: async function(filename, syncDir = 0, recursive = false){
+      /* The syncDir flag is, for purposes of the VFS API's semantics,
+         ignored here. However, if it has the value 0x1234 then: after
+         deleting the given file, recursively try to delete any empty
+         directories left behind in its wake (ignoring any errors and
+         stopping at the first failure).
+
+         That said: we don't know for sure that removeEntry() fails if
+         the dir is not empty because the API is not documented. It has,
+         however, a "recursive" flag which defaults to false, so
+         presumably it will fail if the dir is not empty and that flag
+         is false.
+      */
+      let rc = 0;
+      try {
+        while(filename){
+          const [hDir, filenamePart] = await getDirForFilename(filename, false);
+          if(!filenamePart) break;
+          await hDir.removeEntry(filenamePart, {recursive});
+          if(0x1234 !== syncDir) break;
+          recursive = false;
+          filename = getResolvedPath(filename, true);
+          filename.pop();
+          filename = filename.join('/');
+        }
+      }catch(e){
+        state.s11n.storeException(2,e);
+        rc = state.sq3Codes.SQLITE_IOERR_DELETE;
+      }
+      return rc;
+    },
+    xFileSize: async function(fid/*sqlite3_file pointer*/){
+      const fh = __openFiles[fid];
+      let rc = 0;
+      try{
+        const sz = await (await getSyncHandle(fh,'xFileSize')).getSize();
+        state.s11n.serialize(Number(sz));
+      }catch(e){
+        state.s11n.storeException(1,e);
+        rc = GetSyncHandleError.convertRc(e,state.sq3Codes.SQLITE_IOERR);
+      }
+      await releaseImplicitLock(fh);
+      storeAndNotify('xFileSize', rc);
+    },
+    xLock: async function(fid/*sqlite3_file pointer*/,
+                          lockType/*SQLITE_LOCK_...*/){
+      const fh = __openFiles[fid];
+      let rc = 0;
+      const oldLockType = fh.xLock;
+      fh.xLock = lockType;
+      if( !fh.syncHandle ){
+        try {
+          await getSyncHandle(fh,'xLock');
+          __implicitLocks.delete(fid);
+        }catch(e){
+          state.s11n.storeException(1,e);
+          rc = GetSyncHandleError.convertRc(e,state.sq3Codes.SQLITE_IOERR_LOCK);
+          fh.xLock = oldLockType;
+        }
+      }
+      storeAndNotify('xLock',rc);
+    },
+    xOpen: async function(fid/*sqlite3_file pointer*/, filename,
+                          flags/*SQLITE_OPEN_...*/,
+                          opfsFlags/*OPFS_...*/){
+      const opName = 'xOpen';
+      const create = (state.sq3Codes.SQLITE_OPEN_CREATE & flags);
+      try{
+        let hDir, filenamePart;
+        try {
+          [hDir, filenamePart] = await getDirForFilename(filename, !!create);
+        }catch(e){
+          state.s11n.storeException(1,e);
+          storeAndNotify(opName, state.sq3Codes.SQLITE_NOTFOUND);
+          return;
+        }
+        if( state.opfsFlags.OPFS_UNLINK_BEFORE_OPEN & opfsFlags ){
+          try{
+            await hDir.removeEntry(filenamePart);
+          }catch(e){
+            /* ignoring */
+            //warn("Ignoring failed Unlink of",filename,":",e);
+          }
+        }
+        const hFile = await hDir.getFileHandle(filenamePart, {create});
+        const fh = Object.assign(Object.create(null),{
+          fid: fid,
+          filenameAbs: filename,
+          filenamePart: filenamePart,
+          dirHandle: hDir,
+          fileHandle: hFile,
+          sabView: state.sabFileBufView,
+          readOnly: !create && !!(state.sq3Codes.SQLITE_OPEN_READONLY & flags),
+          deleteOnClose: !!(state.sq3Codes.SQLITE_OPEN_DELETEONCLOSE & flags)
+        });
+        fh.releaseImplicitLocks =
+          (opfsFlags & state.opfsFlags.OPFS_UNLOCK_ASAP)
+          || state.opfsFlags.defaultUnlockAsap;
+        __openFiles[fid] = fh;
+        storeAndNotify(opName, 0);
+      }catch(e){
+        error(opName,e);
+        state.s11n.storeException(1,e);
+        storeAndNotify(opName, state.sq3Codes.SQLITE_IOERR);
+      }
+    },
+    xRead: async function(fid/*sqlite3_file pointer*/,n,offset64){
+      let rc = 0, nRead;
+      const fh = __openFiles[fid];
+      try{
+        nRead = (await getSyncHandle(fh,'xRead')).read(
+          fh.sabView.subarray(0, n),
+          {at: Number(offset64)}
+        );
+        if(nRead < n){/* Zero-fill remaining bytes */
+          fh.sabView.fill(0, nRead, n);
+          rc = state.sq3Codes.SQLITE_IOERR_SHORT_READ;
+        }
+      }catch(e){
+        error("xRead() failed",e,fh);
+        state.s11n.storeException(1,e);
+        rc = GetSyncHandleError.convertRc(e,state.sq3Codes.SQLITE_IOERR_READ);
+      }
+      await releaseImplicitLock(fh);
+      storeAndNotify('xRead',rc);
+    },
+    xSync: async function(fid/*sqlite3_file pointer*/,flags/*ignored*/){
+      const fh = __openFiles[fid];
+      let rc = 0;
+      if(!fh.readOnly && fh.syncHandle){
+        try {
+          await fh.syncHandle.flush();
+        }catch(e){
+          state.s11n.storeException(2,e);
+          rc = state.sq3Codes.SQLITE_IOERR_FSYNC;
+        }
+      }
+      storeAndNotify('xSync',rc);
+    },
+    xTruncate: async function(fid/*sqlite3_file pointer*/,size){
+      let rc = 0;
+      const fh = __openFiles[fid];
+      try{
+        affirmNotRO('xTruncate', fh);
+        await (await getSyncHandle(fh,'xTruncate')).truncate(size);
+      }catch(e){
+        error("xTruncate():",e,fh);
+        state.s11n.storeException(2,e);
+        rc = GetSyncHandleError.convertRc(e,state.sq3Codes.SQLITE_IOERR_TRUNCATE);
+      }
+      await releaseImplicitLock(fh);
+      storeAndNotify('xTruncate',rc);
+    },
+    xUnlock: async function(fid/*sqlite3_file pointer*/,
+                            lockType/*SQLITE_LOCK_...*/){
+      let rc = 0;
+      const fh = __openFiles[fid];
+      if( fh.syncHandle
+          && state.sq3Codes.SQLITE_LOCK_NONE===lockType
+          /* Note that we do not differentiate between lock types in
+             this VFS. We're either locked or unlocked. */ ){
+        try { await closeSyncHandle(fh) }
+        catch(e){
+          state.s11n.storeException(1,e);
+          rc = state.sq3Codes.SQLITE_IOERR_UNLOCK;
+        }
+      }
+      storeAndNotify('xUnlock',rc);
+    },
+    xWrite: async function(fid/*sqlite3_file pointer*/,n,offset64){
+      let rc;
+      const fh = __openFiles[fid];
+      try{
+        affirmNotRO('xWrite', fh);
+        rc = (
+          n === (await getSyncHandle(fh,'xWrite'))
+            .write(fh.sabView.subarray(0, n),
+                   {at: Number(offset64)})
+        ) ? 0 : state.sq3Codes.SQLITE_IOERR_WRITE;
+      }catch(e){
+        error("xWrite():",e,fh);
+        state.s11n.storeException(1,e);
+        rc = GetSyncHandleError.convertRc(e,state.sq3Codes.SQLITE_IOERR_WRITE);
+      }
+      await releaseImplicitLock(fh);
+      storeAndNotify('xWrite',rc);
+    }
+  }/*vfsAsyncImpls*/;
+
+  const initS11n = ()=>{
+    /**
+       ACHTUNG: this code is 100% duplicated in the other half of this
+       proxy! The documentation is maintained in the "synchronous half".
+    */
+    if(state.s11n) return state.s11n;
+    const textDecoder = new TextDecoder(),
+          textEncoder = new TextEncoder('utf-8'),
+          viewU8 = new Uint8Array(state.sabIO, state.sabS11nOffset, state.sabS11nSize),
+          viewDV = new DataView(state.sabIO, state.sabS11nOffset, state.sabS11nSize);
+    state.s11n = Object.create(null);
+    const TypeIds = Object.create(null);
+    TypeIds.number  = { id: 1, size: 8, getter: 'getFloat64', setter: 'setFloat64' };
+    TypeIds.bigint  = { id: 2, size: 8, getter: 'getBigInt64', setter: 'setBigInt64' };
+    TypeIds.boolean = { id: 3, size: 4, getter: 'getInt32', setter: 'setInt32' };
+    TypeIds.string =  { id: 4 };
+    const getTypeId = (v)=>(
+      TypeIds[typeof v]
+        || toss("Maintenance required: this value type cannot be serialized.",v)
+    );
+    const getTypeIdById = (tid)=>{
+      switch(tid){
+          case TypeIds.number.id: return TypeIds.number;
+          case TypeIds.bigint.id: return TypeIds.bigint;
+          case TypeIds.boolean.id: return TypeIds.boolean;
+          case TypeIds.string.id: return TypeIds.string;
+          default: toss("Invalid type ID:",tid);
+      }
+    };
+    state.s11n.deserialize = function(clear=false){
+      const argc = viewU8[0];
+      const rc = argc ? [] : null;
+      if(argc){
+        const typeIds = [];
+        let offset = 1, i, n, v;
+        for(i = 0; i < argc; ++i, ++offset){
+          typeIds.push(getTypeIdById(viewU8[offset]));
+        }
+        for(i = 0; i < argc; ++i){
+          const t = typeIds[i];
+          if(t.getter){
+            v = viewDV[t.getter](offset, state.littleEndian);
+            offset += t.size;
+          }else{/*String*/
+            n = viewDV.getInt32(offset, state.littleEndian);
+            offset += 4;
+            v = textDecoder.decode(viewU8.slice(offset, offset+n));
+            offset += n;
+          }
+          rc.push(v);
+        }
+      }
+      if(clear) viewU8[0] = 0;
+      //log("deserialize:",argc, rc);
+      return rc;
+    };
+    state.s11n.serialize = function(...args){
+      if(args.length){
+        //log("serialize():",args);
+        const typeIds = [];
+        let i = 0, offset = 1;
+        viewU8[0] = args.length & 0xff /* header = # of args */;
+        for(; i < args.length; ++i, ++offset){
+          /* Write the TypeIds.id value into the next args.length
+             bytes. */
+          typeIds.push(getTypeId(args[i]));
+          viewU8[offset] = typeIds[i].id;
+        }
+        for(i = 0; i < args.length; ++i) {
+          /* Deserialize the following bytes based on their
+             corresponding TypeIds.id from the header. */
+          const t = typeIds[i];
+          if(t.setter){
+            viewDV[t.setter](offset, args[i], state.littleEndian);
+            offset += t.size;
+          }else{/*String*/
+            const s = textEncoder.encode(args[i]);
+            viewDV.setInt32(offset, s.byteLength, state.littleEndian);
+            offset += 4;
+            viewU8.set(s, offset);
+            offset += s.byteLength;
+          }
+        }
+        //log("serialize() result:",viewU8.slice(0,offset));
+      }else{
+        viewU8[0] = 0;
+      }
+    };
+
+    state.s11n.storeException = state.asyncS11nExceptions
+      ? ((priority,e)=>{
+        if(priority<=state.asyncS11nExceptions){
+          state.s11n.serialize([e.name,': ',e.message].join(""));
+        }
+      })
+      : ()=>{};
+
+    return state.s11n;
+  }/*initS11n()*/;
+
+  const waitLoop = async function f(){
+    const opHandlers = Object.create(null);
+    for(let k of Object.keys(state.opIds)){
+      const vi = vfsAsyncImpls[k];
+      if(!vi) continue;
+      const o = Object.create(null);
+      opHandlers[state.opIds[k]] = o;
+      o.key = k;
+      o.f = vi;
+    }
+    while(!flagAsyncShutdown){
+      try {
+        if('not-equal'!==Atomics.wait(
+          state.sabOPView, state.opIds.whichOp, 0, state.asyncIdleWaitTime
+        )){
+          /* Maintenance note: we compare against 'not-equal' because
+
+             https://github.com/tomayac/sqlite-wasm/issues/12
+
+             is reporting that this occassionally, under high loads,
+             returns 'ok', which leads to the whichOp being 0 (which
+             isn't a valid operation ID and leads to an exception,
+             along with a corresponding ugly console log
+             message). Unfortunately, the conditions for that cannot
+             be reliably reproduced. The only place in our code which
+             writes a 0 to the state.opIds.whichOp SharedArrayBuffer
+             index is a few lines down from here, and that instance
+             is required in order for clear communication between
+             the sync half of this proxy and this half.
+          */
+          await releaseImplicitLocks();
+          continue;
+        }
+        const opId = Atomics.load(state.sabOPView, state.opIds.whichOp);
+        Atomics.store(state.sabOPView, state.opIds.whichOp, 0);
+        const hnd = opHandlers[opId] ?? toss("No waitLoop handler for whichOp #",opId);
+        const args = state.s11n.deserialize(
+          true /* clear s11n to keep the caller from confusing this with
+                  an exception string written by the upcoming
+                  operation */
+        ) || [];
+        //warn("waitLoop() whichOp =",opId, hnd, args);
+        if(hnd.f) await hnd.f(...args);
+        else error("Missing callback for opId",opId);
+      }catch(e){
+        error('in waitLoop():',e);
+      }
+    }
+  };
+
+  navigator.storage.getDirectory().then(function(d){
+    state.rootDir = d;
+    globalThis.onmessage = function({data}){
+      switch(data.type){
+          case 'opfs-async-init':{
+            /* Receive shared state from synchronous partner */
+            const opt = data.args;
+            for(const k in opt) state[k] = opt[k];
+            state.verbose = opt.verbose ?? 1;
+            state.sabOPView = new Int32Array(state.sabOP);
+            state.sabFileBufView = new Uint8Array(state.sabIO, 0, state.fileBufferSize);
+            state.sabS11nView = new Uint8Array(state.sabIO, state.sabS11nOffset, state.sabS11nSize);
+            Object.keys(vfsAsyncImpls).forEach((k)=>{
+              if(!Number.isFinite(state.opIds[k])){
+                toss("Maintenance required: missing state.opIds[",k,"]");
+              }
+            });
+            initS11n();
+            log("init state",state);
+            wPost('opfs-async-inited');
+            waitLoop();
+            break;
+          }
+          case 'opfs-async-restart':
+            if(flagAsyncShutdown){
+              warn("Restarting after opfs-async-shutdown. Might or might not work.");
+              flagAsyncShutdown = false;
+              waitLoop();
+            }
+            break;
+      }
+    };
+    wPost('opfs-async-loaded');
+  }).catch((e)=>error("error initializing OPFS asyncer:",e));
+}/*installAsyncProxy()*/;
+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(!globalThis.FileSystemHandle ||
+         !globalThis.FileSystemDirectoryHandle ||
+         !globalThis.FileSystemFileHandle ||
+         !globalThis.FileSystemFileHandle.prototype.createSyncAccessHandle ||
+         !navigator?.storage?.getDirectory){
+  wPost('opfs-unavailable',"Missing required OPFS APIs.");
+}else{
+  installAsyncProxy();
+}

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/sqlite3-vfs-helper.c-pp.js

@@ -0,0 +1,103 @@
+/*
+** 2022-11-30
+**
+** The author disclaims copyright to this source code.  In place of a
+** legal notice, here is a blessing:
+**
+** *   May you do good and not evil.
+** *   May you find forgiveness for yourself and forgive others.
+** *   May you share freely, never taking more than you give.
+*/
+
+/**
+   This file installs sqlite3.vfs, a namespace of helpers for use in
+   the creation of JavaScript implementations of sqlite3_vfs.
+*/
+'use strict';
+globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
+  const wasm = sqlite3.wasm, capi = sqlite3.capi, toss = sqlite3.util.toss3;
+  const vfs = Object.create(null);
+  sqlite3.vfs = vfs;
+
+  /**
+     Uses sqlite3_vfs_register() to register this
+     sqlite3.capi.sqlite3_vfs instance. This object must have already
+     been filled out properly. If the first argument is truthy, the
+     VFS is registered as the default VFS, else it is not.
+
+     On success, returns this object. Throws on error.
+  */
+  capi.sqlite3_vfs.prototype.registerVfs = function(asDefault=false){
+    if(!(this instanceof sqlite3.capi.sqlite3_vfs)){
+      toss("Expecting a sqlite3_vfs-type argument.");
+    }
+    const rc = capi.sqlite3_vfs_register(this, asDefault ? 1 : 0);
+    if(rc){
+      toss("sqlite3_vfs_register(",this,") failed with rc",rc);
+    }
+    if(this.pointer !== capi.sqlite3_vfs_find(this.$zName)){
+      toss("BUG: sqlite3_vfs_find(vfs.$zName) failed for just-installed VFS",
+           this);
+    }
+    return this;
+  };
+
+  /**
+     A wrapper for
+     sqlite3.StructBinder.StructType.prototype.installMethods() or
+     registerVfs() to reduce installation of a VFS and/or its I/O
+     methods to a single call.
+
+     Accepts an object which contains the properties "io" and/or
+     "vfs", each of which is itself an object with following properties:
+
+     - `struct`: an sqlite3.StructBinder.StructType-type struct. This
+       must be a populated (except for the methods) object of type
+       sqlite3_io_methods (for the "io" entry) or sqlite3_vfs (for the
+       "vfs" entry).
+
+     - `methods`: an object mapping sqlite3_io_methods method names
+       (e.g. 'xClose') to JS implementations of those methods. The JS
+       implementations must be call-compatible with their native
+       counterparts.
+
+     For each of those object, this function passes its (`struct`,
+     `methods`, (optional) `applyArgcCheck`) properties to
+     installMethods().
+
+     If the `vfs` entry is set then:
+
+     - Its `struct` property's registerVfs() is called. The
+       `vfs` entry may optionally have an `asDefault` property, which
+       gets passed as the argument to registerVfs().
+
+     - If `struct.$zName` is falsy and the entry has a string-type
+       `name` property, `struct.$zName` is set to the C-string form of
+       that `name` value before registerVfs() is called. That string
+       gets added to the on-dispose state of the struct.
+
+     On success returns this object. Throws on error.
+  */
+  vfs.installVfs = function(opt){
+    let count = 0;
+    const propList = ['io','vfs'];
+    for(const key of propList){
+      const o = opt[key];
+      if(o){
+        ++count;
+        o.struct.installMethods(o.methods, !!o.applyArgcCheck);
+        if('vfs'===key){
+          if(!o.struct.$zName && 'string'===typeof o.name){
+            o.struct.addOnDispose(
+              o.struct.$zName = wasm.allocCString(o.name)
+            );
+          }
+          o.struct.registerVfs(!!o.asDefault);
+        }
+      }
+    }
+    if(!count) toss("Misuse: installVfs() options object requires at least",
+                    "one of:", propList);
+    return this;
+  };
+}/*sqlite3ApiBootstrap.initializers.push()*/);

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/sqlite3-vfs-opfs-sahpool.c-pp.js

@@ -0,0 +1,1301 @@
+//#ifnot target=node
+/*
+  2023-07-14
+
+  The author disclaims copyright to this source code.  In place of a
+  legal notice, here is a blessing:
+
+  *   May you do good and not evil.
+  *   May you find forgiveness for yourself and forgive others.
+  *   May you share freely, never taking more than you give.
+
+  ***********************************************************************
+
+  This file holds a sqlite3_vfs backed by OPFS storage which uses a
+  different implementation strategy than the "opfs" VFS. This one is a
+  port of Roy Hashimoto's OPFS SyncAccessHandle pool:
+
+  https://github.com/rhashimoto/wa-sqlite/blob/master/src/examples/AccessHandlePoolVFS.js
+
+  As described at:
+
+  https://github.com/rhashimoto/wa-sqlite/discussions/67
+
+  with Roy's explicit permission to permit us to port his to our
+  infrastructure rather than having to clean-room reverse-engineer it:
+
+  https://sqlite.org/forum/forumpost/e140d84e71
+
+  Primary differences from the "opfs" VFS include:
+
+  - This one avoids the need for a sub-worker to synchronize
+  communication between the synchronous C API and the
+  only-partly-synchronous OPFS API.
+
+  - It does so by opening a fixed number of OPFS files at
+  library-level initialization time, obtaining SyncAccessHandles to
+  each, and manipulating those handles via the synchronous sqlite3_vfs
+  interface. If it cannot open them (e.g. they are already opened by
+  another tab) then the VFS will not be installed.
+
+  - Because of that, this one lacks all library-level concurrency
+  support.
+
+  - Also because of that, it does not require the SharedArrayBuffer,
+  so can function without the COOP/COEP HTTP response headers.
+
+  - It can hypothetically support Safari 16.4+, whereas the "opfs" VFS
+  requires v17 due to a subworker/storage bug in 16.x which makes it
+  incompatible with that VFS.
+
+  - This VFS requires the "semi-fully-sync" FileSystemSyncAccessHandle
+  (hereafter "SAH") APIs released with Chrome v108 (and all other
+  major browsers released since March 2023). If that API is not
+  detected, the VFS is not registered.
+*/
+globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
+  'use strict';
+  const toss = sqlite3.util.toss;
+  const toss3 = sqlite3.util.toss3;
+  const initPromises = Object.create(null) /* cache of (name:result) of VFS init results */;
+  const capi = sqlite3.capi;
+  const util = sqlite3.util;
+  const wasm = sqlite3.wasm;
+  // Config opts for the VFS...
+  const SECTOR_SIZE = 4096;
+  const HEADER_MAX_PATH_SIZE = 512;
+  const HEADER_FLAGS_SIZE = 4;
+  const HEADER_DIGEST_SIZE = 8;
+  const HEADER_CORPUS_SIZE = HEADER_MAX_PATH_SIZE + HEADER_FLAGS_SIZE;
+  const HEADER_OFFSET_FLAGS = HEADER_MAX_PATH_SIZE;
+  const HEADER_OFFSET_DIGEST = HEADER_CORPUS_SIZE;
+  const HEADER_OFFSET_DATA = SECTOR_SIZE;
+  /* Bitmask of file types which may persist across sessions.
+     SQLITE_OPEN_xyz types not listed here may be inadvertently
+     left in OPFS but are treated as transient by this VFS and
+     they will be cleaned up during VFS init. */
+  const PERSISTENT_FILE_TYPES =
+        capi.SQLITE_OPEN_MAIN_DB |
+        capi.SQLITE_OPEN_MAIN_JOURNAL |
+        capi.SQLITE_OPEN_SUPER_JOURNAL |
+        capi.SQLITE_OPEN_WAL;
+
+  /** Subdirectory of the VFS's space where "opaque" (randomly-named)
+      files are stored. Changing this effectively invalidates the data
+      stored under older names (orphaning it), so don't do that. */
+  const OPAQUE_DIR_NAME = ".opaque";
+
+  /**
+     Returns short a string of random alphanumeric characters
+     suitable for use as a random filename.
+  */
+  const getRandomName = ()=>Math.random().toString(36).slice(2);
+
+  const textDecoder = new TextDecoder();
+  const textEncoder = new TextEncoder();
+
+  const optionDefaults = Object.assign(Object.create(null),{
+    name: 'opfs-sahpool',
+    directory: undefined /* derived from .name */,
+    initialCapacity: 6,
+    clearOnInit: false,
+    /* Logging verbosity 3+ == everything, 2 == warnings+errors, 1 ==
+       errors only. */
+    verbosity: 2,
+    forceReinitIfPreviouslyFailed: false
+  });
+
+  /** Logging routines, from most to least serious. */
+  const loggers = [
+    sqlite3.config.error,
+    sqlite3.config.warn,
+    sqlite3.config.log
+  ];
+  const log = sqlite3.config.log;
+  const warn = sqlite3.config.warn;
+  const error = sqlite3.config.error;
+
+  /* Maps (sqlite3_vfs*) to OpfsSAHPool instances */
+  const __mapVfsToPool = new Map();
+  const getPoolForVfs = (pVfs)=>__mapVfsToPool.get(pVfs);
+  const setPoolForVfs = (pVfs,pool)=>{
+    if(pool) __mapVfsToPool.set(pVfs, pool);
+    else __mapVfsToPool.delete(pVfs);
+  };
+  /* Maps (sqlite3_file*) to OpfsSAHPool instances */
+  const __mapSqlite3File = new Map();
+  const getPoolForPFile = (pFile)=>__mapSqlite3File.get(pFile);
+  const setPoolForPFile = (pFile,pool)=>{
+    if(pool) __mapSqlite3File.set(pFile, pool);
+    else __mapSqlite3File.delete(pFile);
+  };
+
+  /**
+     Impls for the sqlite3_io_methods methods. Maintenance reminder:
+     members are in alphabetical order to simplify finding them.
+  */
+  const ioMethods = {
+    xCheckReservedLock: function(pFile,pOut){
+      const pool = getPoolForPFile(pFile);
+      pool.log('xCheckReservedLock');
+      pool.storeErr();
+      wasm.poke32(pOut, 1);
+      return 0;
+    },
+    xClose: function(pFile){
+      const pool = getPoolForPFile(pFile);
+      pool.storeErr();
+      const file = pool.getOFileForS3File(pFile);
+      if(file) {
+        try{
+          pool.log(`xClose ${file.path}`);
+          pool.mapS3FileToOFile(pFile, false);
+          file.sah.flush();
+          if(file.flags & capi.SQLITE_OPEN_DELETEONCLOSE){
+            pool.deletePath(file.path);
+          }
+        }catch(e){
+          return pool.storeErr(e, capi.SQLITE_IOERR);
+        }
+      }
+      return 0;
+    },
+    xDeviceCharacteristics: function(pFile){
+      return capi.SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;
+    },
+    xFileControl: function(pFile, opId, pArg){
+      return capi.SQLITE_NOTFOUND;
+    },
+    xFileSize: function(pFile,pSz64){
+      const pool = getPoolForPFile(pFile);
+      pool.log(`xFileSize`);
+      const file = pool.getOFileForS3File(pFile);
+      const size = file.sah.getSize() - HEADER_OFFSET_DATA;
+      //log(`xFileSize ${file.path} ${size}`);
+      wasm.poke64(pSz64, BigInt(size));
+      return 0;
+    },
+    xLock: function(pFile,lockType){
+      const pool = getPoolForPFile(pFile);
+      pool.log(`xLock ${lockType}`);
+      pool.storeErr();
+      const file = pool.getOFileForS3File(pFile);
+      file.lockType = lockType;
+      return 0;
+    },
+    xRead: function(pFile,pDest,n,offset64){
+      const pool = getPoolForPFile(pFile);
+      pool.storeErr();
+      const file = pool.getOFileForS3File(pFile);
+      pool.log(`xRead ${file.path} ${n} @ ${offset64}`);
+      try {
+        const nRead = file.sah.read(
+          wasm.heap8u().subarray(pDest, pDest+n),
+          {at: HEADER_OFFSET_DATA + Number(offset64)}
+        );
+        if(nRead < n){
+          wasm.heap8u().fill(0, pDest + nRead, pDest + n);
+          return capi.SQLITE_IOERR_SHORT_READ;
+        }
+        return 0;
+      }catch(e){
+        return pool.storeErr(e, capi.SQLITE_IOERR);
+      }
+    },
+    xSectorSize: function(pFile){
+      return SECTOR_SIZE;
+    },
+    xSync: function(pFile,flags){
+      const pool = getPoolForPFile(pFile);
+      pool.log(`xSync ${flags}`);
+      pool.storeErr();
+      const file = pool.getOFileForS3File(pFile);
+      //log(`xSync ${file.path} ${flags}`);
+      try{
+        file.sah.flush();
+        return 0;
+      }catch(e){
+        return pool.storeErr(e, capi.SQLITE_IOERR);
+      }
+    },
+    xTruncate: function(pFile,sz64){
+      const pool = getPoolForPFile(pFile);
+      pool.log(`xTruncate ${sz64}`);
+      pool.storeErr();
+      const file = pool.getOFileForS3File(pFile);
+      //log(`xTruncate ${file.path} ${iSize}`);
+      try{
+        file.sah.truncate(HEADER_OFFSET_DATA + Number(sz64));
+        return 0;
+      }catch(e){
+        return pool.storeErr(e, capi.SQLITE_IOERR);
+      }
+    },
+    xUnlock: function(pFile,lockType){
+      const pool = getPoolForPFile(pFile);
+      pool.log('xUnlock');
+      const file = pool.getOFileForS3File(pFile);
+      file.lockType = lockType;
+      return 0;
+    },
+    xWrite: function(pFile,pSrc,n,offset64){
+      const pool = getPoolForPFile(pFile);
+      pool.storeErr();
+      const file = pool.getOFileForS3File(pFile);
+      pool.log(`xWrite ${file.path} ${n} ${offset64}`);
+      try{
+        const nBytes = file.sah.write(
+          wasm.heap8u().subarray(pSrc, pSrc+n),
+          { at: HEADER_OFFSET_DATA + Number(offset64) }
+        );
+        return n===nBytes ? 0 : toss("Unknown write() failure.");
+      }catch(e){
+        return pool.storeErr(e, capi.SQLITE_IOERR);
+      }
+    }
+  }/*ioMethods*/;
+
+  const opfsIoMethods = new capi.sqlite3_io_methods();
+  opfsIoMethods.$iVersion = 1;
+  sqlite3.vfs.installVfs({
+    io: {struct: opfsIoMethods, methods: ioMethods}
+  });
+
+  /**
+     Impls for the sqlite3_vfs methods. Maintenance reminder: members
+     are in alphabetical order to simplify finding them.
+  */
+  const vfsMethods = {
+    xAccess: function(pVfs,zName,flags,pOut){
+      //log(`xAccess ${wasm.cstrToJs(zName)}`);
+      const pool = getPoolForVfs(pVfs);
+      pool.storeErr();
+      try{
+        const name = pool.getPath(zName);
+        wasm.poke32(pOut, pool.hasFilename(name) ? 1 : 0);
+      }catch(e){
+        /*ignored*/
+        wasm.poke32(pOut, 0);
+      }
+      return 0;
+    },
+    xCurrentTime: function(pVfs,pOut){
+      wasm.poke(pOut, 2440587.5 + (new Date().getTime()/86400000),
+                'double');
+      return 0;
+    },
+    xCurrentTimeInt64: function(pVfs,pOut){
+      wasm.poke(pOut, (2440587.5 * 86400000) + new Date().getTime(),
+                'i64');
+      return 0;
+    },
+    xDelete: function(pVfs, zName, doSyncDir){
+      const pool = getPoolForVfs(pVfs);
+      pool.log(`xDelete ${wasm.cstrToJs(zName)}`);
+      pool.storeErr();
+      try{
+        pool.deletePath(pool.getPath(zName));
+        return 0;
+      }catch(e){
+        pool.storeErr(e);
+        return capi.SQLITE_IOERR_DELETE;
+      }
+    },
+    xFullPathname: function(pVfs,zName,nOut,pOut){
+      //const pool = getPoolForVfs(pVfs);
+      //pool.log(`xFullPathname ${wasm.cstrToJs(zName)}`);
+      const i = wasm.cstrncpy(pOut, zName, nOut);
+      return i<nOut ? 0 : capi.SQLITE_CANTOPEN;
+    },
+    xGetLastError: function(pVfs,nOut,pOut){
+      const pool = getPoolForVfs(pVfs);
+      const e = pool.popErr();
+      pool.log(`xGetLastError ${nOut} e =`,e);
+      if(e){
+        const scope = wasm.scopedAllocPush();
+        try{
+          const [cMsg, n] = wasm.scopedAllocCString(e.message, true);
+          wasm.cstrncpy(pOut, cMsg, nOut);
+          if(n > nOut) wasm.poke8(pOut + nOut - 1, 0);
+        }catch(e){
+          return capi.SQLITE_NOMEM;
+        }finally{
+          wasm.scopedAllocPop(scope);
+        }
+      }
+      return e ? (e.sqlite3Rc || capi.SQLITE_IOERR) : 0;
+    },
+    //xSleep is optionally defined below
+    xOpen: function f(pVfs, zName, pFile, flags, pOutFlags){
+      const pool = getPoolForVfs(pVfs);
+      try{
+        pool.log(`xOpen ${wasm.cstrToJs(zName)} ${flags}`);
+        // First try to open a path that already exists in the file system.
+        const path = (zName && wasm.peek8(zName))
+              ? pool.getPath(zName)
+              : getRandomName();
+        let sah = pool.getSAHForPath(path);
+        if(!sah && (flags & capi.SQLITE_OPEN_CREATE)) {
+          // File not found so try to create it.
+          if(pool.getFileCount() < pool.getCapacity()) {
+            // Choose an unassociated OPFS file from the pool.
+            sah = pool.nextAvailableSAH();
+            pool.setAssociatedPath(sah, path, flags);
+          }else{
+            // File pool is full.
+            toss('SAH pool is full. Cannot create file',path);
+          }
+        }
+        if(!sah){
+          toss('file not found:',path);
+        }
+        // Subsequent I/O methods are only passed the sqlite3_file
+        // pointer, so map the relevant info we need to that pointer.
+        const file = {path, flags, sah};
+        pool.mapS3FileToOFile(pFile, file);
+        file.lockType = capi.SQLITE_LOCK_NONE;
+        const sq3File = new capi.sqlite3_file(pFile);
+        sq3File.$pMethods = opfsIoMethods.pointer;
+        sq3File.dispose();
+        wasm.poke32(pOutFlags, flags);
+        return 0;
+      }catch(e){
+        pool.storeErr(e);
+        return capi.SQLITE_CANTOPEN;
+      }
+    }/*xOpen()*/
+  }/*vfsMethods*/;
+
+  /**
+     Creates and initializes an sqlite3_vfs instance for an
+     OpfsSAHPool. The argument is the VFS's name (JS string).
+
+     Throws if the VFS name is already registered or if something
+     goes terribly wrong via sqlite3.vfs.installVfs().
+
+     Maintenance reminder: the only detail about the returned object
+     which is specific to any given OpfsSAHPool instance is the $zName
+     member. All other state is identical.
+  */
+  const createOpfsVfs = function(vfsName){
+    if( sqlite3.capi.sqlite3_vfs_find(vfsName)){
+      toss3("VFS name is already registered:", vfsName);
+    }
+    const opfsVfs = new capi.sqlite3_vfs();
+    /* We fetch the default VFS so that we can inherit some
+       methods from it. */
+    const pDVfs = capi.sqlite3_vfs_find(null);
+    const dVfs = pDVfs
+          ? new capi.sqlite3_vfs(pDVfs)
+          : null /* dVfs will be null when sqlite3 is built with
+                    SQLITE_OS_OTHER. */;
+    opfsVfs.$iVersion = 2/*yes, two*/;
+    opfsVfs.$szOsFile = capi.sqlite3_file.structInfo.sizeof;
+    opfsVfs.$mxPathname = HEADER_MAX_PATH_SIZE;
+    opfsVfs.addOnDispose(
+      opfsVfs.$zName = wasm.allocCString(vfsName),
+      ()=>setPoolForVfs(opfsVfs.pointer, 0)
+    );
+
+    if(dVfs){
+      /* Inherit certain VFS members from the default VFS,
+         if available. */
+      opfsVfs.$xRandomness = dVfs.$xRandomness;
+      opfsVfs.$xSleep = dVfs.$xSleep;
+      dVfs.dispose();
+    }
+    if(!opfsVfs.$xRandomness && !vfsMethods.xRandomness){
+      /* If the default VFS has no xRandomness(), add a basic JS impl... */
+      vfsMethods.xRandomness = function(pVfs, nOut, pOut){
+        const heap = wasm.heap8u();
+        let i = 0;
+        for(; i < nOut; ++i) heap[pOut + i] = (Math.random()*255000) & 0xFF;
+        return i;
+      };
+    }
+    if(!opfsVfs.$xSleep && !vfsMethods.xSleep){
+      vfsMethods.xSleep = (pVfs,ms)=>0;
+    }
+    sqlite3.vfs.installVfs({
+      vfs: {struct: opfsVfs, methods: vfsMethods}
+    });
+    return opfsVfs;
+  };
+
+  /**
+     Class for managing OPFS-related state for the
+     OPFS SharedAccessHandle Pool sqlite3_vfs.
+  */
+  class OpfsSAHPool {
+    /* OPFS dir in which VFS metadata is stored. */
+    vfsDir;
+    /* Directory handle to this.vfsDir. */
+    #dhVfsRoot;
+    /* Directory handle to the subdir of this.#dhVfsRoot which holds
+       the randomly-named "opaque" files. This subdir exists in the
+       hope that we can eventually support client-created files in
+       this.#dhVfsRoot. */
+    #dhOpaque;
+    /* Directory handle to this.dhVfsRoot's parent dir. Needed
+       for a VFS-wipe op. */
+    #dhVfsParent;
+    /* Maps SAHs to their opaque file names. */
+    #mapSAHToName = new Map();
+    /* Maps client-side file names to SAHs. */
+    #mapFilenameToSAH = new Map();
+    /* Set of currently-unused SAHs. */
+    #availableSAH = new Set();
+    /* Maps (sqlite3_file*) to xOpen's file objects. */
+    #mapS3FileToOFile_ = new Map();
+
+    /* Maps SAH to an abstract File Object which contains
+       various metadata about that handle. */
+    //#mapSAHToMeta = new Map();
+
+    /** Buffer used by [sg]etAssociatedPath(). */
+    #apBody = new Uint8Array(HEADER_CORPUS_SIZE);
+    // DataView for this.#apBody
+    #dvBody;
+
+    // associated sqlite3_vfs instance
+    #cVfs;
+
+    // Logging verbosity. See optionDefaults.verbosity.
+    #verbosity;
+
+    constructor(options = Object.create(null)){
+      this.#verbosity = options.verbosity ?? optionDefaults.verbosity;
+      this.vfsName = options.name || optionDefaults.name;
+      this.#cVfs = createOpfsVfs(this.vfsName);
+      setPoolForVfs(this.#cVfs.pointer, this);
+      this.vfsDir = options.directory || ("."+this.vfsName);
+      this.#dvBody =
+        new DataView(this.#apBody.buffer, this.#apBody.byteOffset);
+      this.isReady = this
+        .reset(!!(options.clearOnInit ?? optionDefaults.clearOnInit))
+        .then(()=>{
+          if(this.$error) throw this.$error;
+          return this.getCapacity()
+            ? Promise.resolve(undefined)
+            : this.addCapacity(options.initialCapacity
+                               || optionDefaults.initialCapacity);
+        });
+    }
+
+    #logImpl(level,...args){
+      if(this.#verbosity>level) loggers[level](this.vfsName+":",...args);
+    };
+    log(...args){this.#logImpl(2, ...args)};
+    warn(...args){this.#logImpl(1, ...args)};
+    error(...args){this.#logImpl(0, ...args)};
+
+    getVfs(){return this.#cVfs}
+
+    /* Current pool capacity. */
+    getCapacity(){return this.#mapSAHToName.size}
+
+    /* Current number of in-use files from pool. */
+    getFileCount(){return this.#mapFilenameToSAH.size}
+
+    /* Returns an array of the names of all
+       currently-opened client-specified filenames. */
+    getFileNames(){
+      const rc = [];
+      const iter = this.#mapFilenameToSAH.keys();
+      for(const n of iter) rc.push(n);
+      return rc;
+    }
+
+//    #createFileObject(sah,clientName,opaqueName){
+//      const f = Object.assign(Object.create(null),{
+//        clientName, opaqueName
+//      });
+//      this.#mapSAHToMeta.set(sah, f);
+//      return f;
+//    }
+//    #unmapFileObject(sah){
+//      this.#mapSAHToMeta.delete(sah);
+//    }
+
+    /**
+       Adds n files to the pool's capacity. This change is
+       persistent across settings. Returns a Promise which resolves
+       to the new capacity.
+    */
+    async addCapacity(n){
+      for(let i = 0; i < n; ++i){
+        const name = getRandomName();
+        const h = await this.#dhOpaque.getFileHandle(name, {create:true});
+        const ah = await h.createSyncAccessHandle();
+        this.#mapSAHToName.set(ah,name);
+        this.setAssociatedPath(ah, '', 0);
+        //this.#createFileObject(ah,undefined,name);
+      }
+      return this.getCapacity();
+    }
+
+    /**
+       Reduce capacity by n, but can only reduce up to the limit
+       of currently-available SAHs. Returns a Promise which resolves
+       to the number of slots really removed.
+    */
+    async reduceCapacity(n){
+      let nRm = 0;
+      for(const ah of Array.from(this.#availableSAH)){
+        if(nRm === n || this.getFileCount() === this.getCapacity()){
+          break;
+        }
+        const name = this.#mapSAHToName.get(ah);
+        //this.#unmapFileObject(ah);
+        ah.close();
+        await this.#dhOpaque.removeEntry(name);
+        this.#mapSAHToName.delete(ah);
+        this.#availableSAH.delete(ah);
+        ++nRm;
+      }
+      return nRm;
+    }
+
+    /**
+       Releases all currently-opened SAHs. The only legal
+       operation after this is acquireAccessHandles().
+    */
+    releaseAccessHandles(){
+      for(const ah of this.#mapSAHToName.keys()) ah.close();
+      this.#mapSAHToName.clear();
+      this.#mapFilenameToSAH.clear();
+      this.#availableSAH.clear();
+    }
+
+    /**
+       Opens all files under this.vfsDir/this.#dhOpaque and acquires
+       a SAH for each. returns a Promise which resolves to no value
+       but completes once all SAHs are acquired. If acquiring an SAH
+       throws, SAHPool.$error will contain the corresponding
+       exception.
+
+       If clearFiles is true, the client-stored state of each file is
+       cleared when its handle is acquired, including its name, flags,
+       and any data stored after the metadata block.
+    */
+    async acquireAccessHandles(clearFiles){
+      const files = [];
+      for await (const [name,h] of this.#dhOpaque){
+        if('file'===h.kind){
+          files.push([name,h]);
+        }
+      }
+      return Promise.all(files.map(async([name,h])=>{
+        try{
+          const ah = await h.createSyncAccessHandle()
+          this.#mapSAHToName.set(ah, name);
+          if(clearFiles){
+            ah.truncate(HEADER_OFFSET_DATA);
+            this.setAssociatedPath(ah, '', 0);
+          }else{
+            const path = this.getAssociatedPath(ah);
+            if(path){
+              this.#mapFilenameToSAH.set(path, ah);
+            }else{
+              this.#availableSAH.add(ah);
+            }
+          }
+        }catch(e){
+          this.storeErr(e);
+          this.releaseAccessHandles();
+          throw e;
+        }
+      }));
+    }
+
+    /**
+       Given an SAH, returns the client-specified name of
+       that file by extracting it from the SAH's header.
+
+       On error, it disassociates SAH from the pool and
+       returns an empty string.
+    */
+    getAssociatedPath(sah){
+      sah.read(this.#apBody, {at: 0});
+      // Delete any unexpected files left over by previous
+      // untimely errors...
+      const flags = this.#dvBody.getUint32(HEADER_OFFSET_FLAGS);
+      if(this.#apBody[0] &&
+         ((flags & capi.SQLITE_OPEN_DELETEONCLOSE) ||
+          (flags & PERSISTENT_FILE_TYPES)===0)){
+        warn(`Removing file with unexpected flags ${flags.toString(16)}`,
+             this.#apBody);
+        this.setAssociatedPath(sah, '', 0);
+        return '';
+      }
+
+      const fileDigest = new Uint32Array(HEADER_DIGEST_SIZE / 4);
+      sah.read(fileDigest, {at: HEADER_OFFSET_DIGEST});
+      const compDigest = this.computeDigest(this.#apBody);
+      if(fileDigest.every((v,i) => v===compDigest[i])){
+        // Valid digest
+        const pathBytes = this.#apBody.findIndex((v)=>0===v);
+        if(0===pathBytes){
+          // This file is unassociated, so truncate it to avoid
+          // leaving stale db data laying around.
+          sah.truncate(HEADER_OFFSET_DATA);
+        }
+        return pathBytes
+          ? textDecoder.decode(this.#apBody.subarray(0,pathBytes))
+          : '';
+      }else{
+        // Invalid digest
+        warn('Disassociating file with bad digest.');
+        this.setAssociatedPath(sah, '', 0);
+        return '';
+      }
+    }
+
+    /**
+       Stores the given client-defined path and SQLITE_OPEN_xyz flags
+       into the given SAH. If path is an empty string then the file is
+       disassociated from the pool but its previous name is preserved
+       in the metadata.
+    */
+    setAssociatedPath(sah, path, flags){
+      const enc = textEncoder.encodeInto(path, this.#apBody);
+      if(HEADER_MAX_PATH_SIZE <= enc.written + 1/*NUL byte*/){
+        toss("Path too long:",path);
+      }
+      this.#apBody.fill(0, enc.written, HEADER_MAX_PATH_SIZE);
+      this.#dvBody.setUint32(HEADER_OFFSET_FLAGS, flags);
+
+      const digest = this.computeDigest(this.#apBody);
+      sah.write(this.#apBody, {at: 0});
+      sah.write(digest, {at: HEADER_OFFSET_DIGEST});
+      sah.flush();
+
+      if(path){
+        this.#mapFilenameToSAH.set(path, sah);
+        this.#availableSAH.delete(sah);
+      }else{
+        // This is not a persistent file, so eliminate the contents.
+        sah.truncate(HEADER_OFFSET_DATA);
+        this.#availableSAH.add(sah);
+      }
+    }
+
+    /**
+       Computes a digest for the given byte array and returns it as a
+       two-element Uint32Array. This digest gets stored in the
+       metadata for each file as a validation check. Changing this
+       algorithm invalidates all existing databases for this VFS, so
+       don't do that.
+    */
+    computeDigest(byteArray){
+      let h1 = 0xdeadbeef;
+      let h2 = 0x41c6ce57;
+      for(const v of byteArray){
+        h1 = 31 * h1 + (v * 307);
+        h2 = 31 * h2 + (v * 307);
+      }
+      return new Uint32Array([h1>>>0, h2>>>0]);
+    }
+
+    /**
+       Re-initializes the state of the SAH pool, releasing and
+       re-acquiring all handles.
+
+       See acquireAccessHandles() for the specifics of the clearFiles
+       argument.
+    */
+    async reset(clearFiles){
+      await this.isReady;
+      let h = await navigator.storage.getDirectory();
+      let prev, prevName;
+      for(const d of this.vfsDir.split('/')){
+        if(d){
+          prev = h;
+          h = await h.getDirectoryHandle(d,{create:true});
+        }
+      }
+      this.#dhVfsRoot = h;
+      this.#dhVfsParent = prev;
+      this.#dhOpaque = await this.#dhVfsRoot.getDirectoryHandle(
+        OPAQUE_DIR_NAME,{create:true}
+      );
+      this.releaseAccessHandles();
+      return this.acquireAccessHandles(clearFiles);
+    }
+
+    /**
+       Returns the pathname part of the given argument,
+       which may be any of:
+
+       - a URL object
+       - A JS string representing a file name
+       - Wasm C-string representing a file name
+
+       All "../" parts and duplicate slashes are resolve/removed from
+       the returned result.
+    */
+    getPath(arg) {
+      if(wasm.isPtr(arg)) arg = wasm.cstrToJs(arg);
+      return ((arg instanceof URL)
+              ? arg
+              : new URL(arg, 'file://localhost/')).pathname;
+    }
+
+    /**
+       Removes the association of the given client-specified file
+       name (JS string) from the pool. Returns true if a mapping
+       is found, else false.
+    */
+    deletePath(path) {
+      const sah = this.#mapFilenameToSAH.get(path);
+      if(sah) {
+        // Un-associate the name from the SAH.
+        this.#mapFilenameToSAH.delete(path);
+        this.setAssociatedPath(sah, '', 0);
+      }
+      return !!sah;
+    }
+
+    /**
+       Sets e (an Error object) as this object's current error. Pass a
+       falsy (or no) value to clear it. If code is truthy it is
+       assumed to be an SQLITE_xxx result code, defaulting to
+       SQLITE_IOERR if code is falsy.
+
+       Returns the 2nd argument.
+    */
+    storeErr(e,code){
+      if(e){
+        e.sqlite3Rc = code || capi.SQLITE_IOERR;
+        this.error(e);
+      }
+      this.$error = e;
+      return code;
+    }
+    /**
+       Pops this object's Error object and returns
+       it (a falsy value if no error is set).
+    */
+    popErr(){
+      const rc = this.$error;
+      this.$error = undefined;
+      return rc;
+    }
+
+    /**
+       Returns the next available SAH without removing
+       it from the set.
+    */
+    nextAvailableSAH(){
+      const [rc] = this.#availableSAH.keys();
+      return rc;
+    }
+
+    /**
+       Given an (sqlite3_file*), returns the mapped
+       xOpen file object.
+    */
+    getOFileForS3File(pFile){
+      return this.#mapS3FileToOFile_.get(pFile);
+    }
+    /**
+       Maps or unmaps (if file is falsy) the given (sqlite3_file*)
+       to an xOpen file object and to this pool object.
+    */
+    mapS3FileToOFile(pFile,file){
+      if(file){
+        this.#mapS3FileToOFile_.set(pFile, file);
+        setPoolForPFile(pFile, this);
+      }else{
+        this.#mapS3FileToOFile_.delete(pFile);
+        setPoolForPFile(pFile, false);
+      }
+    }
+
+    /**
+       Returns true if the given client-defined file name is in this
+       object's name-to-SAH map.
+    */
+    hasFilename(name){
+      return this.#mapFilenameToSAH.has(name)
+    }
+
+    /**
+       Returns the SAH associated with the given
+       client-defined file name.
+    */
+    getSAHForPath(path){
+      return this.#mapFilenameToSAH.get(path);
+    }
+
+    /**
+       Removes this object's sqlite3_vfs registration and shuts down
+       this object, releasing all handles, mappings, and whatnot,
+       including deleting its data directory. There is currently no
+       way to "revive" the object and reaquire its resources.
+
+       This function is intended primarily for testing.
+
+       Resolves to true if it did its job, false if the
+       VFS has already been shut down.
+    */
+    async removeVfs(){
+      if(!this.#cVfs.pointer || !this.#dhOpaque) return false;
+      capi.sqlite3_vfs_unregister(this.#cVfs.pointer);
+      this.#cVfs.dispose();
+      delete initPromises[this.vfsName];
+      try{
+        this.releaseAccessHandles();
+        await this.#dhVfsRoot.removeEntry(OPAQUE_DIR_NAME, {recursive: true});
+        this.#dhOpaque = undefined;
+        await this.#dhVfsParent.removeEntry(
+          this.#dhVfsRoot.name, {recursive: true}
+        );
+        this.#dhVfsRoot = this.#dhVfsParent = undefined;
+      }catch(e){
+        sqlite3.config.error(this.vfsName,"removeVfs() failed:",e);
+        /*otherwise ignored - there is no recovery strategy*/
+      }
+      return true;
+    }
+
+
+    //! Documented elsewhere in this file.
+    exportFile(name){
+      const sah = this.#mapFilenameToSAH.get(name) || toss("File not found:",name);
+      const n = sah.getSize() - HEADER_OFFSET_DATA;
+      const b = new Uint8Array(n>0 ? n : 0);
+      if(n>0){
+        const nRead = sah.read(b, {at: HEADER_OFFSET_DATA});
+        if(nRead != n){
+          toss("Expected to read "+n+" bytes but read "+nRead+".");
+        }
+      }
+      return b;
+    }
+
+    //! Impl for importDb() when its 2nd arg is a function.
+    async importDbChunked(name, callback){
+      const sah = this.#mapFilenameToSAH.get(name)
+            || this.nextAvailableSAH()
+            || toss("No available handles to import to.");
+      sah.truncate(0);
+      let nWrote = 0, chunk, checkedHeader = false, err = false;
+      try{
+        while( undefined !== (chunk = await callback()) ){
+          if(chunk instanceof ArrayBuffer) chunk = new Uint8Array(chunk);
+          if( 0===nWrote && chunk.byteLength>=15 ){
+            util.affirmDbHeader(chunk);
+            checkedHeader = true;
+          }
+          sah.write(chunk, {at:  HEADER_OFFSET_DATA + nWrote});
+          nWrote += chunk.byteLength;
+        }
+        if( nWrote < 512 || 0!==nWrote % 512 ){
+          toss("Input size",nWrote,"is not correct for an SQLite database.");
+        }
+        if( !checkedHeader ){
+          const header = new Uint8Array(20);
+          sah.read( header, {at: 0} );
+          util.affirmDbHeader( header );
+        }
+        sah.write(new Uint8Array([1,1]), {
+          at: HEADER_OFFSET_DATA + 18
+        }/*force db out of WAL mode*/);
+      }catch(e){
+        this.setAssociatedPath(sah, '', 0);
+        throw e;
+      }
+      this.setAssociatedPath(sah, name, capi.SQLITE_OPEN_MAIN_DB);
+      return nWrote;
+    }
+
+    //! Documented elsewhere in this file.
+    importDb(name, bytes){
+      if( bytes instanceof ArrayBuffer ) bytes = new Uint8Array(bytes);
+      else if( bytes instanceof Function ) return this.importDbChunked(name, bytes);
+      const sah = this.#mapFilenameToSAH.get(name)
+            || this.nextAvailableSAH()
+            || toss("No available handles to import to.");
+      const n = bytes.byteLength;
+      if(n<512 || n%512!=0){
+        toss("Byte array size is invalid for an SQLite db.");
+      }
+      const header = "SQLite format 3";
+      for(let i = 0; i < header.length; ++i){
+        if( header.charCodeAt(i) !== bytes[i] ){
+          toss("Input does not contain an SQLite database header.");
+        }
+      }
+      const nWrote = sah.write(bytes, {at: HEADER_OFFSET_DATA});
+      if(nWrote != n){
+        this.setAssociatedPath(sah, '', 0);
+        toss("Expected to write "+n+" bytes but wrote "+nWrote+".");
+      }else{
+        sah.write(new Uint8Array([1,1]), {at: HEADER_OFFSET_DATA+18}
+                   /* force db out of WAL mode */);
+        this.setAssociatedPath(sah, name, capi.SQLITE_OPEN_MAIN_DB);
+      }
+      return nWrote;
+    }
+
+  }/*class OpfsSAHPool*/;
+
+
+  /**
+     A OpfsSAHPoolUtil instance is exposed to clients in order to
+     manipulate an OpfsSAHPool object without directly exposing that
+     object and allowing for some semantic changes compared to that
+     class.
+
+     Class docs are in the client-level docs for
+     installOpfsSAHPoolVfs().
+  */
+  class OpfsSAHPoolUtil {
+    /* This object's associated OpfsSAHPool. */
+    #p;
+
+    constructor(sahPool){
+      this.#p = sahPool;
+      this.vfsName = sahPool.vfsName;
+    }
+
+    async addCapacity(n){ return this.#p.addCapacity(n) }
+
+    async reduceCapacity(n){ return this.#p.reduceCapacity(n) }
+
+    getCapacity(){ return this.#p.getCapacity(this.#p) }
+
+    getFileCount(){ return this.#p.getFileCount() }
+    getFileNames(){ return this.#p.getFileNames() }
+
+    async reserveMinimumCapacity(min){
+      const c = this.#p.getCapacity();
+      return (c < min) ? this.#p.addCapacity(min - c) : c;
+    }
+
+    exportFile(name){ return this.#p.exportFile(name) }
+
+    importDb(name, bytes){ return this.#p.importDb(name,bytes) }
+
+    async wipeFiles(){ return this.#p.reset(true) }
+
+    unlink(filename){ return this.#p.deletePath(filename) }
+
+    async removeVfs(){ return this.#p.removeVfs() }
+
+  }/* class OpfsSAHPoolUtil */;
+
+  /**
+     Returns a resolved Promise if the current environment
+     has a "fully-sync" SAH impl, else a rejected Promise.
+  */
+  const apiVersionCheck = async ()=>{
+    const dh = await navigator.storage.getDirectory();
+    const fn = '.opfs-sahpool-sync-check-'+getRandomName();
+    const fh = await dh.getFileHandle(fn, { create: true });
+    const ah = await fh.createSyncAccessHandle();
+    const close = ah.close();
+    await close;
+    await dh.removeEntry(fn);
+    if(close?.then){
+      toss("The local OPFS API is too old for opfs-sahpool:",
+           "it has an async FileSystemSyncAccessHandle.close() method.");
+    }
+    return true;
+  };
+
+  /**
+     installOpfsSAHPoolVfs() asynchronously initializes the OPFS
+     SyncAccessHandle (a.k.a. SAH) Pool VFS. It returns a Promise which
+     either resolves to a utility object described below or rejects with
+     an Error value.
+
+     Initialization of this VFS is not automatic because its
+     registration requires that it lock all resources it
+     will potentially use, even if client code does not want
+     to use them. That, in turn, can lead to locking errors
+     when, for example, one page in a given origin has loaded
+     this VFS but does not use it, then another page in that
+     origin tries to use the VFS. If the VFS were automatically
+     registered, the second page would fail to load the VFS
+     due to OPFS locking errors.
+
+     If this function is called more than once with a given "name"
+     option (see below), it will return the same Promise. Calls for
+     different names will return different Promises which resolve to
+     independent objects and refer to different VFS registrations.
+
+     On success, the resulting Promise resolves to a utility object
+     which can be used to query and manipulate the pool. Its API is
+     described at the end of these docs.
+
+     This function accepts an options object to configure certain
+     parts but it is only acknowledged for the very first call and
+     ignored for all subsequent calls.
+
+     The options, in alphabetical order:
+
+     - `clearOnInit`: (default=false) if truthy, contents and filename
+     mapping are removed from each SAH it is acquired during
+     initalization of the VFS, leaving the VFS's storage in a pristine
+     state. Use this only for databases which need not survive a page
+     reload.
+
+     - `initialCapacity`: (default=6) Specifies the default capacity of
+     the VFS. This should not be set unduly high because the VFS has
+     to open (and keep open) a file for each entry in the pool. This
+     setting only has an effect when the pool is initially empty. It
+     does not have any effect if a pool already exists.
+
+     - `directory`: (default="."+`name`) Specifies the OPFS directory
+     name in which to store metadata for the `"opfs-sahpool"`
+     sqlite3_vfs.  Only one instance of this VFS can be installed per
+     JavaScript engine, and any two engines with the same storage
+     directory name will collide with each other, leading to locking
+     errors and the inability to register the VFS in the second and
+     subsequent engine. Using a different directory name for each
+     application enables different engines in the same HTTP origin to
+     co-exist, but their data are invisible to each other. Changing
+     this name will effectively orphan any databases stored under
+     previous names. The default is unspecified but descriptive.  This
+     option may contain multiple path elements, e.g. "foo/bar/baz",
+     and they are created automatically.  In practice there should be
+     no driving need to change this. ACHTUNG: all files in this
+     directory are assumed to be managed by the VFS. Do not place
+     other files in that directory, as they may be deleted or
+     otherwise modified by the VFS.
+
+     - `name`: (default="opfs-sahpool") sets the name to register this
+     VFS under. Normally this should not be changed, but it is
+     possible to register this VFS under multiple names so long as
+     each has its own separate directory to work from. The storage for
+     each is invisible to all others. The name must be a string
+     compatible with `sqlite3_vfs_register()` and friends and suitable
+     for use in URI-style database file names.
+
+     Achtung: if a custom `name` is provided, a custom `directory`
+     must also be provided if any other instance is registered with
+     the default directory. If no directory is explicitly provided
+     then a directory name is synthesized from the `name` option.
+
+
+     - `forceReinitIfPreviouslyFailed`: (default=`false`) Is a fallback option
+     to assist in working around certain flaky environments which may
+     mysteriously fail to permit access to OPFS sync access handles on
+     an initial attempt but permit it on a second attemp. This option
+     should never be used but is provided for those who choose to
+     throw caution to the wind and trust such environments. If this
+     option is truthy _and_ the previous attempt to initialize this
+     VFS with the same `name` failed, the VFS will attempt to
+     initialize a second time instead of returning the cached
+     failure. See discussion at:
+     <https://github.com/sqlite/sqlite-wasm/issues/79>
+
+
+     Peculiarities of this VFS vis a vis other SQLite VFSes:
+
+     - Paths given to it _must_ be absolute. Relative paths will not
+     be properly recognized. This is arguably a bug but correcting it
+     requires some hoop-jumping in routines which have no business
+     doing such tricks.
+
+     - It is possible to install multiple instances under different
+     names, each sandboxed from one another inside their own private
+     directory.  This feature exists primarily as a way for disparate
+     applications within a given HTTP origin to use this VFS without
+     introducing locking issues between them.
+
+
+     The API for the utility object passed on by this function's
+     Promise, in alphabetical order...
+
+     - [async] number addCapacity(n)
+
+     Adds `n` entries to the current pool. This change is persistent
+     across sessions so should not be called automatically at each app
+     startup (but see `reserveMinimumCapacity()`). Its returned Promise
+     resolves to the new capacity.  Because this operation is necessarily
+     asynchronous, the C-level VFS API cannot call this on its own as
+     needed.
+
+     - byteArray exportFile(name)
+
+     Synchronously reads the contents of the given file into a Uint8Array
+     and returns it. This will throw if the given name is not currently
+     in active use or on I/O error. Note that the given name is _not_
+     visible directly in OPFS (or, if it is, it's not from this VFS).
+
+     - number getCapacity()
+
+     Returns the number of files currently contained
+     in the SAH pool. The default capacity is only large enough for one
+     or two databases and their associated temp files.
+
+     - number getFileCount()
+
+     Returns the number of files from the pool currently allocated to
+     slots. This is not the same as the files being "opened".
+
+     - array getFileNames()
+
+     Returns an array of the names of the files currently allocated to
+     slots. This list is the same length as getFileCount().
+
+     - void importDb(name, bytes)
+
+     Imports the contents of an SQLite database, provided as a byte
+     array or ArrayBuffer, under the given name, overwriting any
+     existing content. Throws if the pool has no available file slots,
+     on I/O error, or if the input does not appear to be a
+     database. In the latter case, only a cursory examination is made.
+     Results are undefined if the given db name refers to an opened
+     db.  Note that this routine is _only_ for importing database
+     files, not arbitrary files, the reason being that this VFS will
+     automatically clean up any non-database files so importing them
+     is pointless.
+
+     If passed a function for its second argument, its behavior
+     changes to asynchronous and it imports its data in chunks fed to
+     it by the given callback function. It calls the callback (which
+     may be async) repeatedly, expecting either a Uint8Array or
+     ArrayBuffer (to denote new input) or undefined (to denote
+     EOF). For so long as the callback continues to return
+     non-undefined, it will append incoming data to the given
+     VFS-hosted database file. The result of the resolved Promise when
+     called this way is the size of the resulting database.
+
+     On succes this routine rewrites the database header bytes in the
+     output file (not the input array) to force disabling of WAL mode.
+
+     On a write error, the handle is removed from the pool and made
+     available for re-use.
+
+     - [async] number reduceCapacity(n)
+
+     Removes up to `n` entries from the pool, with the caveat that it can
+     only remove currently-unused entries. It returns a Promise which
+     resolves to the number of entries actually removed.
+
+     - [async] boolean removeVfs()
+
+     Unregisters the opfs-sahpool VFS and removes its directory from OPFS
+     (which means that _all client content_ is removed). After calling
+     this, the VFS may no longer be used and there is no way to re-add it
+     aside from reloading the current JavaScript context.
+
+     Results are undefined if a database is currently in use with this
+     VFS.
+
+     The returned Promise resolves to true if it performed the removal
+     and false if the VFS was not installed.
+
+     If the VFS has a multi-level directory, e.g. "/foo/bar/baz", _only_
+     the bottom-most directory is removed because this VFS cannot know for
+     certain whether the higher-level directories contain data which
+     should be removed.
+
+     - [async] number reserveMinimumCapacity(min)
+
+     If the current capacity is less than `min`, the capacity is
+     increased to `min`, else this returns with no side effects. The
+     resulting Promise resolves to the new capacity.
+
+     - boolean unlink(filename)
+
+     If a virtual file exists with the given name, disassociates it from
+     the pool and returns true, else returns false without side
+     effects. Results are undefined if the file is currently in active
+     use.
+
+     - string vfsName
+
+     The SQLite VFS name under which this pool's VFS is registered.
+
+     - [async] void wipeFiles()
+
+     Clears all client-defined state of all SAHs and makes all of them
+     available for re-use by the pool. Results are undefined if any such
+     handles are currently in use, e.g. by an sqlite3 db.
+  */
+  sqlite3.installOpfsSAHPoolVfs = async function(options=Object.create(null)){
+    options = Object.assign(Object.create(null), optionDefaults, (options||{}));
+    const vfsName = options.name;
+    if(options.$testThrowPhase1){
+      throw options.$testThrowPhase1;
+    }
+    if(initPromises[vfsName]){
+      try {
+        const p = await initPromises[vfsName];
+        //log("installOpfsSAHPoolVfs() returning cached result",options,vfsName,p);
+        return p;
+      }catch(e){
+        //log("installOpfsSAHPoolVfs() got cached failure",options,vfsName,e);
+        if( options.forceReinitIfPreviouslyFailed ){
+          delete initPromises[vfsName];
+          /* Fall through and try again. */
+        }else{
+          throw e;
+        }
+      }
+    }
+    if(!globalThis.FileSystemHandle ||
+       !globalThis.FileSystemDirectoryHandle ||
+       !globalThis.FileSystemFileHandle ||
+       !globalThis.FileSystemFileHandle.prototype.createSyncAccessHandle ||
+       !navigator?.storage?.getDirectory){
+      return (initPromises[vfsName] = Promise.reject(new Error("Missing required OPFS APIs.")));
+    }
+
+    /**
+       Maintenance reminder: the order of ASYNC ops in this function
+       is significant. We need to have them all chained at the very
+       end in order to be able to catch a race condition where
+       installOpfsSAHPoolVfs() is called twice in rapid succession,
+       e.g.:
+
+       installOpfsSAHPoolVfs().then(console.warn.bind(console));
+       installOpfsSAHPoolVfs().then(console.warn.bind(console));
+
+       If the timing of the async calls is not "just right" then that
+       second call can end up triggering the init a second time and chaos
+       ensues.
+    */
+    return initPromises[vfsName] = apiVersionCheck().then(async function(){
+      if(options.$testThrowPhase2){
+        throw options.$testThrowPhase2;
+      }
+      const thePool = new OpfsSAHPool(options);
+      return thePool.isReady.then(async()=>{
+        /** The poolUtil object will be the result of the
+            resolved Promise. */
+        const poolUtil = new OpfsSAHPoolUtil(thePool);
+        if(sqlite3.oo1){
+          const oo1 = sqlite3.oo1;
+          const theVfs = thePool.getVfs();
+          const OpfsSAHPoolDb = function(...args){
+            const opt = oo1.DB.dbCtorHelper.normalizeArgs(...args);
+            opt.vfs = theVfs.$zName;
+            oo1.DB.dbCtorHelper.call(this, opt);
+          };
+          OpfsSAHPoolDb.prototype = Object.create(oo1.DB.prototype);
+          poolUtil.OpfsSAHPoolDb = OpfsSAHPoolDb;
+        }/*extend sqlite3.oo1*/
+        thePool.log("VFS initialized.");
+        return poolUtil;
+      }).catch(async (e)=>{
+        await thePool.removeVfs().catch(()=>{});
+        throw e;
+      });
+    }).catch((err)=>{
+      //error("rejecting promise:",err);
+      return initPromises[vfsName] = Promise.reject(err);
+    });
+  }/*installOpfsSAHPoolVfs()*/;
+}/*sqlite3ApiBootstrap.initializers*/);
+//#else
+/*
+  The OPFS SAH Pool VFS parts are elided from builds targeting
+  node.js.
+*/
+//#endif target=node

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/sqlite3-vtab-helper.c-pp.js

@@ -0,0 +1,427 @@
+/*
+** 2022-11-30
+**
+** The author disclaims copyright to this source code.  In place of a
+** legal notice, here is a blessing:
+**
+** *   May you do good and not evil.
+** *   May you find forgiveness for yourself and forgive others.
+** *   May you share freely, never taking more than you give.
+*/
+
+/**
+   This file installs sqlite3.vtab, a namespace of helpers for use in
+   the creation of JavaScript implementations virtual tables. If built
+   without virtual table support then this function does nothing.
+*/
+'use strict';
+globalThis.sqlite3ApiBootstrap.initializers.push(function(sqlite3){
+  if( !sqlite3.wasm.exports.sqlite3_declare_vtab ){
+    return;
+  }
+  const wasm = sqlite3.wasm, capi = sqlite3.capi, toss = sqlite3.util.toss3;
+  const vtab = Object.create(null);
+  sqlite3.vtab = vtab;
+
+  const sii = capi.sqlite3_index_info;
+  /**
+     If n is >=0 and less than this.$nConstraint, this function
+     returns either a WASM pointer to the 0-based nth entry of
+     this.$aConstraint (if passed a truthy 2nd argument) or an
+     sqlite3_index_info.sqlite3_index_constraint object wrapping that
+     address (if passed a falsy value or no 2nd argument). Returns a
+     falsy value if n is out of range.
+  */
+  sii.prototype.nthConstraint = function(n, asPtr=false){
+    if(n<0 || n>=this.$nConstraint) return false;
+    const ptr = this.$aConstraint + (
+      sii.sqlite3_index_constraint.structInfo.sizeof * n
+    );
+    return asPtr ? ptr : new sii.sqlite3_index_constraint(ptr);
+  };
+
+  /**
+     Works identically to nthConstraint() but returns state from
+     this.$aConstraintUsage, so returns an
+     sqlite3_index_info.sqlite3_index_constraint_usage instance
+     if passed no 2nd argument or a falsy 2nd argument.
+  */
+  sii.prototype.nthConstraintUsage = function(n, asPtr=false){
+    if(n<0 || n>=this.$nConstraint) return false;
+    const ptr = this.$aConstraintUsage + (
+      sii.sqlite3_index_constraint_usage.structInfo.sizeof * n
+    );
+    return asPtr ? ptr : new sii.sqlite3_index_constraint_usage(ptr);
+  };
+
+  /**
+     If n is >=0 and less than this.$nOrderBy, this function
+     returns either a WASM pointer to the 0-based nth entry of
+     this.$aOrderBy (if passed a truthy 2nd argument) or an
+     sqlite3_index_info.sqlite3_index_orderby object wrapping that
+     address (if passed a falsy value or no 2nd argument). Returns a
+     falsy value if n is out of range.
+  */
+  sii.prototype.nthOrderBy = function(n, asPtr=false){
+    if(n<0 || n>=this.$nOrderBy) return false;
+    const ptr = this.$aOrderBy + (
+      sii.sqlite3_index_orderby.structInfo.sizeof * n
+    );
+    return asPtr ? ptr : new sii.sqlite3_index_orderby(ptr);
+  };
+
+  /**
+     Internal factory function for xVtab and xCursor impls.
+  */
+  const __xWrapFactory = function(methodName,StructType){
+    return function(ptr,removeMapping=false){
+      if(0===arguments.length) ptr = new StructType;
+      if(ptr instanceof StructType){
+        //T.assert(!this.has(ptr.pointer));
+        this.set(ptr.pointer, ptr);
+        return ptr;
+      }else if(!wasm.isPtr(ptr)){
+        sqlite3.SQLite3Error.toss("Invalid argument to",methodName+"()");
+      }
+      let rc = this.get(ptr);
+      if(removeMapping) this.delete(ptr);
+      return rc;
+    }.bind(new Map);
+  };
+
+  /**
+     A factory function which implements a simple lifetime manager for
+     mappings between C struct pointers and their JS-level wrappers.
+     The first argument must be the logical name of the manager
+     (e.g. 'xVtab' or 'xCursor'), which is only used for error
+     reporting. The second must be the capi.XYZ struct-type value,
+     e.g. capi.sqlite3_vtab or capi.sqlite3_vtab_cursor.
+
+     Returns an object with 4 methods: create(), get(), unget(), and
+     dispose(), plus a StructType member with the value of the 2nd
+     argument. The methods are documented in the body of this
+     function.
+  */
+  const StructPtrMapper = function(name, StructType){
+    const __xWrap = __xWrapFactory(name,StructType);
+    /**
+       This object houses a small API for managing mappings of (`T*`)
+       to StructType<T> objects, specifically within the lifetime
+       requirements of sqlite3_module methods.
+    */
+    return Object.assign(Object.create(null),{
+      /** The StructType object for this object's API. */
+      StructType,
+      /**
+         Creates a new StructType object, writes its `pointer`
+         value to the given output pointer, and returns that
+         object. Its intended usage depends on StructType:
+
+         sqlite3_vtab: to be called from sqlite3_module::xConnect()
+         or xCreate() implementations.
+
+         sqlite3_vtab_cursor: to be called from xOpen().
+
+         This will throw if allocation of the StructType instance
+         fails or if ppOut is not a pointer-type value.
+      */
+      create: (ppOut)=>{
+        const rc = __xWrap();
+        wasm.pokePtr(ppOut, rc.pointer);
+        return rc;
+      },
+      /**
+         Returns the StructType object previously mapped to the
+         given pointer using create(). Its intended usage depends
+         on StructType:
+
+         sqlite3_vtab: to be called from sqlite3_module methods which
+         take a (sqlite3_vtab*) pointer _except_ for
+         xDestroy()/xDisconnect(), in which case unget() or dispose().
+
+         sqlite3_vtab_cursor: to be called from any sqlite3_module methods
+         which take a `sqlite3_vtab_cursor*` argument except xClose(),
+         in which case use unget() or dispose().
+
+         Rule to remember: _never_ call dispose() on an instance
+         returned by this function.
+      */
+      get: (pCObj)=>__xWrap(pCObj),
+      /**
+         Identical to get() but also disconnects the mapping between the
+         given pointer and the returned StructType object, such that
+         future calls to this function or get() with the same pointer
+         will return the undefined value. Its intended usage depends
+         on StructType:
+
+         sqlite3_vtab: to be called from sqlite3_module::xDisconnect() or
+         xDestroy() implementations or in error handling of a failed
+         xCreate() or xConnect().
+
+         sqlite3_vtab_cursor: to be called from xClose() or during
+         cleanup in a failed xOpen().
+
+         Calling this method obligates the caller to call dispose() on
+         the returned object when they're done with it.
+      */
+      unget: (pCObj)=>__xWrap(pCObj,true),
+      /**
+         Works like unget() plus it calls dispose() on the
+         StructType object.
+      */
+      dispose: (pCObj)=>{
+        const o = __xWrap(pCObj,true);
+        if(o) o.dispose();
+      }
+    });
+  };
+
+  /**
+     A lifetime-management object for mapping `sqlite3_vtab*`
+     instances in sqlite3_module methods to capi.sqlite3_vtab
+     objects.
+
+     The API docs are in the API-internal StructPtrMapper().
+  */
+  vtab.xVtab = StructPtrMapper('xVtab', capi.sqlite3_vtab);
+
+  /**
+     A lifetime-management object for mapping `sqlite3_vtab_cursor*`
+     instances in sqlite3_module methods to capi.sqlite3_vtab_cursor
+     objects.
+
+     The API docs are in the API-internal StructPtrMapper().
+  */
+  vtab.xCursor = StructPtrMapper('xCursor', capi.sqlite3_vtab_cursor);
+
+  /**
+     Convenience form of creating an sqlite3_index_info wrapper,
+     intended for use in xBestIndex implementations. Note that the
+     caller is expected to call dispose() on the returned object
+     before returning. Though not _strictly_ required, as that object
+     does not own the pIdxInfo memory, it is nonetheless good form.
+  */
+  vtab.xIndexInfo = (pIdxInfo)=>new capi.sqlite3_index_info(pIdxInfo);
+
+  /**
+     Given an sqlite3_module method name and error object, this
+     function returns sqlite3.capi.SQLITE_NOMEM if (e instanceof
+     sqlite3.WasmAllocError), else it returns its second argument. Its
+     intended usage is in the methods of a sqlite3_vfs or
+     sqlite3_module:
+
+     ```
+     try{
+      let rc = ...
+      return rc;
+     }catch(e){
+       return sqlite3.vtab.xError(
+                'xColumn', e, sqlite3.capi.SQLITE_XYZ);
+       // where SQLITE_XYZ is some call-appropriate result code.
+     }
+     ```
+
+     If no 3rd argument is provided, its default depends on
+     the error type:
+
+     - An sqlite3.WasmAllocError always resolves to capi.SQLITE_NOMEM.
+
+     - If err is an SQLite3Error then its `resultCode` property
+       is used.
+
+     - If all else fails, capi.SQLITE_ERROR is used.
+
+     If xError.errorReporter is a function, it is called in
+     order to report the error, else the error is not reported.
+     If that function throws, that exception is ignored.
+  */
+  vtab.xError = function f(methodName, err, defaultRc){
+    if(f.errorReporter instanceof Function){
+      try{f.errorReporter("sqlite3_module::"+methodName+"(): "+err.message);}
+      catch(e){/*ignored*/}
+    }
+    let rc;
+    if(err instanceof sqlite3.WasmAllocError) rc = capi.SQLITE_NOMEM;
+    else if(arguments.length>2) rc = defaultRc;
+    else if(err instanceof sqlite3.SQLite3Error) rc = err.resultCode;
+    return rc || capi.SQLITE_ERROR;
+  };
+  vtab.xError.errorReporter = 1 ? console.error.bind(console) : false;
+
+  /**
+     A helper for sqlite3_vtab::xRowid() and xUpdate()
+     implementations. It must be passed the final argument to one of
+     those methods (an output pointer to an int64 row ID) and the
+     value to store at the output pointer's address. Returns the same
+     as wasm.poke() and will throw if the 1st or 2nd arguments
+     are invalid for that function.
+
+     Example xRowid impl:
+
+     ```
+     const xRowid = (pCursor, ppRowid64)=>{
+       const c = vtab.xCursor(pCursor);
+       vtab.xRowid(ppRowid64, c.myRowId);
+       return 0;
+     };
+     ```
+  */
+  vtab.xRowid = (ppRowid64, value)=>wasm.poke(ppRowid64, value, 'i64');
+
+  /**
+     A helper to initialize and set up an sqlite3_module object for
+     later installation into individual databases using
+     sqlite3_create_module(). Requires an object with the following
+     properties:
+
+     - `methods`: an object containing a mapping of properties with
+       the C-side names of the sqlite3_module methods, e.g. xCreate,
+       xBestIndex, etc., to JS implementations for those functions.
+       Certain special-case handling is performed, as described below.
+
+     - `catchExceptions` (default=false): if truthy, the given methods
+       are not mapped as-is, but are instead wrapped inside wrappers
+       which translate exceptions into result codes of SQLITE_ERROR or
+       SQLITE_NOMEM, depending on whether the exception is an
+       sqlite3.WasmAllocError. In the case of the xConnect and xCreate
+       methods, the exception handler also sets the output error
+       string to the exception's error string.
+
+     - OPTIONAL `struct`: a sqlite3.capi.sqlite3_module() instance. If
+       not set, one will be created automatically. If the current
+       "this" is-a sqlite3_module then it is unconditionally used in
+       place of `struct`.
+
+     - OPTIONAL `iVersion`: if set, it must be an integer value and it
+       gets assigned to the `$iVersion` member of the struct object.
+       If it's _not_ set, and the passed-in `struct` object's `$iVersion`
+       is 0 (the default) then this function attempts to define a value
+       for that property based on the list of methods it has.
+
+     If `catchExceptions` is false, it is up to the client to ensure
+     that no exceptions escape the methods, as doing so would move
+     them through the C API, leading to undefined
+     behavior. (vtab.xError() is intended to assist in reporting
+     such exceptions.)
+
+     Certain methods may refer to the same implementation. To simplify
+     the definition of such methods:
+
+     - If `methods.xConnect` is `true` then the value of
+       `methods.xCreate` is used in its place, and vice versa. sqlite
+       treats xConnect/xCreate functions specially if they are exactly
+       the same function (same pointer value).
+
+     - If `methods.xDisconnect` is true then the value of
+       `methods.xDestroy` is used in its place, and vice versa.
+
+     This is to facilitate creation of those methods inline in the
+     passed-in object without requiring the client to explicitly get a
+     reference to one of them in order to assign it to the other
+     one.
+
+     The `catchExceptions`-installed handlers will account for
+     identical references to the above functions and will install the
+     same wrapper function for both.
+
+     The given methods are expected to return integer values, as
+     expected by the C API. If `catchExceptions` is truthy, the return
+     value of the wrapped function will be used as-is and will be
+     translated to 0 if the function returns a falsy value (e.g. if it
+     does not have an explicit return). If `catchExceptions` is _not_
+     active, the method implementations must explicitly return integer
+     values.
+
+     Throws on error. On success, returns the sqlite3_module object
+     (`this` or `opt.struct` or a new sqlite3_module instance,
+     depending on how it's called).
+  */
+  vtab.setupModule = function(opt){
+    let createdMod = false;
+    const mod = (this instanceof capi.sqlite3_module)
+          ? this : (opt.struct || (createdMod = new capi.sqlite3_module()));
+    try{
+      const methods = opt.methods || toss("Missing 'methods' object.");
+      for(const e of Object.entries({
+        // -----^ ==> [k,v] triggers a broken code transformation in
+        // some versions of the emsdk toolchain.
+        xConnect: 'xCreate', xDisconnect: 'xDestroy'
+      })){
+        // Remap X=true to X=Y for certain X/Y combinations
+        const k = e[0], v = e[1];
+        if(true === methods[k]) methods[k] = methods[v];
+        else if(true === methods[v]) methods[v] = methods[k];
+      }
+      if(opt.catchExceptions){
+        const fwrap = function(methodName, func){
+          if(['xConnect','xCreate'].indexOf(methodName) >= 0){
+            return function(pDb, pAux, argc, argv, ppVtab, pzErr){
+              try{return func(...arguments) || 0}
+              catch(e){
+                if(!(e instanceof sqlite3.WasmAllocError)){
+                  wasm.dealloc(wasm.peekPtr(pzErr));
+                  wasm.pokePtr(pzErr, wasm.allocCString(e.message));
+                }
+                return vtab.xError(methodName, e);
+              }
+            };
+          }else{
+            return function(...args){
+              try{return func(...args) || 0}
+              catch(e){
+                return vtab.xError(methodName, e);
+              }
+            };
+          }
+        };
+        const mnames = [
+          'xCreate', 'xConnect', 'xBestIndex', 'xDisconnect',
+          'xDestroy', 'xOpen', 'xClose', 'xFilter', 'xNext',
+          'xEof', 'xColumn', 'xRowid', 'xUpdate',
+          'xBegin', 'xSync', 'xCommit', 'xRollback',
+          'xFindFunction', 'xRename', 'xSavepoint', 'xRelease',
+          'xRollbackTo', 'xShadowName'
+        ];
+        const remethods = Object.create(null);
+        for(const k of mnames){
+          const m = methods[k];
+          if(!(m instanceof Function)) continue;
+          else if('xConnect'===k && methods.xCreate===m){
+            remethods[k] = methods.xCreate;
+          }else if('xCreate'===k && methods.xConnect===m){
+            remethods[k] = methods.xConnect;
+          }else{
+            remethods[k] = fwrap(k, m);
+          }
+        }
+        mod.installMethods(remethods, false);
+      }else{
+        // No automatic exception handling. Trust the client
+        // to not throw.
+        mod.installMethods(
+          methods, !!opt.applyArgcCheck/*undocumented option*/
+        );
+      }
+      if(0===mod.$iVersion){
+        let v;
+        if('number'===typeof opt.iVersion) v = opt.iVersion;
+        else if(mod.$xShadowName) v = 3;
+        else if(mod.$xSavePoint || mod.$xRelease || mod.$xRollbackTo) v = 2;
+        else v = 1;
+        mod.$iVersion = v;
+      }
+    }catch(e){
+      if(createdMod) createdMod.dispose();
+      throw e;
+    }
+    return mod;
+  }/*setupModule()*/;
+
+  /**
+     Equivalent to calling vtab.setupModule() with this sqlite3_module
+     object as the call's `this`.
+  */
+  capi.sqlite3_module.prototype.setupModule = function(opt){
+    return vtab.setupModule.call(this, opt);
+  };
+}/*sqlite3ApiBootstrap.initializers.push()*/);

local-test-sqlite3-delta-02/afc-sqlite3/ext/wasm/api/sqlite3-worker1.c-pp.js

@@ -0,0 +1,54 @@
+//#ifnot omit-oo1
+/*
+  2022-05-23
+
+  The author disclaims copyright to this source code.  In place of a
+  legal notice, here is a blessing:
+
+  *   May you do good and not evil.
+  *   May you find forgiveness for yourself and forgive others.
+  *   May you share freely, never taking more than you give.
+
+  ***********************************************************************
+
+  This is a JS Worker file for the main sqlite3 api. It loads
+  sqlite3.js, initializes the module, and postMessage()'s a message
+  after the module is initialized:
+
+  {type: 'sqlite3-api', result: 'worker1-ready'}
+
+  This seemingly superfluous level of indirection is necessary when
+  loading sqlite3.js via a Worker. Instantiating a worker with new
+  Worker("sqlite.js") will not (cannot) call sqlite3InitModule() to
+  initialize the module due to a timing/order-of-operations conflict
+  (and that symbol is not exported in a way that a Worker loading it
+  that way can see it).  Thus JS code wanting to load the sqlite3
+  Worker-specific API needs to pass _this_ file (or equivalent) to the
+  Worker constructor and then listen for an event in the form shown
+  above in order to know when the module has completed initialization.
+
+  This file accepts a URL arguments to adjust how it loads sqlite3.js:
+
+  - `sqlite3.dir`, if set, treats the given directory name as the
+    directory from which `sqlite3.js` will be loaded.
+*/
+//#if target=es6-bundler-friendly
+import {default as sqlite3InitModule} from './sqlite3-bundler-friendly.mjs';
+//#else
+"use strict";
+{
+  const urlParams = globalThis.location
+        ? new URL(globalThis.location.href).searchParams
+        : new URLSearchParams();
+  let theJs = 'sqlite3.js';
+  if(urlParams.has('sqlite3.dir')){
+    theJs = urlParams.get('sqlite3.dir') + '/' + theJs;
+  }
+  //console.warn("worker1 theJs =",theJs);
+  importScripts(theJs);
+}
+//#endif
+sqlite3InitModule().then(sqlite3 => sqlite3.initWorker1API());
+//#else
+/* Built with the omit-oo1 flag. */
+//#endif ifnot omit-oo1