@semiont/frontend 0.3.4 → 0.3.6

package/standalone/apps/frontend/.next/server/app/api/resources/[id]/route.js

@@ -230,14 +230,7 @@ function _interopRequireWildcard(e, r) {
 
 /***/ }),
 
-/***/ 94735:
-/***/ ((module) => {
-
-module.exports = require("events");
-
-/***/ }),
-
-/***/ 94943:
+/***/ 94251:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -302,8 +295,2057 @@ var next_auth = __webpack_require__(61388);
 var auth = __webpack_require__(63986);
 // EXTERNAL MODULE: ./src/lib/env.ts
 var env = __webpack_require__(62100);
-// EXTERNAL MODULE: ../../packages/core/dist/index.js
-var dist = __webpack_require__(74992);
+// EXTERNAL MODULE: external "crypto"
+var external_crypto_ = __webpack_require__(55511);
+;// ../../node_modules/smol-toml/dist/error.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+function getLineColFromPtr(string, ptr) {
+    let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+    return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+    let lines = string.split(/\r\n|\n|\r/g);
+    let codeblock = '';
+    let numberLen = (Math.log10(line + 1) | 0) + 1;
+    for (let i = line - 1; i <= line + 1; i++) {
+        let l = lines[i - 1];
+        if (!l)
+            continue;
+        codeblock += i.toString().padEnd(numberLen, ' ');
+        codeblock += ':  ';
+        codeblock += l;
+        codeblock += '\n';
+        if (i === line) {
+            codeblock += ' '.repeat(numberLen + column + 2);
+            codeblock += '^\n';
+        }
+    }
+    return codeblock;
+}
+class TomlError extends Error {
+    line;
+    column;
+    codeblock;
+    constructor(message, options) {
+        const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+        const codeblock = makeCodeBlock(options.toml, line, column);
+        super(`Invalid TOML document: ${message}\n\n${codeblock}`, options);
+        this.line = line;
+        this.column = column;
+        this.codeblock = codeblock;
+    }
+}
+
+;// ../../node_modules/smol-toml/dist/util.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+function isEscaped(str, ptr) {
+    let i = 0;
+    while (str[ptr - ++i] === '\\')
+        ;
+    return --i && (i % 2);
+}
+function indexOfNewline(str, start = 0, end = str.length) {
+    let idx = str.indexOf('\n', start);
+    if (str[idx - 1] === '\r')
+        idx--;
+    return idx <= end ? idx : -1;
+}
+function skipComment(str, ptr) {
+    for (let i = ptr; i < str.length; i++) {
+        let c = str[i];
+        if (c === '\n')
+            return i;
+        if (c === '\r' && str[i + 1] === '\n')
+            return i + 1;
+        if ((c < '\x20' && c !== '\t') || c === '\x7f') {
+            throw new TomlError('control characters are not allowed in comments', {
+                toml: str,
+                ptr: ptr,
+            });
+        }
+    }
+    return str.length;
+}
+function skipVoid(str, ptr, banNewLines, banComments) {
+    let c;
+    while ((c = str[ptr]) === ' ' || c === '\t' || (!banNewLines && (c === '\n' || c === '\r' && str[ptr + 1] === '\n')))
+        ptr++;
+    return banComments || c !== '#'
+        ? ptr
+        : skipVoid(str, skipComment(str, ptr), banNewLines);
+}
+function skipUntil(str, ptr, sep, end, banNewLines = false) {
+    if (!end) {
+        ptr = indexOfNewline(str, ptr);
+        return ptr < 0 ? str.length : ptr;
+    }
+    for (let i = ptr; i < str.length; i++) {
+        let c = str[i];
+        if (c === '#') {
+            i = indexOfNewline(str, i);
+        }
+        else if (c === sep) {
+            return i + 1;
+        }
+        else if (c === end || (banNewLines && (c === '\n' || (c === '\r' && str[i + 1] === '\n')))) {
+            return i;
+        }
+    }
+    throw new TomlError('cannot find end of structure', {
+        toml: str,
+        ptr: ptr
+    });
+}
+function getStringEnd(str, seek) {
+    let first = str[seek];
+    let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2]
+        ? str.slice(seek, seek + 3)
+        : first;
+    seek += target.length - 1;
+    do
+        seek = str.indexOf(target, ++seek);
+    while (seek > -1 && first !== "'" && isEscaped(str, seek));
+    if (seek > -1) {
+        seek += target.length;
+        if (target.length > 1) {
+            if (str[seek] === first)
+                seek++;
+            if (str[seek] === first)
+                seek++;
+        }
+    }
+    return seek;
+}
+
+;// ../../node_modules/smol-toml/dist/date.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+let DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+class TomlDate extends Date {
+    #hasDate = false;
+    #hasTime = false;
+    #offset = null;
+    constructor(date) {
+        let hasDate = true;
+        let hasTime = true;
+        let offset = 'Z';
+        if (typeof date === 'string') {
+            let match = date.match(DATE_TIME_RE);
+            if (match) {
+                if (!match[1]) {
+                    hasDate = false;
+                    date = `0000-01-01T${date}`;
+                }
+                hasTime = !!match[2];
+                // Make sure to use T instead of a space. Breaks in case of extreme values otherwise.
+                hasTime && date[10] === ' ' && (date = date.replace(' ', 'T'));
+                // Do not allow rollover hours.
+                if (match[2] && +match[2] > 23) {
+                    date = '';
+                }
+                else {
+                    offset = match[3] || null;
+                    date = date.toUpperCase();
+                    if (!offset && hasTime)
+                        date += 'Z';
+                }
+            }
+            else {
+                date = '';
+            }
+        }
+        super(date);
+        if (!isNaN(this.getTime())) {
+            this.#hasDate = hasDate;
+            this.#hasTime = hasTime;
+            this.#offset = offset;
+        }
+    }
+    isDateTime() {
+        return this.#hasDate && this.#hasTime;
+    }
+    isLocal() {
+        return !this.#hasDate || !this.#hasTime || !this.#offset;
+    }
+    isDate() {
+        return this.#hasDate && !this.#hasTime;
+    }
+    isTime() {
+        return this.#hasTime && !this.#hasDate;
+    }
+    isValid() {
+        return this.#hasDate || this.#hasTime;
+    }
+    toISOString() {
+        let iso = super.toISOString();
+        // Local Date
+        if (this.isDate())
+            return iso.slice(0, 10);
+        // Local Time
+        if (this.isTime())
+            return iso.slice(11, 23);
+        // Local DateTime
+        if (this.#offset === null)
+            return iso.slice(0, -1);
+        // Offset DateTime
+        if (this.#offset === 'Z')
+            return iso;
+        // This part is quite annoying: JS strips the original timezone from the ISO string representation
+        // Instead of using a "modified" date and "Z", we restore the representation "as authored"
+        let offset = (+(this.#offset.slice(1, 3)) * 60) + +(this.#offset.slice(4, 6));
+        offset = this.#offset[0] === '-' ? offset : -offset;
+        let offsetDate = new Date(this.getTime() - (offset * 60e3));
+        return offsetDate.toISOString().slice(0, -1) + this.#offset;
+    }
+    static wrapAsOffsetDateTime(jsDate, offset = 'Z') {
+        let date = new TomlDate(jsDate);
+        date.#offset = offset;
+        return date;
+    }
+    static wrapAsLocalDateTime(jsDate) {
+        let date = new TomlDate(jsDate);
+        date.#offset = null;
+        return date;
+    }
+    static wrapAsLocalDate(jsDate) {
+        let date = new TomlDate(jsDate);
+        date.#hasTime = false;
+        date.#offset = null;
+        return date;
+    }
+    static wrapAsLocalTime(jsDate) {
+        let date = new TomlDate(jsDate);
+        date.#hasDate = false;
+        date.#offset = null;
+        return date;
+    }
+}
+
+;// ../../node_modules/smol-toml/dist/primitive.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+
+let INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+let FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+let LEADING_ZERO = /^[+-]?0[0-9_]/;
+let ESCAPE_REGEX = /^[0-9a-f]{2,8}$/i;
+let ESC_MAP = {
+    b: '\b',
+    t: '\t',
+    n: '\n',
+    f: '\f',
+    r: '\r',
+    e: '\x1b',
+    '"': '"',
+    '\\': '\\',
+};
+function parseString(str, ptr = 0, endPtr = str.length) {
+    let isLiteral = str[ptr] === '\'';
+    let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
+    if (isMultiline) {
+        endPtr -= 2;
+        if (str[ptr += 2] === '\r')
+            ptr++;
+        if (str[ptr] === '\n')
+            ptr++;
+    }
+    let tmp = 0;
+    let isEscape;
+    let parsed = '';
+    let sliceStart = ptr;
+    while (ptr < endPtr - 1) {
+        let c = str[ptr++];
+        if (c === '\n' || (c === '\r' && str[ptr] === '\n')) {
+            if (!isMultiline) {
+                throw new TomlError('newlines are not allowed in strings', {
+                    toml: str,
+                    ptr: ptr - 1,
+                });
+            }
+        }
+        else if ((c < '\x20' && c !== '\t') || c === '\x7f') {
+            throw new TomlError('control characters are not allowed in strings', {
+                toml: str,
+                ptr: ptr - 1,
+            });
+        }
+        if (isEscape) {
+            isEscape = false;
+            if (c === 'x' || c === 'u' || c === 'U') {
+                // Unicode escape
+                let code = str.slice(ptr, (ptr += (c === 'x' ? 2 : c === 'u' ? 4 : 8)));
+                if (!ESCAPE_REGEX.test(code)) {
+                    throw new TomlError('invalid unicode escape', {
+                        toml: str,
+                        ptr: tmp,
+                    });
+                }
+                try {
+                    parsed += String.fromCodePoint(parseInt(code, 16));
+                }
+                catch {
+                    throw new TomlError('invalid unicode escape', {
+                        toml: str,
+                        ptr: tmp,
+                    });
+                }
+            }
+            else if (isMultiline && (c === '\n' || c === ' ' || c === '\t' || c === '\r')) {
+                // Multiline escape
+                ptr = skipVoid(str, ptr - 1, true);
+                if (str[ptr] !== '\n' && str[ptr] !== '\r') {
+                    throw new TomlError('invalid escape: only line-ending whitespace may be escaped', {
+                        toml: str,
+                        ptr: tmp,
+                    });
+                }
+                ptr = skipVoid(str, ptr);
+            }
+            else if (c in ESC_MAP) {
+                // Classic escape
+                parsed += ESC_MAP[c];
+            }
+            else {
+                throw new TomlError('unrecognized escape sequence', {
+                    toml: str,
+                    ptr: tmp,
+                });
+            }
+            sliceStart = ptr;
+        }
+        else if (!isLiteral && c === '\\') {
+            tmp = ptr - 1;
+            isEscape = true;
+            parsed += str.slice(sliceStart, tmp);
+        }
+    }
+    return parsed + str.slice(sliceStart, endPtr - 1);
+}
+function parseValue(value, toml, ptr, integersAsBigInt) {
+    // Constant values
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (value === '-inf')
+        return -Infinity;
+    if (value === 'inf' || value === '+inf')
+        return Infinity;
+    if (value === 'nan' || value === '+nan' || value === '-nan')
+        return NaN;
+    // Avoid FP representation of -0
+    if (value === '-0')
+        return integersAsBigInt ? 0n : 0;
+    // Numbers
+    let isInt = INT_REGEX.test(value);
+    if (isInt || FLOAT_REGEX.test(value)) {
+        if (LEADING_ZERO.test(value)) {
+            throw new TomlError('leading zeroes are not allowed', {
+                toml: toml,
+                ptr: ptr,
+            });
+        }
+        value = value.replace(/_/g, '');
+        let numeric = +value;
+        if (isNaN(numeric)) {
+            throw new TomlError('invalid number', {
+                toml: toml,
+                ptr: ptr,
+            });
+        }
+        if (isInt) {
+            if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+                throw new TomlError('integer value cannot be represented losslessly', {
+                    toml: toml,
+                    ptr: ptr,
+                });
+            }
+            if (isInt || integersAsBigInt === true)
+                numeric = BigInt(value);
+        }
+        return numeric;
+    }
+    const date = new TomlDate(value);
+    if (!date.isValid()) {
+        throw new TomlError('invalid value', {
+            toml: toml,
+            ptr: ptr,
+        });
+    }
+    return date;
+}
+
+;// ../../node_modules/smol-toml/dist/extract.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+
+
+function sliceAndTrimEndOf(str, startPtr, endPtr) {
+    let value = str.slice(startPtr, endPtr);
+    let commentIdx = value.indexOf('#');
+    if (commentIdx > -1) {
+        // The call to skipComment allows to "validate" the comment
+        // (absence of control characters)
+        skipComment(str, commentIdx);
+        value = value.slice(0, commentIdx);
+    }
+    return [value.trimEnd(), commentIdx];
+}
+function extractValue(str, ptr, end, depth, integersAsBigInt) {
+    if (depth === 0) {
+        throw new TomlError('document contains excessively nested structures. aborting.', {
+            toml: str,
+            ptr: ptr
+        });
+    }
+    let c = str[ptr];
+    if (c === '[' || c === '{') {
+        let [value, endPtr] = c === '['
+            ? parseArray(str, ptr, depth, integersAsBigInt)
+            : parseInlineTable(str, ptr, depth, integersAsBigInt);
+        if (end) {
+            endPtr = skipVoid(str, endPtr);
+            if (str[endPtr] === ',')
+                endPtr++;
+            else if (str[endPtr] !== end) {
+                throw new TomlError('expected comma or end of structure', {
+                    toml: str,
+                    ptr: endPtr,
+                });
+            }
+        }
+        return [value, endPtr];
+    }
+    let endPtr;
+    if (c === '"' || c === "'") {
+        endPtr = getStringEnd(str, ptr);
+        let parsed = parseString(str, ptr, endPtr);
+        if (end) {
+            endPtr = skipVoid(str, endPtr);
+            if (str[endPtr] && str[endPtr] !== ',' && str[endPtr] !== end && str[endPtr] !== '\n' && str[endPtr] !== '\r') {
+                throw new TomlError('unexpected character encountered', {
+                    toml: str,
+                    ptr: endPtr,
+                });
+            }
+            endPtr += (+(str[endPtr] === ','));
+        }
+        return [parsed, endPtr];
+    }
+    endPtr = skipUntil(str, ptr, ',', end);
+    let slice = sliceAndTrimEndOf(str, ptr, endPtr - (+(str[endPtr - 1] === ',')));
+    if (!slice[0]) {
+        throw new TomlError('incomplete key-value declaration: no value specified', {
+            toml: str,
+            ptr: ptr
+        });
+    }
+    if (end && slice[1] > -1) {
+        endPtr = skipVoid(str, ptr + slice[1]);
+        endPtr += +(str[endPtr] === ',');
+    }
+    return [
+        parseValue(slice[0], str, ptr, integersAsBigInt),
+        endPtr,
+    ];
+}
+
+;// ../../node_modules/smol-toml/dist/struct.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+
+
+let KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(str, ptr, end = '=') {
+    let dot = ptr - 1;
+    let parsed = [];
+    let endPtr = str.indexOf(end, ptr);
+    if (endPtr < 0) {
+        throw new TomlError('incomplete key-value: cannot find end of key', {
+            toml: str,
+            ptr: ptr,
+        });
+    }
+    do {
+        let c = str[ptr = ++dot];
+        // If it's whitespace, ignore
+        if (c !== ' ' && c !== '\t') {
+            // If it's a string
+            if (c === '"' || c === '\'') {
+                if (c === str[ptr + 1] && c === str[ptr + 2]) {
+                    throw new TomlError('multiline strings are not allowed in keys', {
+                        toml: str,
+                        ptr: ptr,
+                    });
+                }
+                let eos = getStringEnd(str, ptr);
+                if (eos < 0) {
+                    throw new TomlError('unfinished string encountered', {
+                        toml: str,
+                        ptr: ptr,
+                    });
+                }
+                dot = str.indexOf('.', eos);
+                let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+                let newLine = indexOfNewline(strEnd);
+                if (newLine > -1) {
+                    throw new TomlError('newlines are not allowed in keys', {
+                        toml: str,
+                        ptr: ptr + dot + newLine,
+                    });
+                }
+                if (strEnd.trimStart()) {
+                    throw new TomlError('found extra tokens after the string part', {
+                        toml: str,
+                        ptr: eos,
+                    });
+                }
+                if (endPtr < eos) {
+                    endPtr = str.indexOf(end, eos);
+                    if (endPtr < 0) {
+                        throw new TomlError('incomplete key-value: cannot find end of key', {
+                            toml: str,
+                            ptr: ptr,
+                        });
+                    }
+                }
+                parsed.push(parseString(str, ptr, eos));
+            }
+            else {
+                // Normal raw key part consumption and validation
+                dot = str.indexOf('.', ptr);
+                let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
+                if (!KEY_PART_RE.test(part)) {
+                    throw new TomlError('only letter, numbers, dashes and underscores are allowed in keys', {
+                        toml: str,
+                        ptr: ptr,
+                    });
+                }
+                parsed.push(part.trimEnd());
+            }
+        }
+        // Until there's no more dot
+    } while (dot + 1 && dot < endPtr);
+    return [parsed, skipVoid(str, endPtr + 1, true, true)];
+}
+function parseInlineTable(str, ptr, depth, integersAsBigInt) {
+    let res = {};
+    let seen = new Set();
+    let c;
+    ptr++;
+    while ((c = str[ptr++]) !== '}' && c) {
+        if (c === ',') {
+            throw new TomlError('expected value, found comma', {
+                toml: str,
+                ptr: ptr - 1,
+            });
+        }
+        else if (c === '#')
+            ptr = skipComment(str, ptr);
+        else if (c !== ' ' && c !== '\t' && c !== '\n' && c !== '\r') {
+            let k;
+            let t = res;
+            let hasOwn = false;
+            let [key, keyEndPtr] = parseKey(str, ptr - 1);
+            for (let i = 0; i < key.length; i++) {
+                if (i)
+                    t = hasOwn ? t[k] : (t[k] = {});
+                k = key[i];
+                if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== 'object' || seen.has(t[k]))) {
+                    throw new TomlError('trying to redefine an already defined value', {
+                        toml: str,
+                        ptr: ptr,
+                    });
+                }
+                if (!hasOwn && k === '__proto__') {
+                    Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+                }
+            }
+            if (hasOwn) {
+                throw new TomlError('trying to redefine an already defined value', {
+                    toml: str,
+                    ptr: ptr,
+                });
+            }
+            let [value, valueEndPtr] = extractValue(str, keyEndPtr, '}', depth - 1, integersAsBigInt);
+            seen.add(value);
+            t[k] = value;
+            ptr = valueEndPtr;
+        }
+    }
+    if (!c) {
+        throw new TomlError('unfinished table encountered', {
+            toml: str,
+            ptr: ptr,
+        });
+    }
+    return [res, ptr];
+}
+function parseArray(str, ptr, depth, integersAsBigInt) {
+    let res = [];
+    let c;
+    ptr++;
+    while ((c = str[ptr++]) !== ']' && c) {
+        if (c === ',') {
+            throw new TomlError('expected value, found comma', {
+                toml: str,
+                ptr: ptr - 1,
+            });
+        }
+        else if (c === '#')
+            ptr = skipComment(str, ptr);
+        else if (c !== ' ' && c !== '\t' && c !== '\n' && c !== '\r') {
+            let e = extractValue(str, ptr - 1, ']', depth - 1, integersAsBigInt);
+            res.push(e[0]);
+            ptr = e[1];
+        }
+    }
+    if (!c) {
+        throw new TomlError('unfinished array encountered', {
+            toml: str,
+            ptr: ptr,
+        });
+    }
+    return [res, ptr];
+}
+
+;// ../../node_modules/smol-toml/dist/parse.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+
+
+function peekTable(key, table, meta, type) {
+    let t = table;
+    let m = meta;
+    let k;
+    let hasOwn = false;
+    let state;
+    for (let i = 0; i < key.length; i++) {
+        if (i) {
+            t = hasOwn ? t[k] : (t[k] = {});
+            m = (state = m[k]).c;
+            if (type === 0 /* Type.DOTTED */ && (state.t === 1 /* Type.EXPLICIT */ || state.t === 2 /* Type.ARRAY */)) {
+                return null;
+            }
+            if (state.t === 2 /* Type.ARRAY */) {
+                let l = t.length - 1;
+                t = t[l];
+                m = m[l].c;
+            }
+        }
+        k = key[i];
+        if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 /* Type.DOTTED */ && m[k]?.d) {
+            return null;
+        }
+        if (!hasOwn) {
+            if (k === '__proto__') {
+                Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+                Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+            }
+            m[k] = {
+                t: i < key.length - 1 && type === 2 /* Type.ARRAY */
+                    ? 3 /* Type.ARRAY_DOTTED */
+                    : type,
+                d: false,
+                i: 0,
+                c: {},
+            };
+        }
+    }
+    state = m[k];
+    if (state.t !== type && !(type === 1 /* Type.EXPLICIT */ && state.t === 3 /* Type.ARRAY_DOTTED */)) {
+        // Bad key type!
+        return null;
+    }
+    if (type === 2 /* Type.ARRAY */) {
+        if (!state.d) {
+            state.d = true;
+            t[k] = [];
+        }
+        t[k].push(t = {});
+        state.c[state.i++] = (state = { t: 1 /* Type.EXPLICIT */, d: false, i: 0, c: {} });
+    }
+    if (state.d) {
+        // Redefining a table!
+        return null;
+    }
+    state.d = true;
+    if (type === 1 /* Type.EXPLICIT */) {
+        t = hasOwn ? t[k] : (t[k] = {});
+    }
+    else if (type === 0 /* Type.DOTTED */ && hasOwn) {
+        return null;
+    }
+    return [k, t, state.c];
+}
+function parse_parse(toml, { maxDepth = 1000, integersAsBigInt } = {}) {
+    let res = {};
+    let meta = {};
+    let tbl = res;
+    let m = meta;
+    for (let ptr = skipVoid(toml, 0); ptr < toml.length;) {
+        if (toml[ptr] === '[') {
+            let isTableArray = toml[++ptr] === '[';
+            let k = parseKey(toml, ptr += +isTableArray, ']');
+            if (isTableArray) {
+                if (toml[k[1] - 1] !== ']') {
+                    throw new TomlError('expected end of table declaration', {
+                        toml: toml,
+                        ptr: k[1] - 1,
+                    });
+                }
+                k[1]++;
+            }
+            let p = peekTable(k[0], res, meta, isTableArray ? 2 /* Type.ARRAY */ : 1 /* Type.EXPLICIT */);
+            if (!p) {
+                throw new TomlError('trying to redefine an already defined table or value', {
+                    toml: toml,
+                    ptr: ptr,
+                });
+            }
+            m = p[2];
+            tbl = p[1];
+            ptr = k[1];
+        }
+        else {
+            let k = parseKey(toml, ptr);
+            let p = peekTable(k[0], tbl, m, 0 /* Type.DOTTED */);
+            if (!p) {
+                throw new TomlError('trying to redefine an already defined table or value', {
+                    toml: toml,
+                    ptr: ptr,
+                });
+            }
+            let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
+            p[1][p[0]] = v[0];
+            ptr = v[1];
+        }
+        ptr = skipVoid(toml, ptr, true);
+        if (toml[ptr] && toml[ptr] !== '\n' && toml[ptr] !== '\r') {
+            throw new TomlError('each key-value declaration must be followed by an end-of-line', {
+                toml: toml,
+                ptr: ptr
+            });
+        }
+        ptr = skipVoid(toml, ptr);
+    }
+    return res;
+}
+
+;// ../../node_modules/smol-toml/dist/stringify.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+let BARE_KEY = /^[a-z0-9-_]+$/i;
+function extendedTypeOf(obj) {
+    let type = typeof obj;
+    if (type === 'object') {
+        if (Array.isArray(obj))
+            return 'array';
+        if (obj instanceof Date)
+            return 'date';
+    }
+    return type;
+}
+function isArrayOfTables(obj) {
+    for (let i = 0; i < obj.length; i++) {
+        if (extendedTypeOf(obj[i]) !== 'object')
+            return false;
+    }
+    return obj.length != 0;
+}
+function formatString(s) {
+    return JSON.stringify(s).replace(/\x7f/g, '\\u007f');
+}
+function stringifyValue(val, type, depth, numberAsFloat) {
+    if (depth === 0) {
+        throw new Error('Could not stringify the object: maximum object depth exceeded');
+    }
+    if (type === 'number') {
+        if (isNaN(val))
+            return 'nan';
+        if (val === Infinity)
+            return 'inf';
+        if (val === -Infinity)
+            return '-inf';
+        if (numberAsFloat && Number.isInteger(val))
+            return val.toFixed(1);
+        return val.toString();
+    }
+    if (type === 'bigint' || type === 'boolean') {
+        return val.toString();
+    }
+    if (type === 'string') {
+        return formatString(val);
+    }
+    if (type === 'date') {
+        if (isNaN(val.getTime())) {
+            throw new TypeError('cannot serialize invalid date');
+        }
+        return val.toISOString();
+    }
+    if (type === 'object') {
+        return stringifyInlineTable(val, depth, numberAsFloat);
+    }
+    if (type === 'array') {
+        return stringifyArray(val, depth, numberAsFloat);
+    }
+}
+function stringifyInlineTable(obj, depth, numberAsFloat) {
+    let keys = Object.keys(obj);
+    if (keys.length === 0)
+        return '{}';
+    let res = '{ ';
+    for (let i = 0; i < keys.length; i++) {
+        let k = keys[i];
+        if (i)
+            res += ', ';
+        res += BARE_KEY.test(k) ? k : formatString(k);
+        res += ' = ';
+        res += stringifyValue(obj[k], extendedTypeOf(obj[k]), depth - 1, numberAsFloat);
+    }
+    return res + ' }';
+}
+function stringifyArray(array, depth, numberAsFloat) {
+    if (array.length === 0)
+        return '[]';
+    let res = '[ ';
+    for (let i = 0; i < array.length; i++) {
+        if (i)
+            res += ', ';
+        if (array[i] === null || array[i] === void 0) {
+            throw new TypeError('arrays cannot contain null or undefined values');
+        }
+        res += stringifyValue(array[i], extendedTypeOf(array[i]), depth - 1, numberAsFloat);
+    }
+    return res + ' ]';
+}
+function stringifyArrayTable(array, key, depth, numberAsFloat) {
+    if (depth === 0) {
+        throw new Error('Could not stringify the object: maximum object depth exceeded');
+    }
+    let res = '';
+    for (let i = 0; i < array.length; i++) {
+        res += `${res && '\n'}[[${key}]]\n`;
+        res += stringifyTable(0, array[i], key, depth, numberAsFloat);
+    }
+    return res;
+}
+function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
+    if (depth === 0) {
+        throw new Error('Could not stringify the object: maximum object depth exceeded');
+    }
+    let preamble = '';
+    let tables = '';
+    let keys = Object.keys(obj);
+    for (let i = 0; i < keys.length; i++) {
+        let k = keys[i];
+        if (obj[k] !== null && obj[k] !== void 0) {
+            let type = extendedTypeOf(obj[k]);
+            if (type === 'symbol' || type === 'function') {
+                throw new TypeError(`cannot serialize values of type '${type}'`);
+            }
+            let key = BARE_KEY.test(k) ? k : formatString(k);
+            if (type === 'array' && isArrayOfTables(obj[k])) {
+                tables += (tables && '\n') + stringifyArrayTable(obj[k], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
+            }
+            else if (type === 'object') {
+                let tblKey = prefix ? `${prefix}.${key}` : key;
+                tables += (tables && '\n') + stringifyTable(tblKey, obj[k], tblKey, depth - 1, numberAsFloat);
+            }
+            else {
+                preamble += key;
+                preamble += ' = ';
+                preamble += stringifyValue(obj[k], type, depth, numberAsFloat);
+                preamble += '\n';
+            }
+        }
+    }
+    if (tableKey && (preamble || !tables)) // Create table only if necessary
+        preamble = preamble ? `[${tableKey}]\n${preamble}` : `[${tableKey}]`;
+    return preamble && tables
+        ? `${preamble}\n${tables}`
+        : preamble || tables;
+}
+function stringify(obj, { maxDepth = 1000, numbersAsFloat = false } = {}) {
+    if (extendedTypeOf(obj) !== 'object') {
+        throw new TypeError('stringify can only be called with an object');
+    }
+    let str = stringifyTable(0, obj, '', maxDepth, numbersAsFloat);
+    if (str[str.length - 1] !== '\n')
+        return str + '\n';
+    return str;
+}
+
+;// ../../node_modules/smol-toml/dist/index.js
+/*!
+ * Copyright (c) Squirrel Chat et al., All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+
+
+/* harmony default export */ const dist = ({ parse: parse_parse, stringify: stringify, TomlDate: TomlDate, TomlError: TomlError });
+
+
+;// ../../packages/core/dist/index.js
+
+
+
+// src/branded-types.ts
+function email(value) {
+    return value;
+}
+function authCode(value) {
+    return value;
+}
+function googleCredential(value) {
+    return value;
+}
+function accessToken(value) {
+    return value;
+}
+function refreshToken(value) {
+    return value;
+}
+function mcpToken(value) {
+    return value;
+}
+function cloneToken(value) {
+    return value;
+}
+function jobId(value) {
+    return value;
+}
+function userDID(value) {
+    return value;
+}
+function entityType(value) {
+    return value;
+}
+function searchQuery(value) {
+    return value;
+}
+function baseUrl(value) {
+    return value;
+}
+function resourceUri(uri) {
+    if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
+        throw new TypeError(`Expected ResourceUri, got: ${uri}`);
+    }
+    return uri;
+}
+function annotationUri(uri) {
+    if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
+        throw new TypeError(`Expected AnnotationUri, got: ${uri}`);
+    }
+    return uri;
+}
+function resourceAnnotationUri(uri) {
+    if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
+        throw new TypeError(`Expected ResourceAnnotationUri, got: ${uri}`);
+    }
+    if (!uri.includes("/resources/") || !uri.includes("/annotations/")) {
+        throw new TypeError(`Expected nested ResourceAnnotationUri format, got: ${uri}`);
+    }
+    return uri;
+}
+// src/creation-methods.ts
+var CREATION_METHODS = {
+    API: "api",
+    UPLOAD: "upload",
+    UI: "ui",
+    REFERENCE: "reference",
+    CLONE: "clone",
+    GENERATED: "generated"
+};
+// src/identifiers.ts
+function isResourceId(value) {
+    return !value.includes("/");
+}
+function isAnnotationId(value) {
+    return !value.includes("/");
+}
+function resourceId(id) {
+    if (id.includes("/")) {
+        throw new TypeError(`Expected ResourceId, got URI: ${id}`);
+    }
+    return id;
+}
+function annotationId(id) {
+    if (id.includes("/")) {
+        throw new TypeError(`Expected AnnotationId, got URI: ${id}`);
+    }
+    return id;
+}
+function userId(id) {
+    return id;
+}
+// src/events.ts
+function isResourceEvent(event) {
+    return event && typeof event.id === "string" && typeof event.timestamp === "string" && (event.resourceId === void 0 || typeof event.resourceId === "string") && // resourceId now optional
+    typeof event.type === "string" && event.type.includes(".");
+}
+function isSystemEvent(event) {
+    return event.type === "entitytype.added";
+}
+function isResourceScopedEvent(event) {
+    return !isSystemEvent(event);
+}
+function getEventType(event) {
+    return event.type;
+}
+// src/event-utils.ts
+function getAnnotationUriFromEvent(event) {
+    const eventData = event.event;
+    if (eventData.type === "annotation.added") {
+        return eventData.payload.annotation.id || null;
+    }
+    if (eventData.type === "annotation.removed" || eventData.type === "annotation.body.updated") {
+        if (eventData.payload.annotationId && eventData.resourceId) {
+            try {
+                const resourceUri2 = eventData.resourceId;
+                const baseUrl2 = resourceUri2.substring(0, resourceUri2.lastIndexOf("/resources/"));
+                return `${baseUrl2}/annotations/${eventData.payload.annotationId}`;
+            } catch (e) {
+                return null;
+            }
+        }
+    }
+    return null;
+}
+function isEventRelatedToAnnotation(event, annotationUri2) {
+    const eventAnnotationUri = getAnnotationUriFromEvent(event);
+    return eventAnnotationUri === annotationUri2;
+}
+function isResourceEvent2(event) {
+    return event && typeof event.event === "object" && typeof event.event.id === "string" && typeof event.event.timestamp === "string" && typeof event.event.resourceId === "string" && typeof event.event.type === "string" && typeof event.metadata === "object" && typeof event.metadata.sequenceNumber === "number";
+}
+var EventBus = class {
+    constructor(){
+        this.subjects = /* @__PURE__ */ new Map();
+        this.isDestroyed = false;
+    }
+    /**
+   * Get the RxJS Subject for an event
+   *
+   * Returns a typed Subject that can be used with all RxJS operators.
+   * Subjects are created lazily on first access.
+   *
+   * @param eventName - The event name
+   * @returns The RxJS Subject for this event
+   *
+   * @example
+   * ```typescript
+   * // Emit
+   * eventBus.get('beckon:hover').next({ annotationId: 'ann-1' });
+   *
+   * // Subscribe
+   * const sub = eventBus.get('beckon:hover').subscribe(handleHover);
+   *
+   * // With operators
+   * eventBus.get('beckon:hover')
+   *   .pipe(debounceTime(100), distinctUntilChanged())
+   *   .subscribe(handleHover);
+   * ```
+   */ get(eventName) {
+        if (this.isDestroyed) {
+            throw new Error(`Cannot access event '${String(eventName)}' on destroyed bus`);
+        }
+        if (!this.subjects.has(eventName)) {
+            this.subjects.set(eventName, new Subject());
+        }
+        return this.subjects.get(eventName);
+    }
+    /**
+   * Destroy the event bus and complete all subjects
+   *
+   * After calling destroy(), no new events can be emitted or subscribed to.
+   * All active subscriptions will be completed.
+   */ destroy() {
+        if (this.isDestroyed) {
+            return;
+        }
+        for (const subject of this.subjects.values()){
+            subject.complete();
+        }
+        this.subjects.clear();
+        this.isDestroyed = true;
+    }
+    /**
+   * Check if the event bus has been destroyed
+   */ get destroyed() {
+        return this.isDestroyed;
+    }
+    /**
+   * Create a resource-scoped event bus
+   *
+   * Events emitted or subscribed through the scoped bus are isolated to that resource.
+   * Internally, events are namespaced but the API remains identical to the parent bus.
+   *
+   * @param resourceId - Resource identifier to scope events to
+   * @returns A scoped event bus for this resource
+   *
+   * @example
+   * ```typescript
+   * const eventBus = new EventBus();
+   * const resource1 = eventBus.scope('resource-1');
+   * const resource2 = eventBus.scope('resource-2');
+   *
+   * // These are isolated - only resource1 subscribers will fire
+   * resource1.get('detection:progress').next({ status: 'started' });
+   * ```
+   */ scope(resourceId2) {
+        return new ScopedEventBus(this, resourceId2);
+    }
+};
+var ScopedEventBus = class _ScopedEventBus {
+    constructor(parent, scopePrefix){
+        this.parent = parent;
+        this.scopePrefix = scopePrefix;
+    }
+    /**
+   * Get the RxJS Subject for a scoped event
+   *
+   * Returns the same type as the parent bus, but events are isolated to this scope.
+   * Internally uses namespaced keys but preserves type safety.
+   *
+   * @param event - The event name
+   * @returns The RxJS Subject for this scoped event
+   */ get(event) {
+        const scopedKey = `${this.scopePrefix}:${event}`;
+        const parentSubjects = this.parent.subjects;
+        if (!parentSubjects.has(scopedKey)) {
+            parentSubjects.set(scopedKey, new Subject());
+        }
+        return parentSubjects.get(scopedKey);
+    }
+    /**
+   * Create a nested scope
+   *
+   * Allows hierarchical scoping like `resource-1:subsystem-a`
+   *
+   * @param subScope - Additional scope level
+   * @returns A nested scoped event bus
+   */ scope(subScope) {
+        return new _ScopedEventBus(this.parent, `${this.scopePrefix}:${subScope}`);
+    }
+};
+function burstBuffer(options) {
+    const { burstWindowMs, maxBatchSize, idleTimeoutMs } = options;
+    return (source)=>new Observable((subscriber)=>{
+            let mode = "passthrough";
+            let buffer = [];
+            let burstTimer = null;
+            let idleTimer = null;
+            function clearBurstTimer() {
+                if (burstTimer !== null) {
+                    clearTimeout(burstTimer);
+                    burstTimer = null;
+                }
+            }
+            function clearIdleTimer() {
+                if (idleTimer !== null) {
+                    clearTimeout(idleTimer);
+                    idleTimer = null;
+                }
+            }
+            function flush() {
+                if (buffer.length === 0) return;
+                const batch = buffer;
+                buffer = [];
+                subscriber.next(batch);
+            }
+            function startIdleTimer() {
+                clearIdleTimer();
+                idleTimer = setTimeout(()=>{
+                    idleTimer = null;
+                    mode = "passthrough";
+                }, idleTimeoutMs);
+            }
+            const subscription = source.subscribe({
+                next (value) {
+                    clearIdleTimer();
+                    if (mode === "passthrough") {
+                        subscriber.next(value);
+                        mode = "accumulating";
+                        burstTimer = setTimeout(()=>{
+                            burstTimer = null;
+                            flush();
+                            startIdleTimer();
+                        }, burstWindowMs);
+                        return;
+                    }
+                    buffer.push(value);
+                    clearBurstTimer();
+                    if (buffer.length >= maxBatchSize) {
+                        flush();
+                        startIdleTimer();
+                    } else {
+                        burstTimer = setTimeout(()=>{
+                            burstTimer = null;
+                            flush();
+                            startIdleTimer();
+                        }, burstWindowMs);
+                    }
+                },
+                error (err) {
+                    clearBurstTimer();
+                    clearIdleTimer();
+                    flush();
+                    subscriber.error(err);
+                },
+                complete () {
+                    clearBurstTimer();
+                    clearIdleTimer();
+                    flush();
+                    subscriber.complete();
+                }
+            });
+            return ()=>{
+                clearBurstTimer();
+                clearIdleTimer();
+                subscription.unsubscribe();
+            };
+        });
+}
+// src/annotation-utils.ts
+function findBodyItem(body, targetItem) {
+    if (!Array.isArray(body)) {
+        return -1;
+    }
+    for(let i = 0; i < body.length; i++){
+        const item = body[i];
+        if (typeof item === "object" && item !== null && "type" in item && "purpose" in item) {
+            const itemType = item.type;
+            const itemPurpose = item.purpose;
+            if (itemType !== targetItem.type || itemPurpose !== targetItem.purpose) {
+                continue;
+            }
+            if (targetItem.type === "TextualBody" && "value" in item) {
+                const itemValue = item.value;
+                if (itemValue === targetItem.value) {
+                    return i;
+                }
+            }
+            if (targetItem.type === "SpecificResource" && "source" in item) {
+                const itemSource = item.source;
+                if (itemSource === targetItem.source) {
+                    return i;
+                }
+            }
+        }
+    }
+    return -1;
+}
+function generateUuid() {
+    return randomBytes(16).toString("hex");
+}
+// src/annotation-assembly.ts
+function getTextPositionSelector(selector) {
+    if (!selector) return null;
+    const selectors = Array.isArray(selector) ? selector : [
+        selector
+    ];
+    const found = selectors.find((s)=>s.type === "TextPositionSelector");
+    if (!found) return null;
+    return found.type === "TextPositionSelector" ? found : null;
+}
+function getSvgSelector(selector) {
+    if (!selector) return null;
+    const selectors = Array.isArray(selector) ? selector : [
+        selector
+    ];
+    const found = selectors.find((s)=>s.type === "SvgSelector");
+    if (!found) return null;
+    return found.type === "SvgSelector" ? found : null;
+}
+function getFragmentSelector(selector) {
+    if (!selector) return null;
+    const selectors = Array.isArray(selector) ? selector : [
+        selector
+    ];
+    const found = selectors.find((s)=>s.type === "FragmentSelector");
+    if (!found) return null;
+    return found.type === "FragmentSelector" ? found : null;
+}
+function validateSvgMarkup(svg) {
+    if (!svg.includes('xmlns="http://www.w3.org/2000/svg"')) {
+        return 'SVG must include xmlns="http://www.w3.org/2000/svg" attribute';
+    }
+    if (!svg.includes("<svg") || !svg.includes("</svg>")) {
+        return "SVG must have opening and closing tags";
+    }
+    const shapeElements = [
+        "rect",
+        "circle",
+        "ellipse",
+        "polygon",
+        "polyline",
+        "path",
+        "line"
+    ];
+    const hasShape = shapeElements.some((shape)=>svg.includes(`<${shape}`) || svg.includes(`<${shape} `));
+    if (!hasShape) {
+        return "SVG must contain at least one shape element (rect, circle, ellipse, polygon, polyline, path, or line)";
+    }
+    return null;
+}
+function assembleAnnotation(request, creator) {
+    const newAnnotationId = generateUuid();
+    const posSelector = getTextPositionSelector(request.target.selector);
+    const svgSelector = getSvgSelector(request.target.selector);
+    const fragmentSelector = getFragmentSelector(request.target.selector);
+    if (!posSelector && !svgSelector && !fragmentSelector) {
+        throw new Error("Either TextPositionSelector, SvgSelector, or FragmentSelector is required for creating annotations");
+    }
+    if (svgSelector) {
+        const svgError = validateSvgMarkup(svgSelector.value);
+        if (svgError) {
+            throw new Error(`Invalid SVG markup: ${svgError}`);
+        }
+    }
+    if (!request.motivation) {
+        throw new Error("motivation is required");
+    }
+    const now = /* @__PURE__ */ new Date().toISOString();
+    const annotation = {
+        "@context": "http://www.w3.org/ns/anno.jsonld",
+        "type": "Annotation",
+        id: newAnnotationId,
+        motivation: request.motivation,
+        target: request.target,
+        body: request.body,
+        creator,
+        created: now,
+        modified: now
+    };
+    const bodyArray = Array.isArray(request.body) ? request.body : request.body ? [
+        request.body
+    ] : [];
+    return {
+        annotation,
+        bodyArray
+    };
+}
+function applyBodyOperations(body, operations) {
+    const bodyArray = Array.isArray(body) ? [
+        ...body
+    ] : [];
+    for (const op of operations){
+        if (op.op === "add") {
+            const exists = bodyArray.some((item)=>JSON.stringify(item) === JSON.stringify(op.item));
+            if (!exists) {
+                bodyArray.push(op.item);
+            }
+        } else if (op.op === "remove") {
+            const index = bodyArray.findIndex((item)=>JSON.stringify(item) === JSON.stringify(op.item));
+            if (index !== -1) {
+                bodyArray.splice(index, 1);
+            }
+        } else if (op.op === "replace") {
+            const index = bodyArray.findIndex((item)=>JSON.stringify(item) === JSON.stringify(op.oldItem));
+            if (index !== -1) {
+                bodyArray[index] = op.newItem;
+            }
+        }
+    }
+    return bodyArray;
+}
+// src/type-guards.ts
+function isString(value) {
+    return typeof value === "string";
+}
+function isNumber(value) {
+    return typeof value === "number" && !isNaN(value);
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isArray(value) {
+    return Array.isArray(value);
+}
+function isBoolean(value) {
+    return typeof value === "boolean";
+}
+function isFunction(value) {
+    return typeof value === "function";
+}
+function isNull(value) {
+    return value === null;
+}
+function isUndefined(value) {
+    return value === void 0;
+}
+function isNullish(value) {
+    return value === null || value === void 0;
+}
+function isDefined(value) {
+    return value !== null && value !== void 0;
+}
+// src/errors.ts
+var SemiontError = class extends Error {
+    constructor(message, code, details){
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "SemiontError";
+        Error.captureStackTrace(this, this.constructor);
+    }
+};
+var ValidationError = class extends SemiontError {
+    constructor(message, details){
+        super(message, "VALIDATION_ERROR", details);
+        this.name = "ValidationError";
+    }
+};
+var ScriptError = class extends SemiontError {
+    constructor(message, code = "SCRIPT_ERROR", details){
+        super(message, code, details);
+        this.name = "ScriptError";
+    }
+};
+var NotFoundError = class extends SemiontError {
+    constructor(resource, id){
+        const message = id ? `${resource} with id '${id}' not found` : `${resource} not found`;
+        super(message, "NOT_FOUND", {
+            resource,
+            id
+        });
+        this.name = "NotFoundError";
+    }
+};
+var UnauthorizedError = class extends SemiontError {
+    constructor(message = "Unauthorized", details){
+        super(message, "UNAUTHORIZED", details);
+        this.name = "UnauthorizedError";
+    }
+};
+var ConflictError = class extends SemiontError {
+    constructor(message, details){
+        super(message, "CONFLICT", details);
+        this.name = "ConflictError";
+    }
+};
+var APIError = class extends Error {
+    constructor(status, data, message){
+        super(message || `API Error: ${status}`);
+        this.status = status;
+        this.data = data;
+        this.name = "APIError";
+        Error.captureStackTrace(this, this.constructor);
+    }
+};
+// src/did-utils.ts
+function userToDid(user) {
+    return `did:web:${user.domain}:users:${user.id}`;
+}
+function userToAgent(user) {
+    return {
+        type: "Person",
+        id: userToDid(user),
+        name: user.name || user.email
+    };
+}
+function didToAgent(did) {
+    const parts = did.split(":");
+    const userId2 = parts[parts.length - 1] || "unknown";
+    return {
+        type: "Person",
+        id: did,
+        name: userId2
+    };
+}
+function deepMerge(base, override) {
+    const result = {
+        ...base
+    };
+    for (const key of Object.keys(override)){
+        const b = base[key];
+        const o = override[key];
+        if (o !== void 0 && o !== null && typeof o === "object" && !Array.isArray(o) && b !== void 0 && b !== null && typeof b === "object" && !Array.isArray(b)) {
+            result[key] = deepMerge(b, o);
+        } else if (o !== void 0) {
+            result[key] = o;
+        }
+    }
+    return result;
+}
+function resolveEnvVars(obj, env) {
+    if (typeof obj === "string") {
+        return obj.replace(/\$\{([^}]+)\}/g, (match, varName)=>{
+            if (env[varName] === void 0) {
+                throw new Error(`Environment variable ${varName} is not set (referenced in config as ${match})`);
+            }
+            return env[varName];
+        });
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item)=>resolveEnvVars(item, env));
+    }
+    if (obj !== null && typeof obj === "object") {
+        const resolved = {};
+        for(const key in obj){
+            resolved[key] = resolveEnvVars(obj[key], env);
+        }
+        return resolved;
+    }
+    return obj;
+}
+function requirePlatform(value, serviceName) {
+    if (!value) {
+        throw new Error(`platform is required for service '${serviceName}' \u2014 add 'platform = "posix"|"container"|"external"' to its config section`);
+    }
+    return value;
+}
+function loadTomlConfig(projectRoot, environment, globalConfigPath, reader, env) {
+    const projectConfigContent = reader.readIfExists(`${projectRoot}/.semiont/config`);
+    let projectName = "semiont-project";
+    let projectSite;
+    let projectEnvSection = {};
+    if (projectConfigContent) {
+        const projectConfig = parse(projectConfigContent);
+        projectName = projectConfig.project?.name ?? projectName;
+        projectSite = projectConfig.site;
+        projectEnvSection = projectConfig.environments?.[environment] ?? {};
+    }
+    const globalContent = reader.readIfExists(globalConfigPath);
+    const raw = globalContent ? parse(globalContent) : {};
+    const userEnvSection = raw.environments?.[environment] ?? {};
+    const envSection = deepMerge(projectEnvSection, userEnvSection);
+    const resolved = resolveEnvVars(envSection, env);
+    const flatInference = resolved.inference;
+    const makeMeaningSection = resolved["make-meaning"];
+    const workersSection = resolved.workers ?? {};
+    const actorsSection = resolved.actors ?? {};
+    const defaultWorkerInference = workersSection["default"]?.inference;
+    const defaultMakeMeaningInference = makeMeaningSection?.default?.inference;
+    function mergeWithFlatInference(specific) {
+        if (!flatInference) return specific;
+        const providerDefaults = {};
+        if (specific.type === "anthropic") {
+            const a = flatInference.anthropic;
+            if (a) {
+                providerDefaults.apiKey = a.apiKey;
+                providerDefaults.endpoint = a.endpoint;
+            } else {
+                if (!flatInference.type) {
+                    throw new Error(`[environments.${environment}.inference] is missing 'type'. Add type = "anthropic" or use [inference.anthropic] sub-section.`);
+                }
+                providerDefaults.apiKey = flatInference.apiKey;
+                providerDefaults.endpoint = flatInference.endpoint;
+            }
+        } else if (specific.type === "ollama") {
+            const o = flatInference.ollama;
+            if (o) {
+                providerDefaults.baseURL = o.baseURL;
+            } else {
+                if (!flatInference.type) {
+                    throw new Error(`[environments.${environment}.inference] is missing 'type'. Add type = "ollama" or use [inference.ollama] sub-section.`);
+                }
+                providerDefaults.baseURL = flatInference.baseURL;
+            }
+        }
+        return {
+            maxTokens: flatInference.maxTokens,
+            ...providerDefaults,
+            ...specific
+        };
+    }
+    function resolveActorInference(fromMakeMeaning, fromActors) {
+        const base = fromMakeMeaning ?? fromActors ?? defaultMakeMeaningInference;
+        if (!base) return void 0;
+        return mergeWithFlatInference(base);
+    }
+    const actors = {};
+    const gathererInference = resolveActorInference(makeMeaningSection?.actors?.gatherer?.inference, actorsSection["gatherer"]?.inference);
+    if (gathererInference) actors.gatherer = gathererInference;
+    const matcherInference = resolveActorInference(makeMeaningSection?.actors?.matcher?.inference, actorsSection["matcher"]?.inference);
+    if (matcherInference) actors.matcher = matcherInference;
+    const workers = {};
+    const workerTypes = [
+        "reference-annotation",
+        "highlight-annotation",
+        "assessment-annotation",
+        "comment-annotation",
+        "tag-annotation",
+        "generation"
+    ];
+    if (defaultWorkerInference) {
+        workers.default = mergeWithFlatInference(defaultWorkerInference);
+    }
+    for (const wt of workerTypes){
+        const specific = workersSection[wt]?.inference;
+        if (specific) {
+            workers[wt] = mergeWithFlatInference(specific);
+        }
+    }
+    const backend = resolved.backend;
+    const site = resolved.site ?? projectSite;
+    const inferenceSection = resolved.inference;
+    let inferenceProviders;
+    if (inferenceSection) {
+        inferenceProviders = {};
+        if (inferenceSection.anthropic) {
+            const a = inferenceSection.anthropic;
+            inferenceProviders.anthropic = {
+                platform: requirePlatform(a.platform, "inference.anthropic"),
+                endpoint: a.endpoint ?? "https://api.anthropic.com",
+                apiKey: a.apiKey ?? ""
+            };
+        } else if (inferenceSection.type === "anthropic") {
+            inferenceProviders.anthropic = {
+                platform: requirePlatform(inferenceSection.platform, "inference"),
+                endpoint: inferenceSection.endpoint ?? "https://api.anthropic.com",
+                apiKey: inferenceSection.apiKey ?? ""
+            };
+        }
+        if (inferenceSection.ollama) {
+            const o = inferenceSection.ollama;
+            inferenceProviders.ollama = {
+                platform: {
+                    type: requirePlatform(o.platform, "inference.ollama")
+                },
+                baseURL: o.baseURL,
+                port: o.baseURL ? void 0 : o.port ?? 11434
+            };
+        } else if (inferenceSection.type === "ollama") {
+            inferenceProviders.ollama = {
+                platform: {
+                    type: requirePlatform(inferenceSection.platform, "inference")
+                },
+                baseURL: inferenceSection.baseURL,
+                port: inferenceSection.baseURL ? void 0 : 11434
+            };
+        }
+    }
+    const topLevelWorkers = {};
+    for (const [name, w] of Object.entries(workersSection)){
+        if (w.inference) {
+            topLevelWorkers[name] = {
+                inference: {
+                    type: w.inference.type,
+                    model: w.inference.model
+                }
+            };
+        }
+    }
+    const topLevelActors = {};
+    for (const [name, a] of Object.entries(actorsSection)){
+        if (a.inference) {
+            topLevelActors[name] = {
+                inference: {
+                    type: a.inference.type,
+                    model: a.inference.model
+                }
+            };
+        }
+    }
+    if (makeMeaningSection?.actors?.gatherer?.inference) {
+        topLevelActors["gatherer"] = {
+            inference: {
+                type: makeMeaningSection.actors.gatherer.inference.type,
+                model: makeMeaningSection.actors.gatherer.inference.model
+            }
+        };
+    }
+    if (makeMeaningSection?.actors?.matcher?.inference) {
+        topLevelActors["matcher"] = {
+            inference: {
+                type: makeMeaningSection.actors.matcher.inference.type,
+                model: makeMeaningSection.actors.matcher.inference.model
+            }
+        };
+    }
+    const frontend = resolved.frontend;
+    const proxy = resolved.proxy;
+    const config = {
+        services: {
+            backend: backend ? {
+                platform: {
+                    type: requirePlatform(backend.platform, "backend")
+                },
+                port: backend.port ?? 4e3,
+                publicURL: backend.publicURL ?? `http://localhost:${backend.port ?? 4e3}`,
+                corsOrigin: backend.corsOrigin ?? backend.frontendURL ?? "http://localhost:3000"
+            } : void 0,
+            frontend: frontend ? {
+                platform: {
+                    type: requirePlatform(frontend.platform, "frontend")
+                },
+                port: frontend.port ?? 3e3,
+                siteName: site?.siteName ?? "Semiont",
+                publicURL: frontend.publicURL
+            } : void 0,
+            proxy: proxy ? {
+                platform: {
+                    type: requirePlatform(proxy.platform, "proxy")
+                },
+                type: "envoy",
+                port: proxy.port ?? 8080,
+                adminPort: proxy.adminPort ?? 9901,
+                backendPort: backend?.port ?? 4e3,
+                frontendPort: frontend?.port ?? 3e3
+            } : void 0,
+            graph: resolved.graph ? {
+                ...resolved.graph,
+                platform: {
+                    type: requirePlatform(resolved.graph.platform, "graph")
+                },
+                type: resolved.graph.type ?? "neo4j"
+            } : makeMeaningSection?.graph,
+            database: resolved.database ? {
+                platform: {
+                    type: requirePlatform(resolved.database.platform, "database")
+                },
+                type: "postgres",
+                image: resolved.database.image,
+                host: resolved.database.host ?? "localhost",
+                port: resolved.database.port ?? 5432,
+                name: resolved.database.name,
+                user: resolved.database.user,
+                password: resolved.database.password
+            } : void 0
+        },
+        ...inferenceProviders ? {
+            inference: inferenceProviders
+        } : {},
+        ...Object.keys(topLevelWorkers).length > 0 ? {
+            workers: topLevelWorkers
+        } : {},
+        ...Object.keys(topLevelActors).length > 0 ? {
+            actors: topLevelActors
+        } : {},
+        site: site ? {
+            domain: site.domain ?? "localhost",
+            siteName: site.siteName,
+            adminEmail: site.adminEmail,
+            oauthAllowedDomains: site.oauthAllowedDomains
+        } : void 0,
+        logLevel: resolved.logLevel,
+        _metadata: {
+            environment,
+            projectRoot,
+            projectName,
+            ...Object.keys(actors).length > 0 ? {
+                actors
+            } : {},
+            ...Object.keys(workers).length > 0 ? {
+                workers
+            } : {}
+        }
+    };
+    return config;
+}
+function createTomlConfigLoader(reader, globalConfigPath, env) {
+    return (projectRoot, environment)=>{
+        return loadTomlConfig(projectRoot, environment, globalConfigPath, reader, env);
+    };
+}
+// src/config/environment-validator.ts
+function isValidEnvironment(value, availableEnvironments) {
+    if (!value) return false;
+    return availableEnvironments.includes(value);
+}
+function parseEnvironment(value, availableEnvironments) {
+    if (!value) {
+        throw new Error("Environment is required");
+    }
+    if (!isValidEnvironment(value, availableEnvironments)) {
+        throw new Error(`Invalid environment: ${value}. Available environments: ${availableEnvironments.join(", ")}`);
+    }
+    return value;
+}
+function validateEnvironment(value, availableEnvironments) {
+    if (!value) {
+        throw new Error("Environment is required");
+    }
+    if (!isValidEnvironment(value, availableEnvironments)) {
+        throw new Error(`Invalid environment: ${value}. Available environments: ${availableEnvironments.join(", ")}`);
+    }
+    return value;
+}
+// src/config/configuration-error.ts
+var ConfigurationError = class extends Error {
+    constructor(message, environment, suggestion, cause){
+        super(message);
+        this.environment = environment;
+        this.suggestion = suggestion;
+        this.name = "ConfigurationError";
+        this.cause = cause;
+    }
+    /**
+   * Format the error nicely for CLI output
+   */ toString() {
+        let output = `\u274C ${this.message}`;
+        if (this.environment) {
+            output += `
+   Environment: ${this.environment}`;
+        }
+        if (this.suggestion) {
+            output += `
+   \u{1F4A1} Suggestion: ${this.suggestion}`;
+        }
+        return output;
+    }
+};
+// src/config/platform-types.ts
+function isValidPlatformType(value) {
+    return [
+        "aws",
+        "container",
+        "posix",
+        "external"
+    ].includes(value);
+}
+function getAllPlatformTypes() {
+    return [
+        "aws",
+        "container",
+        "posix",
+        "external"
+    ];
+}
+// src/index.ts
+var CORE_TYPES_VERSION = "0.1.0";
+var SDK_VERSION = "0.1.0";
+ //# sourceMappingURL=index.js.map
+ //# sourceMappingURL=index.js.map
+
 // EXTERNAL MODULE: __barrel_optimize__?names=SemiontApiClient!=!../../packages/api-client/dist/index.js
 var api_client_dist = __webpack_require__(78431);
 ;// ./src/app/api/resources/[id]/route.ts
