Fix bin/publish: copy docs.dist from project root

Fix bin/publish: use correct .env path for rspade_system
Fix bin/publish script: prevent grep exit code 1 from terminating script

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

vendor/spatie/ignition/node_modules/url-slug/LICENSE

@@ -0,0 +1,20 @@
+The MIT License
+
+Copyright (c) stldo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

vendor/spatie/ignition/node_modules/url-slug/README.md

@@ -0,0 +1,258 @@
+# url-slug [![Build status][1]][2] [![npm][3]][5] [![npm][4]][5] [![minzipped size][6]][7]
+
+- **Less than 1kB** minified and gzipped;
+- Uses default JavaScript APIs, **no dependencies**;
+- **SEO** friendly;
+- **RFC 3986** compliant, compatible with URL hosts, paths, queries and
+  fragments;
+- Supports **custom dictionaries** to replace characters;
+- Easily **revert slugs**.
+
+## Installation
+
+```bash
+npm install url-slug
+```
+
+## Usage
+
+```javascript
+import urlSlug from 'url-slug'
+
+urlSlug('Sir James Paul McCartney MBE is an English singer-songwriter')
+// sir-james-paul-mc-cartney-mbe-is-an-english-singer-songwriter
+```
+
+### Usage with Node.js
+
+> ⚠️ Only named exports are available in Node.js.
+
+```javascript
+import { convert } from 'url-slug'
+
+urlSlug('Sir James Paul McCartney MBE is an English singer-songwriter')
+// sir-james-paul-mc-cartney-mbe-is-an-english-singer-songwriter
+```
+
+```javascript
+const { convert } = require('url-slug')
+
+urlSlug('Sir James Paul McCartney MBE is an English singer-songwriter')
+// sir-james-paul-mc-cartney-mbe-is-an-english-singer-songwriter
+```
+
+### urlSlug(value[, options]), convert(value[, options])
+
+Returns `value` value converted to a slug.
+
+#### value
+
+A string to be slugified.
+
+#### options
+
+| Name        | Description                                                                       | Default                 |
+| ----------- | --------------------------------------------------------------------------------- | ----------------------- |
+| camelCase   | Split on camel case occurrences                                                   | `true`                  |
+| dictionary  | [Chars to be replaced][8]                                                         | `{}`                    |
+| separator   | [Character or string][9] used to separate the slug fragments                      | `'-'`                   |
+| transformer | A built-in transformer or a custom function (`null` to keep the string unchanged) | `LOWERCASE_TRANSFORMER` |
+
+#### Examples
+
+```javascript
+import * as urlSlug from 'url-slug'
+
+urlSlug.convert('Comfortably Numb', {
+  transformer: urlSlug.UPPERCASE_TRANSFORMER,
+})
+// COMFORTABLY-NUMB
+
+urlSlug.convert('á é í ó ú Á É Í Ó Ú ç Ç ª º ¹ ² ½ ¼', {
+  separator: '_',
+  transformer: false,
+})
+// a_e_i_o_u_A_E_I_O_U_c_C_a_o_1_2_1_2_1_4
+
+urlSlug.convert('Red, red wine, stay close to me…', {
+  separator: '',
+  transformer: urlSlug.TITLECASE_TRANSFORMER,
+})
+// RedRedWineStayCloseToMe
+
+urlSlug.convert('Schwarzweiß', {
+  dictionary: { ß: 'ss', z: 'z ' },
+})
+// schwarz-weiss
+```
+
+### revert(value[, options])
+
+Returns the `value` value converted to a regular sentence.
+
+#### value
+
+A slug to be reverted to a sentence.
+
+#### options
+
+| Name        | Description                                                                       | Default |
+| ----------- | --------------------------------------------------------------------------------- | ------- |
+| camelCase   | Split on camel case occurrences                                                   | `false` |
+| separator   | [Character or string][9] to split the slug (`null` for automatic splitting)       | `null`  |
+| transformer | A built-in transformer or a custom function (`null` to keep the string unchanged) | `false` |
+
+#### Examples
+
+```javascript
+import { revert, TITLECASE_TRANSFORMER } from 'url-slug'
+
+revert('Replace-every_separator.allowed~andSplitCamelCaseToo', {
+  camelCase: true,
+})
+// Replace every separator allowed and Split Camel Case Too
+
+revert('this-slug-needs-a-title_case', {
+  separator: '-',
+  transformer: TITLECASE_TRANSFORMER,
+})
+// This Slug Needs A Title_case
+```
+
+### Custom transformers
+
+Custom transformers are expressed by a function that receives two arguments:
+`fragments`, an array containing the words of a sentence or a slug, and
+`separator`, which is the separator string set in `convert()` options. When
+`revert()` calls a transformer, the `separator` argument will always be a space
+character (`' '`) — the `separator` option will be used to split the slug.
+Transformers should always return a string.
+
+#### Examples
+
+```javascript
+import { convert, revert } from 'url-slug'
+
+convert('O’Neill is an American surfboard, surfwear and equipment brand', {
+  transformer: (fragments) => fragments.join('x').toUpperCase(),
+})
+// OxNEILLxISxANxAMERICANxSURFBOARDxSURFWEARxANDxEQUIPMENTxBRAND
+
+revert('WEIrd_SNAke_CAse', {
+  separator: '_',
+  transformer: (fragments, separator) =>
+    fragments
+      .map(
+        (fragment) =>
+          fragment.slice(0, -2).toLowerCase() + fragment.slice(-2).toUpperCase()
+      )
+      .join(separator),
+})
+// weiRD snaKE caSE
+```
+
+### Built-in transformers
+
+#### LOWERCASE_TRANSFORMER
+
+Converts the result to lowercase. E.g.: `// SOME WORDS >> some words`
+
+#### SENTENCECASE_TRANSFORMER
+
+Converts the result to sentence case. E.g.: `// sOME WORDS >> Some words`
+
+#### UPPERCASE_TRANSFORMER
+
+Converts the result to uppercase. E.g.: `// some words >> SOME WORDS`
+
+#### TITLECASE_TRANSFORMER
+
+Converts the result to title case. E.g.: `// sOME wORDS >> Some Words`
+
+### Separator characters
+
+Any character or an empty string can be used in the `separator` property. When
+the `separator` is an empty string, the `revert()` method will split the slug
+only on camel case occurrences if `camelCase` option is set to `true`,
+or else it returns an untouched string. The following characters are valid
+according to RFC 3986 — defined as _unreserved_ or _sub-delims_ —, and will be
+used in `revert()` function if automatic splitting is enabled — `separator` is
+set to `null`:
+
+`-`, `.`, `_`, `~`, `^`, `-`, `.`, `_`, `~`, `!`, `$`, `&`, `'`, `(`, `)`, `*`,
+`+`, `,`, `;` or `=`
+
+### `dictionary` option
+
+It must be an object, with keys set as single characters and values as strings
+of any length:
+
+```js
+import { convert } from 'url-slug'
+
+convert('♥øß', {
+  dictionary: {
+    '♥': 'love',
+    ø: 'o',
+    ß: 'ss',
+    //...
+  },
+})
+// loveoss
+```
+
+To add separators before or after a specific character, add a space before or
+after the dictionary definition:
+
+```js
+import { convert } from 'url-slug'
+
+convert('♥øß', {
+  dictionary: {
+    '♥': 'love',
+    ø: ' o', // A space was added before
+    ß: 'ss',
+    //...
+  },
+})
+// love-oss
+
+convert('♥øß', {
+  dictionary: {
+    '♥': 'love',
+    ø: ' o ', // A space was added before and after
+    ß: 'ss',
+    //...
+  },
+})
+// love-o-ss
+
+convert('♥øß', {
+  dictionary: {
+    '♥': 'love',
+    ø: 'o ', // A space was added after
+    ß: 'ss',
+    //...
+  },
+})
+// loveo-ss
+```
+
+### Compatibility
+
+Compatible with any environment with ES6 support.
+
+## License
+
+[The MIT License][license]
+
+[1]: https://img.shields.io/github/actions/workflow/status/stldo/url-slug/test.yml?branch=master
+[2]: https://github.com/stldo/url-slug/actions/workflows/test.js.yml
+[3]: https://img.shields.io/npm/dm/url-slug
+[4]: https://img.shields.io/npm/v/url-slug
+[5]: https://www.npmjs.com/package/url-slug
+[6]: https://img.shields.io/bundlephobia/minzip/url-slug
+[7]: https://bundlephobia.com/package/url-slug
+[8]: #dictionary-option
+[9]: #separator-characters
+[license]: ./LICENSE

