@scalar/workspace-store 0.59.0 → 0.61.0

package/dist/entities/auth/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/entities/auth/schema.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG1B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEpE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAE5C,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyC,CAAA;AACxE,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/entities/auth/schema.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG1B,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAEpE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMrB,CAAA;AAEF,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAE5C,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAyC,CAAA;AACxE,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA"}

package/dist/entities/auth/schema.js

@@ -2,8 +2,8 @@ import { Type } from '@scalar/typebox';
 import { compose } from '../../schemas/compose.js';
 import { XScalarCredentialsLocationSchema } from '../../schemas/extensions/security/x-scalar-credentials-location.js';
 import { XScalarSecretClientCertificateSchema, XScalarSecretClientIdSchema, XScalarSecretClientSecretSchema, XScalarSecretHTTPSchema, XScalarSecretPrivateKeySchema, XScalarSecretRedirectUriSchema, XScalarSecretRefreshTokenSchema, XScalarSecretServiceNameSchema, XScalarSecretTokenSchema, } from '../../schemas/extensions/security/x-scalar-security-secrets.js';
-import { OAuthFlowAuthorizationCodeSchema, OAuthFlowClientCredentialsSchema, OAuthFlowImplicitSchema, OAuthFlowPasswordSchema, } from '../../schemas/v3.1/strict/oauth-flow.js';
-import { SecurityRequirementObjectSchema } from '../../schemas/v3.1/strict/openapi-document.js';
+import { OAuthFlowAuthorizationCodeSchema, OAuthFlowClientCredentialsSchema, OAuthFlowImplicitSchema, OAuthFlowPasswordSchema, } from '../../schemas/v3.2/strict/oauth-flow.js';
+import { SecurityRequirementObjectSchema } from '../../schemas/v3.2/strict/openapi-document.js';
 const SecretsApiKeySchema = compose(Type.Object({
     type: Type.Literal('apiKey'),
 }), XScalarSecretTokenSchema);

package/dist/events/definitions/auth.d.ts

@@ -1,8 +1,8 @@
 import type { HttpMethod } from '@scalar/helpers/http/http-methods';
 import type { PartialDeep } from 'type-fest';
 import type { SecretsAuth } from '../../entities/auth/schema.js';