@@ -342,7 +2384,7 @@ async function GET(request, { params }) {
             baseUrl: backendUrl
         });
         // Get resource representation as stream
-        const rId = (0,dist/* resourceId */.a)(id);
+        const rId = resourceId(id);
         const { stream, contentType } = await client.getResourceRepresentationStream(rId, {
             accept: acceptHeader,
             auth: session.backendToken
@@ -722,6 +2764,13 @@ async function handler(req, res, ctx) {
 //# sourceMappingURL=app-route.js.map
 
 
+/***/ }),
+
+/***/ 94735:
+/***/ ((module) => {
+
+module.exports = require("events");
+
 /***/ })
 
 };
@@ -731,7 +2780,7 @@ async function handler(req, res, ctx) {
 var __webpack_require__ = require("../../../../webpack-runtime.js");
 __webpack_require__.C(exports);
 var __webpack_exec__ = (moduleId) => (__webpack_require__(__webpack_require__.s = moduleId))
-var __webpack_exports__ = __webpack_require__.X(0, [8569,4741,5781,7873,3144,730], () => (__webpack_exec__(94943)));
+var __webpack_exports__ = __webpack_require__.X(0, [8569,5866,5056,7873,3144,730], () => (__webpack_exec__(94251)));
 module.exports = __webpack_exports__;
 
 })();