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/react/promise/src/Internal/CancellationQueue.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace React\Promise\Internal;
+
+/**
+ * @internal
+ */
+final class CancellationQueue
+{
+    /** @var bool */
+    private $started = false;
+
+    /** @var object[] */
+    private $queue = [];
+
+    public function __invoke(): void
+    {
+        if ($this->started) {
+            return;
+        }
+
+        $this->started = true;
+        $this->drain();
+    }
+
+    /**
+     * @param mixed $cancellable
+     */
+    public function enqueue($cancellable): void
+    {
+        if (!\is_object($cancellable) || !\method_exists($cancellable, 'then') || !\method_exists($cancellable, 'cancel')) {
+            return;
+        }
+
+        $length = \array_push($this->queue, $cancellable);
+
+        if ($this->started && 1 === $length) {
+            $this->drain();
+        }
+    }
+
+    private function drain(): void
+    {
+        for ($i = \key($this->queue); isset($this->queue[$i]); $i++) {
+            $cancellable = $this->queue[$i];
+            assert(\method_exists($cancellable, 'cancel'));
+
+            $exception = null;
+
+            try {
+                $cancellable->cancel();
+            } catch (\Throwable $exception) {
+            }
+
+            unset($this->queue[$i]);
+
+            if ($exception) {
+                throw $exception;
+            }
+        }
+
+        $this->queue = [];
+    }
+}

vendor/react/promise/src/Internal/FulfilledPromise.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace React\Promise\Internal;
+
+use React\Promise\PromiseInterface;
+use function React\Promise\resolve;
+
+/**
+ * @internal
+ *
+ * @template T
+ * @template-implements PromiseInterface<T>
+ */
+final class FulfilledPromise implements PromiseInterface
+{
+    /** @var T */
+    private $value;
+
+    /**
+     * @param T $value
+     * @throws \InvalidArgumentException
+     */
+    public function __construct($value = null)
+    {
+        if ($value instanceof PromiseInterface) {
+            throw new \InvalidArgumentException('You cannot create React\Promise\FulfilledPromise with a promise. Use React\Promise\resolve($promiseOrValue) instead.');
+        }
+
+        $this->value = $value;
+    }
+
+    /**
+     * @template TFulfilled
+     * @param ?(callable((T is void ? null : T)): (PromiseInterface<TFulfilled>|TFulfilled)) $onFulfilled
+     * @return PromiseInterface<($onFulfilled is null ? T : TFulfilled)>
+     */
+    public function then(?callable $onFulfilled = null, ?callable $onRejected = null): PromiseInterface
+    {
+        if (null === $onFulfilled) {
+            return $this;
+        }
+
+        try {
+            /**
+             * @var PromiseInterface<T>|T $result
+             */
+            $result = $onFulfilled($this->value);
+            return resolve($result);
+        } catch (\Throwable $exception) {
+            return new RejectedPromise($exception);
+        }
+    }
+
+    public function catch(callable $onRejected): PromiseInterface
+    {
+        return $this;
+    }
+
+    public function finally(callable $onFulfilledOrRejected): PromiseInterface
+    {
+        return $this->then(function ($value) use ($onFulfilledOrRejected): PromiseInterface {
+            /** @var T $value */
+            return resolve($onFulfilledOrRejected())->then(function () use ($value) {
+                return $value;
+            });
+        });
+    }
+
+    public function cancel(): void
+    {
+    }
+
+    /**
+     * @deprecated 3.0.0 Use `catch()` instead
+     * @see self::catch()
+     */
+    public function otherwise(callable $onRejected): PromiseInterface
+    {
+        return $this->catch($onRejected);
+    }
+
+    /**
+     * @deprecated 3.0.0 Use `finally()` instead
+     * @see self::finally()
+     */
+    public function always(callable $onFulfilledOrRejected): PromiseInterface
+    {
+        return $this->finally($onFulfilledOrRejected);
+    }
+}

vendor/react/promise/src/Internal/RejectedPromise.php

@@ -0,0 +1,128 @@
+<?php
+
+namespace React\Promise\Internal;
+
+use React\Promise\PromiseInterface;
+use function React\Promise\_checkTypehint;
+use function React\Promise\resolve;
+use function React\Promise\set_rejection_handler;
+
+/**
+ * @internal
+ *
+ * @template-implements PromiseInterface<never>
+ */
+final class RejectedPromise implements PromiseInterface
+{
+    /** @var \Throwable */
+    private $reason;
+
+    /** @var bool */
+    private $handled = false;
+
+    /**
+     * @param \Throwable $reason
+     */
+    public function __construct(\Throwable $reason)
+    {
+        $this->reason = $reason;
+    }
+
+    /** @throws void */
+    public function __destruct()
+    {
+        if ($this->handled) {
+            return;
+        }
+
+        $handler = set_rejection_handler(null);
+        if ($handler === null) {
+            $message = 'Unhandled promise rejection with ' . $this->reason;
+
+            \error_log($message);
+            return;
+        }
+
+        try {
+            $handler($this->reason);
+        } catch (\Throwable $e) {
+            \preg_match('/^([^:\s]++)(.*+)$/sm', (string) $e, $match);
+            \assert(isset($match[1], $match[2]));
+            $message = 'Fatal error: Uncaught ' . $match[1] . ' from unhandled promise rejection handler' . $match[2];
+
+            \error_log($message);
+            exit(255);
+        }
+    }
+
+    /**
+     * @template TRejected
+     * @param ?callable $onFulfilled
+     * @param ?(callable(\Throwable): (PromiseInterface<TRejected>|TRejected)) $onRejected
+     * @return PromiseInterface<($onRejected is null ? never : TRejected)>
+     */
+    public function then(?callable $onFulfilled = null, ?callable $onRejected = null): PromiseInterface
+    {
+        if (null === $onRejected) {
+            return $this;
+        }
+
+        $this->handled = true;
+
+        try {
+            return resolve($onRejected($this->reason));
+        } catch (\Throwable $exception) {
+            return new RejectedPromise($exception);
+        }
+    }
+
+    /**
+     * @template TThrowable of \Throwable
+     * @template TRejected
+     * @param callable(TThrowable): (PromiseInterface<TRejected>|TRejected) $onRejected
+     * @return PromiseInterface<TRejected>
+     */
+    public function catch(callable $onRejected): PromiseInterface
+    {
+        if (!_checkTypehint($onRejected, $this->reason)) {
+            return $this;
+        }
+
+        /**
+         * @var callable(\Throwable):(PromiseInterface<TRejected>|TRejected) $onRejected
+         */
+        return $this->then(null, $onRejected);
+    }
+
+    public function finally(callable $onFulfilledOrRejected): PromiseInterface
+    {
+        return $this->then(null, function (\Throwable $reason) use ($onFulfilledOrRejected): PromiseInterface {
+            return resolve($onFulfilledOrRejected())->then(function () use ($reason): PromiseInterface {
+                return new RejectedPromise($reason);
+            });
+        });
+    }
+
+    public function cancel(): void
+    {
+        $this->handled = true;
+    }
+
+    /**
+     * @deprecated 3.0.0 Use `catch()` instead
+     * @see self::catch()
+     */
+    public function otherwise(callable $onRejected): PromiseInterface
+    {
+        return $this->catch($onRejected);
+    }
+
+    /**
+     * @deprecated 3.0.0 Use `always()` instead
+     * @see self::always()
+     */
+    public function always(callable $onFulfilledOrRejected): PromiseInterface
+    {
+        return $this->finally($onFulfilledOrRejected);
+    }
+}