vendor/spatie/ignition/node_modules/url-slug/dist/index.d.ts

@@ -0,0 +1,24 @@
+type Dictionary = Record<string, string>;
+
+type Transformer = (fragments: string[], separator: string) => string;
+declare const LOWERCASE_TRANSFORMER: Transformer;
+declare const SENTENCECASE_TRANSFORMER: Transformer;
+declare const TITLECASE_TRANSFORMER: Transformer;
+declare const UPPERCASE_TRANSFORMER: Transformer;
+
+interface ConvertOptions {
+    camelCase?: boolean;
+    dictionary?: Dictionary;
+    separator?: string;
+    transformer?: Transformer | null;
+}
+declare function convert(value: string, { camelCase, dictionary, separator, transformer, }?: ConvertOptions): string;
+
+interface RevertOptions {
+    camelCase?: boolean;
+    separator?: string | null;
+    transformer?: Transformer | null;
+}
+declare function revert(value: string, { camelCase, separator, transformer, }?: RevertOptions): string;
+
+export { LOWERCASE_TRANSFORMER, SENTENCECASE_TRANSFORMER, TITLECASE_TRANSFORMER, Transformer, UPPERCASE_TRANSFORMER, convert, convert as default, revert };

vendor/spatie/ignition/node_modules/url-slug/dist/index.js

