meadow-connection-sqlite 1.0.10

package/docs/api.md

@@ -0,0 +1,256 @@
+# API Reference
+
+## Class: MeadowConnectionSQLite
+
+Extends `fable-serviceproviderbase`. Manages a connection to a SQLite database file through the better-sqlite3 library.
+
+### Constructor
+
+```javascript
+new MeadowConnectionSQLite(pFable, pManifest, pServiceHash)
+```
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pFable` | object | A Fable instance |
+| `pManifest` | object | Service manifest / options (optional) |
+| `pServiceHash` | string | Service identifier |
+
+On construction:
+
+- Sets `serviceType` to `'MeadowConnectionSQLite'`
+- Sets `connected` to `false`
+- Reads `SQLiteFilePath` from `fable.settings.SQLite` if available
+
+The provider is not yet connected after construction — call `connectAsync()` to open the database.
+
+---
+
+## Properties
+
+### connected
+
+Whether the database connection is open.
+
+**Type:** `boolean`
+
+### db
+
+The raw `better-sqlite3` `Database` instance. Use this for all query operations. Returns `false` before `connectAsync()` is called.
+
+**Type:** `Database | false`
+
+```javascript
+let tmpDB = _Fable.MeadowSQLiteProvider.db;
+
+// Synchronous query methods from better-sqlite3:
+tmpDB.prepare(sql).run(params);    // INSERT, UPDATE, DELETE
+tmpDB.prepare(sql).get(params);    // SELECT single row
+tmpDB.prepare(sql).all(params);    // SELECT all rows
+tmpDB.exec(sql);                   // Execute raw SQL (multi-statement)
+tmpDB.transaction(fn);             // Wrap a function in a transaction
+tmpDB.pragma(string);              // Run a PRAGMA command
+tmpDB.close();                     // Close the database
+```
+
+### SQLite
+
+Reference to the `better-sqlite3` module constructor. Useful for accessing type constants or creating additional database instances.
+
+**Type:** `function`
+
+```javascript
+let tmpSQLiteConstructor = _Fable.MeadowSQLiteProvider.SQLite;
+```
+
+### serviceType
+
+Always `'MeadowConnectionSQLite'`.
+
+**Type:** `string`
+
+---
+
+## Methods
+
+### connectAsync(fCallback)
+
+Open a connection to the SQLite database file specified in configuration.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `fCallback` | function | Callback: `(error, database)` |
+
+**Behavior:**
+
+- If `SQLiteFilePath` is not configured, calls back with an error
+- If already connected, calls back immediately with the existing database (idempotent)
+- Creates the database file if it does not exist
+- Enables WAL (Write-Ahead Logging) journal mode for performance
+- Sets `this.connected = true` on success
+
+```javascript
+_Fable.MeadowSQLiteProvider.connectAsync(
+	(pError, pDatabase) =>
+	{
+		if (pError)
+		{
+			_Fable.log.error(`Connection failed: ${pError}`);
+			return;
+		}
+
+		// pDatabase is the same as _Fable.MeadowSQLiteProvider.db
+		pDatabase.exec('CREATE TABLE IF NOT EXISTS Test (id INTEGER PRIMARY KEY)');
+	});
+```
+
+### connect()
+
+Synchronous wrapper that calls `connectAsync()` without a callback. Logs a warning about potential race conditions. Prefer `connectAsync()`.
+
+---
+
+## Configuration
+
+### Fable Settings
+
+```json
+{
+	"SQLite":
+	{
+		"SQLiteFilePath": "./data/myapp.db"
+	}
+}
+```
+
+| Setting | Type | Required | Description |
+|---------|------|----------|-------------|
+| `SQLiteFilePath` | string | Yes | File path or `:memory:` for in-memory databases |
+
+Additional properties are passed through to the `better-sqlite3` constructor:
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `readonly` | boolean | `false` | Open the database in read-only mode |
+| `fileMustExist` | boolean | `false` | Error if the file does not exist |
+| `timeout` | number | `5000` | Milliseconds to wait when the database is locked |
+
+---
+
+## Service Registration
+
+The provider integrates with Fable's service manager:
+
+```javascript
+const libMeadowConnectionSQLite = require('meadow-connection-sqlite');
+
+// Register the service type
+_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+
+// Instantiate (optionally with per-instance options)
+_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider',
+	{
+		SQLiteFilePath: './data/alternate.db',
+		readonly: true
+	});
+
+// Access the provider
+_Fable.MeadowSQLiteProvider.connectAsync((pError) => { /* ... */ });
+```
+
+Constructor options override Fable settings, allowing multiple providers with different configurations.
+
+---
+
+## better-sqlite3 Query API
+
+After connecting, all queries go through the `db` getter. Here is a quick reference for the better-sqlite3 methods you will use most:
+
+### Execute Raw SQL
+
+```javascript
+tmpDB.exec(`
+	CREATE TABLE IF NOT EXISTS Book (
+		IDBook INTEGER PRIMARY KEY AUTOINCREMENT,
+		Title TEXT DEFAULT ''
+	);
+	CREATE INDEX IF NOT EXISTS idx_book_title ON Book(Title);
+`);
+```
+
+`exec()` runs one or more SQL statements. It does not return data.
+
+### Prepared Statements
+
+```javascript
+let tmpStmt = tmpDB.prepare('SELECT * FROM Book WHERE Author = ?');
+
+// Single row
+let tmpRow = tmpStmt.get('Frank Herbert');
+
+// All rows
+let tmpRows = tmpStmt.all('Frank Herbert');
+
+// Modification
+let tmpInsert = tmpDB.prepare('INSERT INTO Book (Title, Author) VALUES (?, ?)');
+let tmpInfo = tmpInsert.run('Dune', 'Frank Herbert');
+// tmpInfo.changes = 1, tmpInfo.lastInsertRowid = 1
+```
+
+### Named Parameters
+
+```javascript
+let tmpStmt = tmpDB.prepare('SELECT * FROM Book WHERE Author = @author AND YearPublished > @year');
+let tmpRows = tmpStmt.all({ author: 'Isaac Asimov', year: 1950 });
+```
+
+### Transactions
+
+```javascript
+let tmpBulkInsert = tmpDB.transaction(
+	(pBooks) =>
+	{
+		let tmpStmt = tmpDB.prepare('INSERT INTO Book (Title, Author) VALUES (?, ?)');
+		for (let tmpBook of pBooks)
+		{
+			tmpStmt.run(tmpBook.Title, tmpBook.Author);
+		}
+	});
+
+// The entire array is inserted atomically
+tmpBulkInsert([
+	{ Title: 'Foundation', Author: 'Isaac Asimov' },
+	{ Title: 'Snow Crash', Author: 'Neal Stephenson' }
+]);
+```
+
+If any statement inside the transaction throws, the entire transaction is rolled back automatically.
+
+### Close
+
+```javascript
+tmpDB.close();
+```
+
+---
+
+## Logging
+
+The provider logs connection events through the Fable logging system:
+
+| Event | Level | Message |
+|-------|-------|---------|
+| Connecting | `info` | `Meadow-Connection-SQLite connecting to file [path].` |
+| Connected | `info` | `Meadow-Connection-SQLite successfully connected to SQLite file [path].` |
+| Already connected | `error` | `...is already connected - skipping the second connect call.` |
+| Missing path | `error` | `...database file path is invalid; SQLiteFilePath must be in either...` |
+| Connection error | `error` | `...error connecting to SQLite file [path]: [error]` |
+| No callback | `error` | `...connect() called without a callback...` |
+
+---
+
+## Known Limitations
+
+- **Table generation** — The `generateCreateTableStatement()` and `createTable()` methods produce MSSQL-syntax SQL that is not compatible with SQLite. Use `db.exec()` with SQLite-native `CREATE TABLE` statements instead.
+- **Prepared statement getter** — The `preparedStatement` property references an uninitialized connection pool. Use `db.prepare()` directly for prepared statements.
+- **No async queries** — better-sqlite3 is synchronous by design. For CPU-bound workloads, consider running queries in a worker thread.

package/docs/cover.md

@@ -0,0 +1,15 @@
+# Meadow Connection SQLite
+
+> SQLite database provider for the Meadow data layer
+
+Connect any Fable application to a local SQLite database through the service provider pattern. Built on better-sqlite3 for fast synchronous access with WAL journaling, automatic file creation, and in-memory database support.
+
+- **Zero Config Server** -- No daemon, no Docker — just a file path and you have a database
+- **Synchronous API** -- All queries run synchronously through better-sqlite3's native bindings
+- **WAL Journaling** -- Write-Ahead Logging enabled automatically for concurrent read/write performance
+- **In-Memory Mode** -- Use `:memory:` as the file path for ephemeral databases in tests and prototypes
+- **Service Integration** -- Registers as a Fable service with dependency injection and lifecycle logging
+
+[Quick Start](README.md)
+[API Reference](api.md)
+[GitHub](https://github.com/stevenvelozo/meadow-connection-sqlite)

package/docs/css/docuserve.css

@@ -0,0 +1,73 @@
+/* ============================================================================
+   Pict Docuserve - Base Styles
+   ============================================================================ */
+
+/* Reset and base */
+*, *::before, *::after {
+	box-sizing: border-box;
+}
+
+html, body {
+	margin: 0;
+	padding: 0;
+	font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+	font-size: 16px;
+	line-height: 1.5;
+	color: #423D37;
+	background-color: #fff;
+	-webkit-font-smoothing: antialiased;
+	-moz-osx-font-smoothing: grayscale;
+}
+
+/* Typography */
+h1, h2, h3, h4, h5, h6 {
+	margin-top: 0;
+	line-height: 1.3;
+}
+
+a {
+	color: #2E7D74;
+	text-decoration: none;
+}
+
+a:hover {
+	color: #256861;
+}
+
+/* Application container */
+#Docuserve-Application-Container {
+	min-height: 100vh;
+}
+
+/* Utility: scrollbar styling */
+::-webkit-scrollbar {
+	width: 8px;
+}
+
+::-webkit-scrollbar-track {
+	background: #F5F0E8;
+}
+
+::-webkit-scrollbar-thumb {
+	background: #D4CCBE;
+	border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+	background: #B5AA9A;
+}
+
+/* Responsive adjustments */
+@media (max-width: 768px) {
+	html {
+		font-size: 14px;
+	}
+
+	#Docuserve-Sidebar-Container {
+		display: none;
+	}
+
+	.docuserve-body {
+		flex-direction: column;
+	}
+}

package/docs/examples-pipeline.md

@@ -0,0 +1,331 @@
+# Full Pipeline Example
+
+This walkthrough builds a complete CRUD pipeline from scratch: configure Fable, connect to SQLite, create a schema, insert rows, query, update, delete, run a transaction, and compute aggregates. Every snippet below has been executed and verified against meadow-connection-sqlite.
+
+> The full script is available at `debug/Pipeline-Test.js` in the module repository.
+
+---
+
+## Setup
+
+```javascript
+const libFable = require('fable');
+const libMeadowConnectionSQLite = require('meadow-connection-sqlite');
+
+let _Fable = new libFable(
+	{
+		"Product": "BookstoreExample",
+		"ProductVersion": "1.0.0",
+		"UUID": { "DataCenter": 0, "Worker": 0 },
+		"LogStreams": [{ "streamtype": "console" }],
+		"SQLite": { "SQLiteFilePath": "./dist/Bookstore.db" }
+	});
+
+_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+```
+
+---
+
+## Step 1: Connect
+
+```javascript
+_Fable.MeadowSQLiteProvider.connectAsync(
+	(pError, pDatabase) =>
+	{
+		if (pError)
+		{
+			_Fable.log.error(`Connection failed: ${pError}`);
+			return;
+		}
+
+		_Fable.log.info(`Connected: ${_Fable.MeadowSQLiteProvider.connected}`);
+		// => Connected: true
+
+		let tmpDB = _Fable.MeadowSQLiteProvider.db;
+
+		// ... all remaining steps use tmpDB ...
+	});
+```
+
+The database file is created automatically if it does not exist. WAL journal mode is enabled on connection for better performance.
+
+---
+
+## Step 2: Create a Table
+
+Use SQLite-native `CREATE TABLE` syntax through `db.exec()`:
+
+```javascript
+tmpDB.exec(`
+	CREATE TABLE IF NOT EXISTS Book (
+		IDBook INTEGER PRIMARY KEY AUTOINCREMENT,
+		GUIDBook TEXT DEFAULT '00000000-0000-0000-0000-000000000000',
+		Title TEXT DEFAULT '',
+		Author TEXT DEFAULT '',
+		YearPublished INTEGER DEFAULT 0,
+		Price REAL DEFAULT 0.0,
+		CreateDate TEXT DEFAULT (datetime('now')),
+		UpdateDate TEXT DEFAULT (datetime('now'))
+	)
+`);
+```
+
+**SQLite type mapping:**
+
+| Meadow Type | SQLite Type | Notes |
+|-------------|-------------|-------|
+| ID | `INTEGER PRIMARY KEY AUTOINCREMENT` | Auto-incrementing primary key |
+| GUID | `TEXT` | Store as 36-character UUID string |
+| String | `TEXT` | SQLite does not enforce VARCHAR length |
+| Numeric / ForeignKey | `INTEGER` | 64-bit signed integer |
+| Decimal | `REAL` | 64-bit IEEE floating point |
+| Boolean | `INTEGER` | 0 = false, 1 = true |
+| DateTime | `TEXT` | ISO-8601 string, e.g. `datetime('now')` |
+| Text | `TEXT` | Unlimited length |
+
+---
+
+## Step 3: Insert Rows
+
+Prepared statements with positional parameters:
+
+```javascript
+let tmpInsert = tmpDB.prepare(
+	`INSERT INTO Book (GUIDBook, Title, Author, YearPublished, Price) VALUES (?, ?, ?, ?, ?)`
+);
+
+let tmpResult1 = tmpInsert.run(_Fable.fable.getUUID(), 'The Hobbit', 'J.R.R. Tolkien', 1937, 12.99);
+// tmpResult1.lastInsertRowid => 1
+
+let tmpResult2 = tmpInsert.run(_Fable.fable.getUUID(), 'Dune', 'Frank Herbert', 1965, 14.99);
+// tmpResult2.lastInsertRowid => 2
+
+let tmpResult3 = tmpInsert.run(_Fable.fable.getUUID(), 'Neuromancer', 'William Gibson', 1984, 11.50);
+// tmpResult3.lastInsertRowid => 3
+```
+
+The `run()` method returns an object with two properties:
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `changes` | number | Number of rows affected |
+| `lastInsertRowid` | number | Auto-generated ID of the inserted row |
+
+Fable's `getUUID()` generates unique identifiers for the GUID column.
+
+---
+
+## Step 4: Read All Rows
+
+```javascript
+let tmpAllBooks = tmpDB.prepare(`SELECT * FROM Book`).all();
+// tmpAllBooks.length => 3
+
+for (let i = 0; i < tmpAllBooks.length; i++)
+{
+	let tmpBook = tmpAllBooks[i];
+	console.log(`[${tmpBook.IDBook}] "${tmpBook.Title}" by ${tmpBook.Author} ($${tmpBook.Price})`);
+}
+```
+
+Output:
+
+```
+[1] "The Hobbit" by J.R.R. Tolkien ($12.99)
+[2] "Dune" by Frank Herbert ($14.99)
+[3] "Neuromancer" by William Gibson ($11.5)
+```
+
+The `all()` method returns an array of plain JavaScript objects. Column names become property keys.
+
+---
+
+## Step 5: Read a Single Row
+
+```javascript
+let tmpOneBook = tmpDB.prepare(`SELECT * FROM Book WHERE IDBook = ?`).get(2);
+// tmpOneBook => { IDBook: 2, Title: 'Dune', Author: 'Frank Herbert', ... }
+```
+
+The `get()` method returns a single object, or `undefined` if no row matches.
+
+---
+
+## Step 6: Update
+
+```javascript
+let tmpUpdate = tmpDB.prepare(
+	`UPDATE Book SET Price = ?, UpdateDate = datetime('now') WHERE IDBook = ?`
+);
+let tmpUpdateResult = tmpUpdate.run(16.99, 2);
+// tmpUpdateResult.changes => 1
+
+let tmpVerify = tmpDB.prepare(`SELECT * FROM Book WHERE IDBook = ?`).get(2);
+// tmpVerify.Price => 16.99
+```
+
+---
+
+## Step 7: Delete
+
+```javascript
+let tmpDelete = tmpDB.prepare(`DELETE FROM Book WHERE IDBook = ?`);
+let tmpDeleteResult = tmpDelete.run(3);
+// tmpDeleteResult.changes => 1
+
+let tmpRemaining = tmpDB.prepare(`SELECT * FROM Book`).all();
+// tmpRemaining.length => 2
+```
+
+---
+
+## Step 8: Transactions
+
+Transactions in better-sqlite3 wrap a function. If anything inside the function throws, the entire transaction is rolled back. Otherwise it commits atomically.
+
+```javascript
+let tmpBulkInsert = tmpDB.transaction(
+	(pBooks) =>
+	{
+		let tmpStmt = tmpDB.prepare(
+			`INSERT INTO Book (GUIDBook, Title, Author, YearPublished, Price) VALUES (?, ?, ?, ?, ?)`
+		);
+		for (let tmpBook of pBooks)
+		{
+			tmpStmt.run(tmpBook.GUID, tmpBook.Title, tmpBook.Author, tmpBook.Year, tmpBook.Price);
+		}
+	});
+
+tmpBulkInsert(
+	[
+		{ GUID: _Fable.fable.getUUID(), Title: 'Snow Crash', Author: 'Neal Stephenson', Year: 1992, Price: 13.99 },
+		{ GUID: _Fable.fable.getUUID(), Title: 'Hyperion', Author: 'Dan Simmons', Year: 1989, Price: 15.50 },
+		{ GUID: _Fable.fable.getUUID(), Title: 'Foundation', Author: 'Isaac Asimov', Year: 1951, Price: 10.99 }
+	]);
+```
+
+After the transaction, querying shows all five books:
+
+```
+[1] "The Hobbit" by J.R.R. Tolkien ($12.99)
+[2] "Dune" by Frank Herbert ($16.99)
+[4] "Snow Crash" by Neal Stephenson ($13.99)
+[5] "Hyperion" by Dan Simmons ($15.5)
+[6] "Foundation" by Isaac Asimov ($10.99)
+```
+
+Note that IDBook 3 is absent (deleted in Step 7) and the sequence skips to 4.
+
+Transactions are significantly faster than individual inserts for bulk operations. Inserting 1,000 rows in a transaction can be 50-100x faster than 1,000 separate `run()` calls.
+
+---
+
+## Step 9: Aggregates
+
+```javascript
+let tmpStats = tmpDB.prepare(
+	`SELECT COUNT(*) as BookCount, AVG(Price) as AvgPrice, SUM(Price) as TotalValue FROM Book`
+).get();
+
+console.log(`Books: ${tmpStats.BookCount}`);
+// => Books: 5
+
+console.log(`Average price: $${tmpStats.AvgPrice.toFixed(2)}`);
+// => Average price: $14.09
+
+console.log(`Total value: $${tmpStats.TotalValue.toFixed(2)}`);
+// => Total value: $70.46
+```
+
+---
+
+## Step 10: Close
+
+```javascript
+tmpDB.close();
+```
+
+After closing, further queries on this database instance will throw. The provider's `connected` property remains `true` — if you need to reconnect, create a new provider instance.
+
+---
+
+## Named Parameters
+
+better-sqlite3 supports named parameters prefixed with `@`, `$`, or `:`:
+
+```javascript
+let tmpStmt = tmpDB.prepare(
+	`SELECT * FROM Book WHERE Author = @author AND YearPublished > @minYear`
+);
+
+let tmpBooks = tmpStmt.all({ author: 'Isaac Asimov', minYear: 1950 });
+```
+
+Named parameters make complex queries more readable and less error-prone than positional `?` placeholders.
+
+---
+
+## In-Memory Databases
+
+For test suites and ephemeral workflows, use `:memory:` instead of a file path:
+
+```javascript
+let _Fable = new libFable(
+	{
+		"Product": "TestSuite",
+		"SQLite": { "SQLiteFilePath": ":memory:" }
+	});
+
+// Register, connect, create tables, run tests...
+// Database is discarded when the process exits or the connection closes.
+```
+
+In-memory databases are faster than file-backed databases and leave no cleanup artifacts.
+
+---
+
+## Error Handling Pattern
+
+```javascript
+_Fable.MeadowSQLiteProvider.connectAsync(
+	(pError) =>
+	{
+		if (pError)
+		{
+			_Fable.log.error(`Connection error: ${pError.message}`);
+			return;
+		}
+
+		let tmpDB = _Fable.MeadowSQLiteProvider.db;
+
+		try
+		{
+			tmpDB.exec(`CREATE TABLE Test (id INTEGER PRIMARY KEY)`);
+			tmpDB.prepare(`INSERT INTO Test (id) VALUES (?)`).run(1);
+		}
+		catch (pQueryError)
+		{
+			_Fable.log.error(`Query error: ${pQueryError.message}`);
+		}
+	});
+```
+
+better-sqlite3 throws `SqliteError` exceptions for all query failures (syntax errors, constraint violations, missing tables). Wrap query blocks in try/catch for graceful handling.
+
+---
+
+## Pipeline Summary
+
+| Step | Method | What It Does |
+|------|--------|-------------|
+| Connect | `connectAsync(cb)` | Opens the database file, enables WAL |
+| Create | `db.exec(sql)` | Runs DDL statements |
+| Insert | `db.prepare(sql).run(...)` | Returns `{ changes, lastInsertRowid }` |
+| Read all | `db.prepare(sql).all(...)` | Returns array of row objects |
+| Read one | `db.prepare(sql).get(...)` | Returns single object or `undefined` |
+| Update | `db.prepare(sql).run(...)` | Returns `{ changes }` |
+| Delete | `db.prepare(sql).run(...)` | Returns `{ changes }` |
+| Transaction | `db.transaction(fn)(args)` | Atomic batch; auto-rollback on throw |
+| Aggregate | `db.prepare(sql).get()` | Returns computed values |
+| Close | `db.close()` | Releases file handle |

package/docs/index.html

@@ -0,0 +1,39 @@
+<!doctype html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8">
+		<meta http-equiv="X-UA-Compatible" content="IE=edge">
+		<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+		<meta name="description" content="Documentation powered by pict-docuserve">
+
+		<title>Documentation</title>
+
+		<!-- Application Stylesheet -->
+		<link href="css/docuserve.css" rel="stylesheet">
+		<!-- KaTeX stylesheet for LaTeX equation rendering -->
+		<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.21/dist/katex.min.css">
+		<!-- PICT Dynamic View CSS Container -->
+		<style id="PICT-CSS"></style>
+
+		<!-- Load the PICT library from jsDelivr CDN -->
+		<script src="https://cdn.jsdelivr.net/npm/pict@1/dist/pict.min.js" type="text/javascript"></script>
+		<!-- Bootstrap the Application -->
+		<script type="text/javascript">
+//<![CDATA[
+		Pict.safeOnDocumentReady(() => { Pict.safeLoadPictApplication(PictDocuserve, 2)});
+//]]>
+		</script>
+	</head>
+	<body>
+		<!-- The root container for the Pict application -->
+		<div id="Docuserve-Application-Container"></div>
+
+		<!-- Mermaid diagram rendering -->
+		<script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
+		<script>mermaid.initialize({ startOnLoad: false, theme: 'default' });</script>
+		<!-- KaTeX for LaTeX equation rendering -->
+		<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.21/dist/katex.min.js"></script>
+		<!-- Load the Docuserve PICT Application Bundle from jsDelivr CDN -->
+		<script src="https://cdn.jsdelivr.net/npm/pict-docuserve@0/dist/pict-docuserve.min.js" type="text/javascript"></script>
+	</body>
+</html>