-import type { OAuthFlowsObject, SecurityRequirementObject, SecuritySchemeObject } from '../../schemas/v3.1/strict/openapi-document.js';
-import type { ApiKeyObject, HttpObject, OAuth2Object, OpenIdConnectObject } from '../../schemas/v3.1/strict/security-scheme.js';
+import type { OAuthFlowsObject, SecurityRequirementObject, SecuritySchemeObject } from '../../schemas/v3.2/strict/openapi-document.js';
+import type { ApiKeyObject, HttpObject, OAuth2Object, OpenIdConnectObject } from '../../schemas/v3.2/strict/security-scheme.js';
 /**
  * AuthMeta defines the meta information needed to specify whether the authentication operation
  * is being performed at the document level (entire API), or for a specific operation (specific path and method).

package/dist/events/definitions/document.d.ts

@@ -1,5 +1,5 @@
 import type { PartialDeep } from 'type-fest';
-import type { InfoObject } from '../../schemas/v3.1/strict/info.js';
+import type { InfoObject } from '../../schemas/v3.2/strict/info.js';
 /** Event definitions for the openapi document */
 export type DocumentEvents = {
     /**

package/dist/events/definitions/operation.d.ts

@@ -1,5 +1,5 @@
 import type { HttpMethod } from '@scalar/helpers/http/http-methods';
-import type { OperationObject, ParameterObject } from '../../schemas/v3.1/strict/openapi-document.js';
+import type { OperationObject, ParameterObject } from '../../schemas/v3.2/strict/openapi-document.js';
 /**
  * Describes the minimal identity for an operation in the workspace document.
  * It is used by mutators to find the target operation under `paths`.
@@ -256,8 +256,9 @@ export type OperationEvents = {
         /** The new value for the request body example */
         payload: {
             name: string;
-            value: string | File;
+            value: string | File | unknown[] | undefined;
             isDisabled: boolean;
+            isArray?: boolean;
         }[];
         /** The content type of the request body */
         contentType: string;

package/dist/events/definitions/operation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/events/definitions/operation.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/events/definitions/operation.ts"],"names":[],"mappings":"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"}

package/dist/events/definitions/server.d.ts

@@ -1,5 +1,5 @@
 import type { HttpMethod } from '@scalar/helpers/http/http-methods';
-import type { ServerObject } from '../../schemas/v3.1/strict/openapi-document.js';
+import type { ServerObject } from '../../schemas/v3.2/strict/openapi-document.js';
 export type ServerMeta = {
     type: 'document';
 } | {

package/dist/events/old-definitions.d.ts

@@ -1,7 +1,7 @@
 import type { HttpMethod } from '@scalar/helpers/http/http-methods';
 import type { AvailableClients } from '@scalar/snippetz';
 import type { Simplify } from 'type-fest';
-import type { ServerObject } from '../schemas/v3.1/strict/openapi-document.js';
+import type { ServerObject } from '../schemas/v3.2/strict/openapi-document.js';
 /**
  * Event definitions for scalar blocks
  *

package/dist/helpers/create-chunk-writer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a JSON writer rooted at the real output directory. The caller must keep this
+ * directory and its ancestors safe from concurrent changes by untrusted processes.
+ */
+export declare const createChunkWriter: (directory: string) => Promise<(segments: string[], value: unknown) => Promise<void>>;
+//# sourceMappingURL=create-chunk-writer.d.ts.map

package/dist/helpers/create-chunk-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-chunk-writer.d.ts","sourceRoot":"","sources":["../../src/helpers/create-chunk-writer.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAC5B,WAAW,MAAM,KAChB,OAAO,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAwC/D,CAAA"}

package/dist/helpers/create-chunk-writer.js

@@ -0,0 +1,44 @@
+import fs from 'node:fs/promises';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+/**
+ * Creates a JSON writer rooted at the real output directory. The caller must keep this
+ * directory and its ancestors safe from concurrent changes by untrusted processes.
+ */
+export const createChunkWriter = async (directory) => {
+    await fs.mkdir(directory, { recursive: true });
+    // Configured output roots may intentionally be symlinks, as may system directories such as /tmp.
+    const root = await fs.realpath(directory);
+    return async (segments, value) => {
+        const filename = resolve(root, ...segments);
+        const relativePath = relative(root, filename);
+        if (!relativePath || isAbsolute(relativePath) || relativePath === '..' || relativePath.startsWith(`..${sep}`)) {
+            throw new Error('Chunk path must stay inside the output directory');
+        }
+        // Check each ancestor before creating its children: recursive mkdir would follow a symlink
+        // and could create directories outside the root before we had a chance to validate it.
+        let parent = root;
+        const parentPath = relative(root, dirname(filename));
+        for (const segment of parentPath ? parentPath.split(sep) : []) {
+            parent = resolve(parent, segment);
+            await fs.mkdir(parent).catch((error) => {
+                if (!(error instanceof Error && 'code' in error && error.code === 'EEXIST')) {
+                    throw error;
+                }
+            });
+            const stat = await fs.lstat(parent);
+            if (!stat.isDirectory() || stat.isSymbolicLink()) {
+                throw new Error('Chunk directories must be real directories, not symbolic links');
+            }
+        }
+        const stat = await fs.lstat(filename).catch((error) => {
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                return undefined;
+            }
+            throw error;
+        });
+        if (stat && (!stat.isFile() || stat.isSymbolicLink())) {
+            throw new Error('Chunk destinations must be regular files, not symbolic links');
+        }
+        await fs.writeFile(filename, JSON.stringify(value));
+    };
+};

package/dist/helpers/dynamic-ref.d.ts

@@ -1,4 +1,4 @@
-import type { SchemaObject } from '../schemas/v3.1/strict/schema.js';
+import type { SchemaObject } from '../schemas/v3.2/strict/schema.js';
 /**
  * The dynamic scope, ordered outermost-first.
  *
@@ -11,7 +11,18 @@ export declare const isDynamicRef: (schema: unknown) => schema is SchemaObject &
     $dynamicRef: string;
 };
 export declare const collectDynamicAnchors: (resource: SchemaObject) => Map<string, SchemaObject>;
-/** Append a schema to the dynamic scope when it could hold a `$dynamicAnchor`, otherwise return it unchanged. */
+/**
+ * Append a schema resource to the dynamic scope when it could hold a `$dynamicAnchor`.
+ *
+ * A schema that carries the binding inline — its own `$dynamicAnchor`, or the `$id`/`$defs` binding
+ * written next to a `$ref` (how `Paginated<Planet>` is expressed) — enters the scope directly. A bare
+ * `$ref` to a *named* binding resource (e.g. `$ref: '#/components/schemas/PaginatedUserResponse'`)
+ * hides that resource's `$id`/`$defs` behind the ref, so the anchor is invisible here; follow the ref
+ * to reach the resource. Ordinary `$ref`s resolve to a schema without an anchor and are still skipped;
+ * an unresolved `$ref` resolves to `undefined` and is skipped too.
+ *
+ * See https://github.com/scalar/scalar/issues/9883.
+ */
 export declare const pushDynamicScope: (scope: DynamicScope, schema: SchemaObject) => DynamicScope;
 /**
  * Resolve a `$dynamicRef` fragment against the dynamic scope.

package/dist/helpers/dynamic-ref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic-ref.d.ts","sourceRoot":"","sources":["../../src/helpers/dynamic-ref.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAiBhE;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,YAAY,EAAE,CAAA;AAEzC,2DAA2D;AAC3D,eAAO,MAAM,YAAY,GAAI,QAAQ,OAAO,KAAG,MAAM,IAAI,YAAY,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAItB,CAAA;AAqBvE,eAAO,MAAM,qBAAqB,GAAI,UAAU,YAAY,KAAG,GAAG,CAAC,MAAM,EAAE,YAAY,CAgCtF,CAAA;AAED,iHAAiH;AACjH,eAAO,MAAM,gBAAgB,GAAI,OAAO,YAAY,EAAE,QAAQ,YAAY,KAAG,YAClB,CAAA;AAE3D;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,EAAE,OAAO,YAAY,KAAG,YAAY,GAAG,SAe1F,CAAA"}
+{"version":3,"file":"dynamic-ref.d.ts","sourceRoot":"","sources":["../../src/helpers/dynamic-ref.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAiBhE;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,YAAY,EAAE,CAAA;AAEzC,2DAA2D;AAC3D,eAAO,MAAM,YAAY,GAAI,QAAQ,OAAO,KAAG,MAAM,IAAI,YAAY,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CACuB,CAAA;AAqBpH,eAAO,MAAM,qBAAqB,GAAI,UAAU,YAAY,KAAG,GAAG,CAAC,MAAM,EAAE,YAAY,CAiCtF,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,YAAY,EAAE,QAAQ,YAAY,KAAG,YAG5E,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,EAAE,OAAO,YAAY,KAAG,YAAY,GAAG,SAe1F,CAAA"}

package/dist/helpers/dynamic-ref.js

@@ -1,10 +1,8 @@
+import { isObject } from '@scalar/helpers/object/is-object';
 import { getResolvedRef, mergeSiblingReferences } from '../helpers/get-resolved-ref.js';
 import { unpackProxyObject } from '../helpers/unpack-proxy.js';
 /** Narrow a schema to one that carries a `$dynamicRef`. */
-export const isDynamicRef = (schema) => typeof schema === 'object' &&
-    schema !== null &&
-    '$dynamicRef' in schema &&
-    typeof schema.$dynamicRef === 'string';
+export const isDynamicRef = (schema) => typeof schema === 'object' && schema !== null && '$dynamicRef' in schema && typeof schema.$dynamicRef === 'string';
 /**
  * Whether a schema introduces something a `$dynamicRef` could later bind to.
  *
@@ -40,7 +38,8 @@ export const collectDynamicAnchors = (resource) => {
         }
     };
     add(resource);
-    const defs = resource.$defs;
+    const schemaWithDefs = resource;
+    const defs = schemaWithDefs.$defs;
     if (defs && typeof defs === 'object') {
         for (const key of Object.keys(defs)) {
             add(defs[key]);
@@ -49,8 +48,22 @@ export const collectDynamicAnchors = (resource) => {
     anchorCache.set(cacheTarget, anchors);
     return anchors;
 };
-/** Append a schema to the dynamic scope when it could hold a `$dynamicAnchor`, otherwise return it unchanged. */
-export const pushDynamicScope = (scope, schema) => carriesDynamicAnchor(schema) ? [...scope, schema] : scope;
+/**
+ * Append a schema resource to the dynamic scope when it could hold a `$dynamicAnchor`.
+ *
+ * A schema that carries the binding inline — its own `$dynamicAnchor`, or the `$id`/`$defs` binding
+ * written next to a `$ref` (how `Paginated<Planet>` is expressed) — enters the scope directly. A bare
+ * `$ref` to a *named* binding resource (e.g. `$ref: '#/components/schemas/PaginatedUserResponse'`)
+ * hides that resource's `$id`/`$defs` behind the ref, so the anchor is invisible here; follow the ref
+ * to reach the resource. Ordinary `$ref`s resolve to a schema without an anchor and are still skipped;
+ * an unresolved `$ref` resolves to `undefined` and is skipped too.
+ *
+ * See https://github.com/scalar/scalar/issues/9883.
+ */
+export const pushDynamicScope = (scope, schema) => {
+    const resource = carriesDynamicAnchor(schema) ? schema : getResolvedRef(schema);
+    return isObject(resource) && carriesDynamicAnchor(resource) ? [...scope, resource] : scope;
+};
 /**
  * Resolve a `$dynamicRef` fragment against the dynamic scope.
  *

package/dist/helpers/encode-chunk-name.d.ts

@@ -0,0 +1,3 @@
+/** Encodes a chunk name as one portable filename and URL segment. */
+export declare const encodeChunkName: (name: string) => string;
+//# sourceMappingURL=encode-chunk-name.d.ts.map

package/dist/helpers/encode-chunk-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-chunk-name.d.ts","sourceRoot":"","sources":["../../src/helpers/encode-chunk-name.ts"],"names":[],"mappings":"AAEA,qEAAqE;AACrE,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,MAU9C,CAAA"}

package/dist/helpers/encode-chunk-name.js

@@ -0,0 +1,9 @@
+import { escapeJsonPointer } from '@scalar/json-magic/helpers/escape-json-pointer';
+/** Encodes a chunk name as one portable filename and URL segment. */
+export const encodeChunkName = (name) => {
+    // JSON Pointer escaping preserves existing names and reserves ~x for filesystem escapes.
+    const escaped = escapeJsonPointer(name).replace(/[^a-zA-Z0-9_.~{}-]/gu, (character) => `~x${character.codePointAt(0)?.toString(16)}~`);
+    const portable = escaped.replace(/\.+$/, (dots) => dots.replaceAll('.', '~x2e~'));
+    // Windows device names remain reserved even when followed by a file extension.
+    return /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(portable) || portable === '' ? `~x~${portable}` : portable;
+};

package/dist/helpers/for-each-path-item-operation.d.ts

@@ -1,7 +1,7 @@
 import type { HttpMethod } from '@scalar/helpers/http/http-methods';
 import { type NodeInput } from '../helpers/get-resolved-ref.js';
-import type { OperationObject } from '../schemas/v3.1/strict/operation.js';
-import type { PathItemObject } from '../schemas/v3.1/strict/path-item.js';
+import type { OperationObject } from '../schemas/v3.2/strict/operation.js';
+import type { PathItemObject } from '../schemas/v3.2/strict/path-item.js';
 /**
  * Resolves a path item (or webhook path item), merging sibling properties alongside `$ref`.
  *

package/dist/helpers/get-first-server.d.ts

@@ -1,4 +1,4 @@
-import type { ServerObject } from '../schemas/v3.1/strict/openapi-document.js';
+import type { ServerObject } from '../schemas/v3.2/strict/openapi-document.js';
 /**
  * Iterate through all available servers and pick the first one
  *

package/dist/helpers/get-resolved-ref.d.ts

@@ -14,7 +14,12 @@ export declare const mergeSiblingReferences: <Node>(node: RefNode<Node>) => Node
  * If the node contains a $ref, applies the provided transform (default: returns '$ref-value').
  * Otherwise, returns the node as-is.
  */
-export declare const getResolvedRef: <Node>(node: NodeInput<Node>, transform?: (node: RefNode<Node>) => Node) => Node;
+export declare function getResolvedRef<Node, Result>(node: NodeInput<Node>, transform: (node: RefNode<Node>) => Result): Node | Result;
+export declare function getResolvedRef<Node>(node: {
+    $ref: string;
+    '$ref-value': Node;
+}): Node;
+export declare function getResolvedRef<Node>(node: NodeInput<Node>): Node | undefined;
 /**
  * Type helper we can use if we have getResolvedRef higher in the stack
  */

package/dist/helpers/get-resolved-ref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-resolved-ref.d.ts","sourceRoot":"","sources":["../../src/helpers/get-resolved-ref.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,IAAI,CAAA;CAAE,CAAA;AACjF,MAAM,MAAM,SAAS,CAAC,IAAI,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AASlD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GAAI,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,KAAG,IAalE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,IAAI,EACjC,MAAM,SAAS,CAAC,IAAI,CAAC,EACrB,YAAW,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,IAAuB,SAO5D,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,CAAC,CAAC,SAAS,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAA"}
+{"version":3,"file":"get-resolved-ref.d.ts","sourceRoot":"","sources":["../../src/helpers/get-resolved-ref.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,IAAI,CAAA;CAAE,CAAA;AACjF,MAAM,MAAM,SAAS,CAAC,IAAI,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAOlD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GAAI,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,KAAG,IAalE,CAAA;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EACzC,IAAI,EAAE,SAAS,CAAC,IAAI,CAAC,EACrB,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,KAAK,MAAM,GACzC,IAAI,GAAG,MAAM,CAAA;AAChB,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,IAAI,CAAA;CAAE,GAAG,IAAI,CAAA;AACtF,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,SAAS,CAAA;AAW7E;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,CAAC,CAAC,SAAS,MAAM,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAA"}

package/dist/helpers/get-resolved-ref.js

@@ -1,8 +1,6 @@
 import { isObject } from '@scalar/helpers/object/is-object';
 const defaultTransform = (node) => {
-    // `$ref-value` is populated by the bundler/proxy when the document is resolved. The schemas now
-    // type it as optional so unresolved `{ $ref }` objects pass through coercion untouched, but callers
-    // of `getResolvedRef` operate on resolved documents where the value is present.
+    // Unresolved references have no value; callers must account for that state.
     return node['$ref-value'];
 };
 /**
@@ -22,14 +20,9 @@ export const mergeSiblingReferences = (node) => {
     }
     return { ...value, ...rest };
 };
-/**
- * Resolves a node that may be a $ref object to its actual value.
- * If the node contains a $ref, applies the provided transform (default: returns '$ref-value').
- * Otherwise, returns the node as-is.
- */
-export const getResolvedRef = (node, transform = defaultTransform) => {
+export function getResolvedRef(node, transform = defaultTransform) {
     if (typeof node === 'object' && node !== null && '$ref' in node) {
         return transform(node);
     }
     return node;
-};
+}

package/dist/helpers/is-non-optional-security-requirement.d.ts

@@ -1,4 +1,4 @@
-import type { SecurityRequirementObject } from '../schemas/v3.1/strict/openapi-document.js';
+import type { SecurityRequirementObject } from '../schemas/v3.2/strict/openapi-document.js';
 /** Type guard to determine if a security requirement is non-optional */
 export declare const isNonOptionalSecurityRequirement: (securityRequirement: SecurityRequirementObject | undefined) => securityRequirement is Record<string, string[]>;
 //# sourceMappingURL=is-non-optional-security-requirement.d.ts.map

package/dist/helpers/merge-object.d.ts

@@ -27,10 +27,10 @@
  * const target = { age: 30 }
  * mergeObjects(target, obj) // Safely merges without infinite recursion
  */
-export declare const mergeObjects: <R = unknown>(a: Record<string, unknown>, b: Record<string, unknown>, 
+export declare const mergeObjects: (a: Record<string, unknown>, b: Record<string, unknown>, 
 /**
  * By default we overwrite array indexes, our store is built on this assumption when coercing the document
  * Alternatively we may want to prevent this behaviour when merging with defaults and replace the whole array instead
  */
-replaceArrays?: boolean, cache?: Set<unknown>) => R;
+replaceArrays?: boolean, cache?: Set<unknown>) => Record<string, unknown>;
 //# sourceMappingURL=merge-object.d.ts.map

package/dist/helpers/merge-object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merge-object.d.ts","sourceRoot":"","sources":["../../src/helpers/merge-object.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,GAAG,OAAO,EACtC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;AAC1B;;;GAGG;AACH,uBAAqB,EACrB,QAAO,GAAG,CAAC,OAAO,CAAa,KAC9B,CA4CF,CAAA"}
+{"version":3,"file":"merge-object.d.ts","sourceRoot":"","sources":["../../src/helpers/merge-object.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,YAAY,GACvB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;AAC1B;;;GAGG;AACH,uBAAqB,EACrB,QAAO,GAAG,CAAC,OAAO,CAAa,KAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAsCxB,CAAA"}

package/dist/helpers/merge-object.js

@@ -1,3 +1,4 @@
+import { isObjectLike } from '@scalar/helpers/object/is-object';
 import { getRaw } from '@scalar/json-magic/magic-proxy';
 /**
  * Deep merges two objects, combining their properties recursively.
@@ -43,11 +44,7 @@ replaceArrays = false, cache = new Set()) => {
             const bValue = b[key];
             /** Replace whole array instead of replacing each index */
             const shouldReplaceArrays = replaceArrays && (Array.isArray(aValue) || Array.isArray(bValue));
-            if (typeof aValue === 'object' &&
-                aValue !== null &&
-                typeof bValue === 'object' &&
-                bValue !== null &&
-                !shouldReplaceArrays) {
+            if (isObjectLike(aValue) && isObjectLike(bValue) && !shouldReplaceArrays) {
                 const rawA = getRaw(aValue);
                 const rawB = getRaw(bValue);
                 // Check for circular references before recursive merge

package/dist/mutators/auth.d.ts

@@ -1,7 +1,7 @@
 import type { WorkspaceStore } from '../client.js';
 import type { AuthEvents } from '../events/definitions/auth.js';
 import type { WorkspaceDocument } from '../schemas.js';
-import type { SecuritySchemeObject } from '../schemas/v3.1/strict/security-scheme.js';
+import type { SecuritySchemeObject } from '../schemas/v3.2/strict/security-scheme.js';
 /**
  * Updates the selected security schemes for either the entire document or a specific operation.
  * - Adds newly created security schemes (if any) to the workspace document's components.

package/dist/mutators/auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/mutators/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAQ3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAGlD,OAAO,KAAK,EAAgB,oBAAoB,EAAE,MAAM,uCAAuC,CAAA;AAuC/F;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,6BAA6B,GACxC,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,4CAA4C,UAAU,CAAC,uCAAuC,CAAC,kBAgFhG,CAAA;AAwBD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,UAAU,iBAAiB,GAAG,IAAI,EAClC,mBAAmB,UAAU,CAAC,6BAA6B,CAAC,qCAwB7D,CAAA;AAuCD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,iBAAiB,UAAU,CAAC,0BAA0B,CAAC,SAgDxD,CAAA;AAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,6CAA6C,UAAU,CAAC,6BAA6B,CAAC,SAmEvF,CAAA;AAqED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,0DAA0D,UAAU,CAAC,oBAAoB,CAAC,SA2D3F,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,2BAA2B,UAAU,CAAC,oBAAoB,CAAC,SAwB5D,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,WAAW,UAAU,CAAC,6BAA6B,CAAC,SAmFrD,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,sBAGjC;IACD,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAA;IAClC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAA;CAC7B;6CAE4C,UAAU,CAAC,uCAAuC,CAAC;4CAEpD,UAAU,CAAC,sCAAsC,CAAC;oCAE1D,UAAU,CAAC,6BAA6B,CAAC;2CAElC,UAAU,CAAC,qCAAqC,CAAC;0CAElD,UAAU,CAAC,oCAAoC,CAAC;qCAErD,UAAU,CAAC,0BAA0B,CAAC;oCAEvC,UAAU,CAAC,6BAA6B,CAAC;2BAElD,UAAU,CAAC,oBAAoB,CAAC;2BAChC,UAAU,CAAC,oBAAoB,CAAC;oCACvB,UAAU,CAAC,6BAA6B,CAAC;CAG5E,CAAA"}
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/mutators/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAQ3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAGlD,OAAO,KAAK,EAAgB,oBAAoB,EAAE,MAAM,uCAAuC,CAAA;AAuC/F;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,6BAA6B,GACxC,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,4CAA4C,UAAU,CAAC,uCAAuC,CAAC,kBAgFhG,CAAA;AAwBD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,UAAU,iBAAiB,GAAG,IAAI,EAClC,mBAAmB,UAAU,CAAC,6BAA6B,CAAC,qCAwB7D,CAAA;AAuCD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,qBAAqB,GAChC,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,iBAAiB,UAAU,CAAC,0BAA0B,CAAC,SAgDxD,CAAA;AAaD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,6CAA6C,UAAU,CAAC,6BAA6B,CAAC,SA0EvF,CAAA;AAqED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,0DAA0D,UAAU,CAAC,oBAAoB,CAAC,SA2D3F,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,2BAA2B,UAAU,CAAC,oBAAoB,CAAC,SAwB5D,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,GAAG,IAAI,EAC5B,UAAU,iBAAiB,GAAG,IAAI,EAClC,WAAW,UAAU,CAAC,6BAA6B,CAAC,SAoFrD,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,sBAGjC;IACD,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAA;IAClC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAA;CAC7B;6CAE4C,UAAU,CAAC,uCAAuC,CAAC;4CAEpD,UAAU,CAAC,sCAAsC,CAAC;oCAE1D,UAAU,CAAC,6BAA6B,CAAC;2CAElC,UAAU,CAAC,qCAAqC,CAAC;0CAElD,UAAU,CAAC,oCAAoC,CAAC;qCAErD,UAAU,CAAC,0BAA0B,CAAC;oCAEvC,UAAU,CAAC,6BAA6B,CAAC;2BAElD,UAAU,CAAC,oBAAoB,CAAC;2BAChC,UAAU,CAAC,oBAAoB,CAAC;oCACvB,UAAU,CAAC,6BAA6B,CAAC;CAG5E,CAAA"}

package/dist/mutators/auth.js

@@ -25,11 +25,11 @@ const getAuthDocumentName = (document) => {
  */
 const getDocumentSecuritySchemes = (document) => {
     if (isOpenApiDocument(document)) {
-        return (document.components?.securitySchemes ?? {});
+        return document.components?.securitySchemes ?? {};
     }
     if (isAsyncApiDocument(document)) {
         const components = document.components ? getResolvedRef(document.components) : undefined;
-        return (components?.securitySchemes ?? {});
+        return components?.securitySchemes ?? {};
     }
     return {};
 };
@@ -102,7 +102,7 @@ export const updateSelectedSecuritySchemes = async (store, document, { selectedR
                 [uniqueSchemeName]: [],
             };
         }));
-        createdSchemes.push(...createdSecurityRequirements.filter(Boolean));
+        createdSchemes.push(...createdSecurityRequirements.filter((requirement) => requirement !== undefined));
     }
     const target = getTarget();
     const newSelectedSecuritySchemes = [...selectedRequirements, ...createdSchemes];
@@ -193,7 +193,10 @@ const updateSecuritySchemeSecrets = (store, document, { payload, name, overwrite
         return;
     }
     const auth = store?.auth.getAuthSecrets(documentName, name);
-    const result = mergeObjects(unpackProxyObject(auth, { depth: 1 }) ?? {}, payload);
+    const result = auth
+        ? unpackProxyObject(auth, { depth: 1 })
+        : { ...payload };
+    mergeObjects(result, payload);
     store?.auth.setAuthSecrets(documentName, name, result);
 };
 const clearSecuritySchemeSecrets = (store, document, { name }) => {
@@ -349,10 +352,14 @@ export const updateSelectedScopes = (store, document, { id, name, scopes, scope,
     if (nextScopes === undefined) {
         return;
     }
-    nextScheme[name] = nextScopes;
+    // Replace the matched requirement with a fresh object instead of mutating it in place, so its
+    // identity changes on every scope update. The reference-side Authentication panel passes this
+    // object down as a prop and Vue diffs props by identity — an in-place mutation keeps the same
+    // reference and leaves the scope counter and checkboxes frozen after the first change. See #9589.
+    const updatedSelectedSchemes = nextSelectedSchemes.map((candidate) => candidate === nextScheme ? { ...nextScheme, [name]: nextScopes } : candidate);
     store?.auth.setAuthSelectedSchemas(meta.type === 'document'
         ? { type: 'document', documentName }
-        : { type: 'operation', documentName, path: meta.path, method: meta.method }, { selectedIndex: target.selectedIndex, selectedSchemes: nextSelectedSchemes });
+        : { type: 'operation', documentName, path: meta.path, method: meta.method }, { selectedIndex: target.selectedIndex, selectedSchemes: updatedSelectedSchemes });
 };
 /**
  * Resolves the OAuth flow on a security scheme by name + flow type.
@@ -555,6 +562,8 @@ export const deleteSecurityScheme = (store, document, { names }) => {
         forEachPathItemOperation(pathItemRef, (method, operationRef) => {
             // Get mutable reference for the operation (could resolve $ref proxies)
             const resolvedOperation = getResolvedRef(operationRef);
+            if (!resolvedOperation)
+                return;
             // Remove from operation-level security array
             if ('security' in resolvedOperation && resolvedOperation['security']) {
                 resolvedOperation['security'] = filterSecuritySchemes(resolvedOperation['security']);

package/dist/mutators/index.d.ts

@@ -66,7 +66,7 @@ export declare function generateClientMutators(store: WorkspaceStore | null): {
         auth: {
             updateSelectedSecuritySchemes: (payload: import("../events/definitions/auth.js").AuthEvents["auth:update:selected-security-schemes"]) => Promise<void>;
             clearSelectedSecuritySchemes: (payload: import("../events/definitions/auth.js").AuthEvents["auth:clear:selected-security-schemes"]) => void;
-            updateSecurityScheme: (payload: import("../events/definitions/auth.js").AuthEvents["auth:update:security-scheme"]) => import("../schemas/v3.1/strict/security-scheme.js").SecuritySchemeObject | undefined;
+            updateSecurityScheme: (payload: import("../events/definitions/auth.js").AuthEvents["auth:update:security-scheme"]) => import("../schemas/v3.2/strict/security-scheme.js").SecuritySchemeObject | undefined;
             updateSecuritySchemeSecrets: (payload: import("../events/definitions/auth.js").AuthEvents["auth:update:security-scheme-secrets"]) => void;
             clearSecuritySchemeSecrets: (payload: import("../events/definitions/auth.js").AuthEvents["auth:clear:security-scheme-secrets"]) => void;
             updateSelectedAuthTab: (payload: import("../events/definitions/auth.js").AuthEvents["auth:update:active-index"]) => void;
@@ -113,12 +113,12 @@ export declare function generateClientMutators(store: WorkspaceStore | null): {
             reloadOperationHistory: (payload: import("../events/index.js").OperationEvents["operation:reload:history"]) => void;
         };
         server: {
-            initializeServers: (payload: import("../events/definitions/server.js").ServerEvents["server:initialize:servers"]) => import("../schemas/v3.1/strict/server.js").ServerObject[] | undefined;
-            addServer: (payload: import("../events/definitions/server.js").ServerEvents["server:add:server"]) => import("../schemas/v3.1/strict/server.js").ServerObject | undefined;
-            updateServer: (payload: import("../events/definitions/server.js").ServerEvents["server:update:server"]) => import("../schemas/v3.1/strict/server.js").ServerObject | undefined;
+            initializeServers: (payload: import("../events/definitions/server.js").ServerEvents["server:initialize:servers"]) => import("../schemas/v3.2/strict/server.js").ServerObject[] | undefined;
+            addServer: (payload: import("../events/definitions/server.js").ServerEvents["server:add:server"]) => import("../schemas/v3.2/strict/server.js").ServerObject | undefined;
+            updateServer: (payload: import("../events/definitions/server.js").ServerEvents["server:update:server"]) => import("../schemas/v3.2/strict/server.js").ServerObject | undefined;
             deleteServer: (payload: import("../events/definitions/server.js").ServerEvents["server:delete:server"]) => void;
             clearServers: (payload: import("../events/definitions/server.js").ServerEvents["server:clear:servers"]) => void;
-            updateServerVariables: (payload: import("../events/definitions/server.js").ServerEvents["server:update:variables"]) => import("../schemas/v3.1/strict/server-variable.js").ServerVariableObject | undefined;
+            updateServerVariables: (payload: import("../events/definitions/server.js").ServerEvents["server:update:variables"]) => import("../schemas/v3.2/strict/server-variable.js").ServerVariableObject | undefined;
             updateSelectedServer: (payload: import("../events/definitions/server.js").ServerEvents["server:update:selected"]) => string | undefined;
             updateSelectedAsyncApiServer: (payload: import("../events/definitions/server.js").ServerEvents["asyncapi-server:update:selected"]) => string | undefined;
             updateAsyncApiServerVariables: (payload: import("../events/definitions/server.js").ServerEvents["asyncapi-server:update:variables"]) => import("@scalar/types/asyncapi/3.1").AsyncApiServerVariableObject | undefined;
@@ -157,7 +157,7 @@ export declare function generateClientMutators(store: WorkspaceStore | null): {
         auth: {
             updateSelectedSecuritySchemes: (payload: import("../events/definitions/auth.js").AuthEvents["auth:update:selected-security-schemes"]) => Promise<void>;
             clearSelectedSecuritySchemes: (payload: import("../events/definitions/auth.js").AuthEvents["auth:clear:selected-security-schemes"]) => void;
-            updateSecurityScheme: (payload: import("../events/definitions/auth.js").AuthEvents["auth:update:security-scheme"]) => import("../schemas/v3.1/strict/security-scheme.js").SecuritySchemeObject | undefined;
+            updateSecurityScheme: (payload: import("../events/definitions/auth.js").AuthEvents["auth:update:security-scheme"]) => import("../schemas/v3.2/strict/security-scheme.js").SecuritySchemeObject | undefined;
             updateSecuritySchemeSecrets: (payload: import("../events/definitions/auth.js").AuthEvents["auth:update:security-scheme-secrets"]) => void;
             clearSecuritySchemeSecrets: (payload: import("../events/definitions/auth.js").AuthEvents["auth:clear:security-scheme-secrets"]) => void;
             updateSelectedAuthTab: (payload: import("../events/definitions/auth.js").AuthEvents["auth:update:active-index"]) => void;
@@ -204,12 +204,12 @@ export declare function generateClientMutators(store: WorkspaceStore | null): {
             reloadOperationHistory: (payload: import("../events/index.js").OperationEvents["operation:reload:history"]) => void;
         };
         server: {
-            initializeServers: (payload: import("../events/definitions/server.js").ServerEvents["server:initialize:servers"]) => import("../schemas/v3.1/strict/server.js").ServerObject[] | undefined;
-            addServer: (payload: import("../events/definitions/server.js").ServerEvents["server:add:server"]) => import("../schemas/v3.1/strict/server.js").ServerObject | undefined;
-            updateServer: (payload: import("../events/definitions/server.js").ServerEvents["server:update:server"]) => import("../schemas/v3.1/strict/server.js").ServerObject | undefined;
+            initializeServers: (payload: import("../events/definitions/server.js").ServerEvents["server:initialize:servers"]) => import("../schemas/v3.2/strict/server.js").ServerObject[] | undefined;
+            addServer: (payload: import("../events/definitions/server.js").ServerEvents["server:add:server"]) => import("../schemas/v3.2/strict/server.js").ServerObject | undefined;
+            updateServer: (payload: import("../events/definitions/server.js").ServerEvents["server:update:server"]) => import("../schemas/v3.2/strict/server.js").ServerObject | undefined;
             deleteServer: (payload: import("../events/definitions/server.js").ServerEvents["server:delete:server"]) => void;
             clearServers: (payload: import("../events/definitions/server.js").ServerEvents["server:clear:servers"]) => void;
-            updateServerVariables: (payload: import("../events/definitions/server.js").ServerEvents["server:update:variables"]) => import("../schemas/v3.1/strict/server-variable.js").ServerVariableObject | undefined;
+            updateServerVariables: (payload: import("../events/definitions/server.js").ServerEvents["server:update:variables"]) => import("../schemas/v3.2/strict/server-variable.js").ServerVariableObject | undefined;
             updateSelectedServer: (payload: import("../events/definitions/server.js").ServerEvents["server:update:selected"]) => string | undefined;
             updateSelectedAsyncApiServer: (payload: import("../events/definitions/server.js").ServerEvents["asyncapi-server:update:selected"]) => string | undefined;
             updateAsyncApiServerVariables: (payload: import("../events/definitions/server.js").ServerEvents["asyncapi-server:update:variables"]) => import("@scalar/types/asyncapi/3.1").AsyncApiServerVariableObject | undefined;

package/dist/mutators/operation/body.js

@@ -17,7 +17,7 @@ const findOrCreateRequestBodyExample = (document, contentType, meta) => {
         operation.requestBody = {
             content: {},
         };
-        requestBody = getResolvedRef(operation.requestBody);
+        requestBody = operation.requestBody;
     }
     // Ensure that the example exists
     requestBody.content[contentType] ||= {};
@@ -53,7 +53,7 @@ export const updateOperationRequestBodyContentType = (document, { meta, payload
         operation.requestBody = {
             content: {},
         };
-        requestBody = getResolvedRef(operation.requestBody);
+        requestBody = operation.requestBody;
     }
     if (!requestBody['x-scalar-selected-content-type']) {
         requestBody['x-scalar-selected-content-type'] = {};

package/dist/mutators/operation/helpers/fetch-request-to-har.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetch-request-to-har.d.ts","sourceRoot":"","sources":["../../../../src/mutators/operation/helpers/fetch-request-to-har.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAA;AAE7E,KAAK,sBAAsB,GAAG;IAC5B,2EAA2E;IAC3E,cAAc,EAAE,cAAc,CAAA;IAC9B;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,iBAAiB,GAAU,8DAKrC,sBAAsB,KAAG,OAAO,CAAC,UAAU,CAyD7C,CAAA"}
+{"version":3,"file":"fetch-request-to-har.d.ts","sourceRoot":"","sources":["../../../../src/mutators/operation/helpers/fetch-request-to-har.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAA;AAE7E,KAAK,sBAAsB,GAAG;IAC5B,2EAA2E;IAC3E,cAAc,EAAE,cAAc,CAAA;IAC9B;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,iBAAiB,GAAU,8DAKrC,sBAAsB,KAAG,OAAO,CAAC,UAAU,CA6D7C,CAAA"}