@@ -0,0 +1,91 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.urlSlug = {}));
+})(this, (function (exports) { 'use strict';
+
+    const CAMELCASE_REGEXP_PATTERN = '(?:[a-z](?=[A-Z])|[A-Z](?=[A-Z][a-z]))';
+    function replace(value, dictionary) {
+        for (let index = 0, length = value.length; index < length; index++) {
+            const char = value[index];
+            const replacement = dictionary[char] && String(dictionary[char]);
+            if (replacement !== undefined) {
+                value = value.slice(0, index) + replacement + value.slice(index + 1);
+                const addedCharsCount = replacement.length - 1;
+                index += addedCharsCount;
+                length += addedCharsCount;
+            }
+        }
+        return value;
+    }
+
+    const LOWERCASE_TRANSFORMER = (fragments, separator) => {
+        return fragments.join(separator).toLowerCase();
+    };
+    const SENTENCECASE_TRANSFORMER = (fragments, separator) => {
+        const sentence = fragments.join(separator);
+        return sentence.charAt(0).toUpperCase() + sentence.slice(1).toLowerCase();
+    };
+    const TITLECASE_TRANSFORMER = (fragments, separator) => {
+        const buffer = [];
+        for (let index = 0; index < fragments.length; index++) {
+            buffer.push(fragments[index].charAt(0).toUpperCase() +
+                fragments[index].slice(1).toLowerCase());
+        }
+        return buffer.join(separator);
+    };
+    const UPPERCASE_TRANSFORMER = (fragments, separator) => {
+        return fragments.join(separator).toUpperCase();
+    };
+
+    // eslint-disable-next-line no-misleading-character-class
+    const COMBINING_CHARS = /[\u0300-\u036F\u1AB0-\u1AFF\u1DC0-\u1DFF]+/g;
+    const CONVERT = /[A-Za-z\d]+/g;
+    const CONVERT_CAMELCASE = new RegExp('[A-Za-z\\d]*?' + CAMELCASE_REGEXP_PATTERN + '|[A-Za-z\\d]+', 'g');
+    function convert(value, { camelCase = true, dictionary, separator = '-', transformer = LOWERCASE_TRANSFORMER, } = {}) {
+        const fragments = (dictionary ? replace(String(value), dictionary) : String(value))
+            .normalize('NFKD')
+            .replace(COMBINING_CHARS, '')
+            .match(camelCase ? CONVERT_CAMELCASE : CONVERT);
+        if (!fragments) {
+            return '';
+        }
+        return transformer
+            ? transformer(fragments, String(separator))
+            : fragments.join(String(separator));
+    }
+
+    const REVERT = /[^-._~!$&'()*+,;=]+/g;
+    const REVERT_CAMELCASE = new RegExp("[^-._~!$&'()*+,;=]*?" + CAMELCASE_REGEXP_PATTERN + "|[^-._~!$&'()*+,;=]+", 'g');
+    const REVERT_CAMELCASE_ONLY = new RegExp('.*?' + CAMELCASE_REGEXP_PATTERN + '|.+', 'g');
+    function revert(value, { camelCase = false, separator = null, transformer = null, } = {}) {
+        let fragments;
+        value = String(value);
+        /* Determine which method will be used to split the slug */
+        if (separator === '') {
+            fragments = camelCase ? value.match(REVERT_CAMELCASE_ONLY) : [value];
+        }
+        else if (typeof separator === 'string') {
+            fragments = value.split(separator);
+        }
+        else {
+            fragments = value.match(camelCase ? REVERT_CAMELCASE : REVERT);
+        }
+        if (!fragments) {
+            return '';
+        }
+        return transformer ? transformer(fragments, ' ') : fragments.join(' ');
+    }
+
+    exports.LOWERCASE_TRANSFORMER = LOWERCASE_TRANSFORMER;
+    exports.SENTENCECASE_TRANSFORMER = SENTENCECASE_TRANSFORMER;
+    exports.TITLECASE_TRANSFORMER = TITLECASE_TRANSFORMER;
+    exports.UPPERCASE_TRANSFORMER = UPPERCASE_TRANSFORMER;
+    exports.convert = convert;
+    exports.default = convert;
+    exports.revert = revert;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.js.map

vendor/spatie/ignition/node_modules/url-slug/dist/index.min.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).urlSlug={})}(this,(function(e){"use strict";const t="(?:[a-z](?=[A-Z])|[A-Z](?=[A-Z][a-z]))";const n=(e,t)=>e.join(t).toLowerCase(),o=/[\u0300-\u036F\u1AB0-\u1AFF\u1DC0-\u1DFF]+/g,r=/[A-Za-z\d]+/g,i=new RegExp("[A-Za-z\\d]*?"+t+"|[A-Za-z\\d]+","g");function s(e,{camelCase:t=!0,dictionary:s,separator:a="-",transformer:c=n}={}){const l=(s?function(e,t){for(let n=0,o=e.length;n<o;n++){const r=e[n],i=t[r]&&String(t[r]);if(void 0!==i){e=e.slice(0,n)+i+e.slice(n+1);const t=i.length-1;n+=t,o+=t}}return e}(String(e),s):String(e)).normalize("NFKD").replace(o,"").match(t?i:r);return l?c?c(l,String(a)):l.join(String(a)):""}const a=/[^-._~!$&'()*+,;=]+/g,c=new RegExp("[^-._~!$&'()*+,;=]*?"+t+"|[^-._~!$&'()*+,;=]+","g"),l=new RegExp(".*?"+t+"|.+","g");e.LOWERCASE_TRANSFORMER=n,e.SENTENCECASE_TRANSFORMER=(e,t)=>{const n=e.join(t);return n.charAt(0).toUpperCase()+n.slice(1).toLowerCase()},e.TITLECASE_TRANSFORMER=(e,t)=>{const n=[];for(let t=0;t<e.length;t++)n.push(e[t].charAt(0).toUpperCase()+e[t].slice(1).toLowerCase());return n.join(t)},e.UPPERCASE_TRANSFORMER=(e,t)=>e.join(t).toUpperCase(),e.convert=s,e.default=s,e.revert=function(e,{camelCase:t=!1,separator:n=null,transformer:o=null}={}){let r;return e=String(e),r=""===n?t?e.match(l):[e]:"string"==typeof n?e.split(n):e.match(t?c:a),r?o?o(r," "):r.join(" "):""},Object.defineProperty(e,"__esModule",{value:!0})}));

vendor/spatie/ignition/node_modules/url-slug/dist/index.mjs

@@ -0,0 +1,75 @@
+const CAMELCASE_REGEXP_PATTERN = '(?:[a-z](?=[A-Z])|[A-Z](?=[A-Z][a-z]))';
+function replace(value, dictionary) {
+    for (let index = 0, length = value.length; index < length; index++) {
+        const char = value[index];
+        const replacement = dictionary[char] && String(dictionary[char]);
+        if (replacement !== undefined) {
+            value = value.slice(0, index) + replacement + value.slice(index + 1);
+            const addedCharsCount = replacement.length - 1;
+            index += addedCharsCount;
+            length += addedCharsCount;
+        }
+    }
+    return value;
+}
+
+const LOWERCASE_TRANSFORMER = (fragments, separator) => {
+    return fragments.join(separator).toLowerCase();
+};
+const SENTENCECASE_TRANSFORMER = (fragments, separator) => {
+    const sentence = fragments.join(separator);
+    return sentence.charAt(0).toUpperCase() + sentence.slice(1).toLowerCase();
+};
+const TITLECASE_TRANSFORMER = (fragments, separator) => {
+    const buffer = [];
+    for (let index = 0; index < fragments.length; index++) {
+        buffer.push(fragments[index].charAt(0).toUpperCase() +
+            fragments[index].slice(1).toLowerCase());
+    }
+    return buffer.join(separator);
+};
+const UPPERCASE_TRANSFORMER = (fragments, separator) => {
+    return fragments.join(separator).toUpperCase();
+};
+
+// eslint-disable-next-line no-misleading-character-class
+const COMBINING_CHARS = /[\u0300-\u036F\u1AB0-\u1AFF\u1DC0-\u1DFF]+/g;
+const CONVERT = /[A-Za-z\d]+/g;
+const CONVERT_CAMELCASE = new RegExp('[A-Za-z\\d]*?' + CAMELCASE_REGEXP_PATTERN + '|[A-Za-z\\d]+', 'g');
+function convert(value, { camelCase = true, dictionary, separator = '-', transformer = LOWERCASE_TRANSFORMER, } = {}) {
+    const fragments = (dictionary ? replace(String(value), dictionary) : String(value))
+        .normalize('NFKD')
+        .replace(COMBINING_CHARS, '')
+        .match(camelCase ? CONVERT_CAMELCASE : CONVERT);
+    if (!fragments) {
+        return '';
+    }
+    return transformer
+        ? transformer(fragments, String(separator))
+        : fragments.join(String(separator));
+}
+
+const REVERT = /[^-._~!$&'()*+,;=]+/g;
+const REVERT_CAMELCASE = new RegExp("[^-._~!$&'()*+,;=]*?" + CAMELCASE_REGEXP_PATTERN + "|[^-._~!$&'()*+,;=]+", 'g');
+const REVERT_CAMELCASE_ONLY = new RegExp('.*?' + CAMELCASE_REGEXP_PATTERN + '|.+', 'g');
+function revert(value, { camelCase = false, separator = null, transformer = null, } = {}) {
+    let fragments;
+    value = String(value);
+    /* Determine which method will be used to split the slug */
+    if (separator === '') {
+        fragments = camelCase ? value.match(REVERT_CAMELCASE_ONLY) : [value];
+    }
+    else if (typeof separator === 'string') {
+        fragments = value.split(separator);
+    }
+    else {
+        fragments = value.match(camelCase ? REVERT_CAMELCASE : REVERT);
+    }
+    if (!fragments) {
+        return '';
+    }
+    return transformer ? transformer(fragments, ' ') : fragments.join(' ');
+}
+
+export { LOWERCASE_TRANSFORMER, SENTENCECASE_TRANSFORMER, TITLECASE_TRANSFORMER, UPPERCASE_TRANSFORMER, convert, convert as default, revert };
+//# sourceMappingURL=index.mjs.map