@eventmodelers/node-kit 0.0.2

package/templates/realtime-agent/node_modules/@supabase/storage-js/src/packages/VectorBucketApi.ts

@@ -0,0 +1,73 @@
+import { DEFAULT_HEADERS } from '../lib/constants'
+import { StorageError } from '../lib/common/errors'
+import { Fetch, vectorsApi } from '../lib/common/fetch'
+import BaseApiClient from '../lib/common/BaseApiClient'
+import {
+  ApiResponse,
+  VectorBucket,
+  ListVectorBucketsOptions,
+  ListVectorBucketsResponse,
+} from '../lib/types'
+
+/**
+ * @hidden
+ * Base implementation for vector bucket operations.
+ * Use {@link StorageVectorsClient} via `supabase.storage.vectors` instead.
+ */
+export default class VectorBucketApi extends BaseApiClient<StorageError> {
+  /** Creates a new VectorBucketApi instance */
+  constructor(url: string, headers: { [key: string]: string } = {}, fetch?: Fetch) {
+    const finalUrl = url.replace(/\/$/, '')
+    const finalHeaders = { ...DEFAULT_HEADERS, 'Content-Type': 'application/json', ...headers }
+    super(finalUrl, finalHeaders, fetch, 'vectors')
+  }
+
+  /** Creates a new vector bucket */
+  async createBucket(vectorBucketName: string): Promise<ApiResponse<undefined>> {
+    return this.handleOperation(async () => {
+      const data = await vectorsApi.post(
+        this.fetch,
+        `${this.url}/CreateVectorBucket`,
+        { vectorBucketName },
+        { headers: this.headers }
+      )
+      return data || {}
+    })
+  }
+
+  /** Retrieves metadata for a specific vector bucket */
+  async getBucket(vectorBucketName: string): Promise<ApiResponse<{ vectorBucket: VectorBucket }>> {
+    return this.handleOperation(async () => {
+      return await vectorsApi.post(
+        this.fetch,
+        `${this.url}/GetVectorBucket`,
+        { vectorBucketName },
+        { headers: this.headers }
+      )
+    })
+  }
+
+  /** Lists vector buckets with optional filtering and pagination */
+  async listBuckets(
+    options: ListVectorBucketsOptions = {}
+  ): Promise<ApiResponse<ListVectorBucketsResponse>> {
+    return this.handleOperation(async () => {
+      return await vectorsApi.post(this.fetch, `${this.url}/ListVectorBuckets`, options, {
+        headers: this.headers,
+      })
+    })
+  }
+
+  /** Deletes a vector bucket (must be empty first) */
+  async deleteBucket(vectorBucketName: string): Promise<ApiResponse<undefined>> {
+    return this.handleOperation(async () => {
+      const data = await vectorsApi.post(
+        this.fetch,
+        `${this.url}/DeleteVectorBucket`,
+        { vectorBucketName },
+        { headers: this.headers }
+      )
+      return data || {}
+    })
+  }
+}

package/templates/realtime-agent/node_modules/@supabase/storage-js/src/packages/VectorDataApi.ts

@@ -0,0 +1,98 @@
+import { DEFAULT_HEADERS } from '../lib/constants'
+import { StorageError } from '../lib/common/errors'
+import { Fetch, vectorsApi } from '../lib/common/fetch'
+import BaseApiClient from '../lib/common/BaseApiClient'
+import {
+  ApiResponse,
+  PutVectorsOptions,
+  GetVectorsOptions,
+  GetVectorsResponse,
+  DeleteVectorsOptions,
+  ListVectorsOptions,
+  ListVectorsResponse,
+  QueryVectorsOptions,
+  QueryVectorsResponse,
+} from '../lib/types'
+
+/**
+ * @hidden
+ * Base implementation for vector data operations.
+ * Use {@link VectorIndexScope} via `supabase.storage.vectors.from('bucket').index('idx')` instead.
+ */
+export default class VectorDataApi extends BaseApiClient<StorageError> {
+  /** Creates a new VectorDataApi instance */
+  constructor(url: string, headers: { [key: string]: string } = {}, fetch?: Fetch) {
+    const finalUrl = url.replace(/\/$/, '')
+    const finalHeaders = { ...DEFAULT_HEADERS, 'Content-Type': 'application/json', ...headers }
+    super(finalUrl, finalHeaders, fetch, 'vectors')
+  }
+
+  /** Inserts or updates vectors in batch (1-500 per request) */
+  async putVectors(options: PutVectorsOptions): Promise<ApiResponse<undefined>> {
+    // Validate batch size
+    if (options.vectors.length < 1 || options.vectors.length > 500) {
+      throw new Error('Vector batch size must be between 1 and 500 items')
+    }
+
+    return this.handleOperation(async () => {
+      const data = await vectorsApi.post(this.fetch, `${this.url}/PutVectors`, options, {
+        headers: this.headers,
+      })
+      return data || {}
+    })
+  }
+
+  /** Retrieves vectors by their keys in batch */
+  async getVectors(options: GetVectorsOptions): Promise<ApiResponse<GetVectorsResponse>> {
+    return this.handleOperation(async () => {
+      return await vectorsApi.post(this.fetch, `${this.url}/GetVectors`, options, {
+        headers: this.headers,
+      })
+    })
+  }
+
+  /** Lists vectors in an index with pagination */
+  async listVectors(options: ListVectorsOptions): Promise<ApiResponse<ListVectorsResponse>> {
+    // Validate segment configuration
+    if (options.segmentCount !== undefined) {
+      if (options.segmentCount < 1 || options.segmentCount > 16) {
+        throw new Error('segmentCount must be between 1 and 16')
+      }
+      if (options.segmentIndex !== undefined) {
+        if (options.segmentIndex < 0 || options.segmentIndex >= options.segmentCount) {
+          throw new Error(`segmentIndex must be between 0 and ${options.segmentCount - 1}`)
+        }
+      }
+    }
+
+    return this.handleOperation(async () => {
+      return await vectorsApi.post(this.fetch, `${this.url}/ListVectors`, options, {
+        headers: this.headers,
+      })
+    })
+  }
+
+  /** Queries for similar vectors using approximate nearest neighbor search */
+  async queryVectors(options: QueryVectorsOptions): Promise<ApiResponse<QueryVectorsResponse>> {
+    return this.handleOperation(async () => {
+      return await vectorsApi.post(this.fetch, `${this.url}/QueryVectors`, options, {
+        headers: this.headers,
+      })
+    })
+  }
+
+  /** Deletes vectors by their keys in batch (1-500 per request) */
+  async deleteVectors(options: DeleteVectorsOptions): Promise<ApiResponse<undefined>> {
+    // Validate batch size
+    if (options.keys.length < 1 || options.keys.length > 500) {
+      throw new Error('Keys batch size must be between 1 and 500 items')
+    }
+
+    return this.handleOperation(async () => {
+      const data = await vectorsApi.post(this.fetch, `${this.url}/DeleteVectors`, options, {
+        headers: this.headers,
+      })
+      return data || {}
+    })
+  }
+}

package/templates/realtime-agent/node_modules/@supabase/storage-js/src/packages/VectorIndexApi.ts

@@ -0,0 +1,90 @@
+import { DEFAULT_HEADERS } from '../lib/constants'
+import { StorageError } from '../lib/common/errors'
+import { Fetch, vectorsApi } from '../lib/common/fetch'
+import BaseApiClient from '../lib/common/BaseApiClient'
+import {
+  ApiResponse,
+  VectorIndex,
+  ListIndexesOptions,
+  ListIndexesResponse,
+  VectorDataType,
+  DistanceMetric,
+  MetadataConfiguration,
+} from '../lib/types'
+
+/**
+ * @alpha
+ *
+ * Options for creating a vector index
+ *
+ * **Public alpha:** This API is part of a public alpha release and may not be available to your account type.
+ */
+export interface CreateIndexOptions {
+  vectorBucketName: string
+  indexName: string
+  dataType: VectorDataType
+  dimension: number
+  distanceMetric: DistanceMetric
+  metadataConfiguration?: MetadataConfiguration
+}
+
+/**
+ * @hidden
+ * Base implementation for vector index operations.
+ * Use {@link VectorBucketScope} via `supabase.storage.vectors.from('bucket')` instead.
+ */
+export default class VectorIndexApi extends BaseApiClient<StorageError> {
+  /** Creates a new VectorIndexApi instance */
+  constructor(url: string, headers: { [key: string]: string } = {}, fetch?: Fetch) {
+    const finalUrl = url.replace(/\/$/, '')
+    const finalHeaders = { ...DEFAULT_HEADERS, 'Content-Type': 'application/json', ...headers }
+    super(finalUrl, finalHeaders, fetch, 'vectors')
+  }
+
+  /** Creates a new vector index within a bucket */
+  async createIndex(options: CreateIndexOptions): Promise<ApiResponse<undefined>> {
+    return this.handleOperation(async () => {
+      const data = await vectorsApi.post(this.fetch, `${this.url}/CreateIndex`, options, {
+        headers: this.headers,
+      })
+      return data || {}
+    })
+  }
+
+  /** Retrieves metadata for a specific vector index */
+  async getIndex(
+    vectorBucketName: string,
+    indexName: string
+  ): Promise<ApiResponse<{ index: VectorIndex }>> {
+    return this.handleOperation(async () => {
+      return await vectorsApi.post(
+        this.fetch,
+        `${this.url}/GetIndex`,
+        { vectorBucketName, indexName },
+        { headers: this.headers }
+      )
+    })
+  }
+
+  /** Lists vector indexes within a bucket with optional filtering and pagination */
+  async listIndexes(options: ListIndexesOptions): Promise<ApiResponse<ListIndexesResponse>> {
+    return this.handleOperation(async () => {
+      return await vectorsApi.post(this.fetch, `${this.url}/ListIndexes`, options, {
+        headers: this.headers,
+      })
+    })
+  }
+
+  /** Deletes a vector index and all its data */
+  async deleteIndex(vectorBucketName: string, indexName: string): Promise<ApiResponse<undefined>> {
+    return this.handleOperation(async () => {
+      const data = await vectorsApi.post(
+        this.fetch,
+        `${this.url}/DeleteIndex`,
+        { vectorBucketName, indexName },
+        { headers: this.headers }
+      )
+      return data || {}
+    })
+  }
+}

package/templates/realtime-agent/node_modules/@supabase/supabase-js/README.md

@@ -0,0 +1,238 @@
+<br />
+<p align="center">
+  <a href="https://supabase.io">
+        <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/supabase/supabase/master/packages/common/assets/images/supabase-logo-wordmark--dark.svg">
+      <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/supabase/supabase/master/packages/common/assets/images/supabase-logo-wordmark--light.svg">
+      <img alt="Supabase Logo" width="300" src="https://raw.githubusercontent.com/supabase/supabase/master/packages/common/assets/images/logo-preview.jpg">
+    </picture>
+  </a>
+
+  <h1 align="center">Supabase JS SDK</h1>
+
+  <h3 align="center">Isomorphic JavaScript SDK for Supabase - combining Auth, Database, Storage, Functions, and Realtime.</h3>
+
+  <p align="center">
+    <a href="https://supabase.com/docs/guides/getting-started">Guides</a>
+    ·
+    <a href="https://supabase.com/docs/reference/javascript/start">Reference Docs</a>
+    ·
+    <a href="https://supabase.github.io/supabase-js/supabase-js/v2/spec.json">TypeDoc</a>
+  </p>
+</p>
+
+<div align="center">
+
+[![Build](https://github.com/supabase/supabase-js/workflows/CI/badge.svg)](https://github.com/supabase/supabase-js/actions?query=branch%3Amaster)
+[![Package](https://img.shields.io/npm/v/@supabase/supabase-js)](https://www.npmjs.com/package/@supabase/supabase-js)
+[![License: MIT](https://img.shields.io/npm/l/@supabase/supabase-js)](#license)
+[![pkg.pr.new](https://pkg.pr.new/badge/supabase/supabase-js)](https://pkg.pr.new/~/supabase/supabase-js)
+
+</div>
+
+## Usage
+
+First of all, you need to install the library:
+
+```sh
+npm install @supabase/supabase-js
+```
+
+Then you're able to import the library and establish the connection with the database:
+
+```js
+import { createClient } from '@supabase/supabase-js'
+
+// Create a single supabase client for interacting with your database
+const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+```
+
+### UMD
+
+You can use plain `<script>`s to import supabase-js from CDNs, like:
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/@supabase/supabase-js@2"></script>
+```
+
+or even:
+
+```html
+<script src="https://unpkg.com/@supabase/supabase-js@2"></script>
+```
+
+Then you can use it from a global `supabase` variable:
+
+```html
+<script>
+  const { createClient } = supabase
+  const _supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+
+  console.log('Supabase Instance: ', _supabase)
+  // ...
+</script>
+```
+
+### ESM
+
+You can use `<script type="module">` to import supabase-js from CDNs, like:
+
+```html
+<script type="module">
+  import { createClient } from 'https://cdn.jsdelivr.net/npm/@supabase/supabase-js/+esm'
+  const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+
+  console.log('Supabase Instance: ', supabase)
+  // ...
+</script>
+```
+
+### Deno
+
+You can use supabase-js in the Deno runtime via [JSR](https://jsr.io/@supabase/supabase-js):
+
+```js
+import { createClient } from 'jsr:@supabase/supabase-js@2'
+```
+
+### Custom `fetch` implementation
+
+`supabase-js` uses the [`cross-fetch`](https://www.npmjs.com/package/cross-fetch) library to make HTTP requests, but an alternative `fetch` implementation can be provided as an option. This is most useful in environments where `cross-fetch` is not compatible, for instance Cloudflare Workers:
+
+```js
+import { createClient } from '@supabase/supabase-js'
+
+// Provide a custom `fetch` implementation as an option
+const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key', {
+  global: {
+    fetch: (...args) => fetch(...args),
+  },
+})
+```
+
+## Support Policy
+
+This section outlines the scope of support for various runtime environments in Supabase JavaScript client.
+
+### Node.js
+
+We only support Node.js versions that are in **Active LTS** or **Maintenance** status as defined by the [official Node.js release schedule](https://nodejs.org/en/about/previous-releases#release-schedule). This means we support versions that are currently receiving long-term support and critical bug fixes.
+
+When a Node.js version reaches end-of-life and is no longer in Active LTS or Maintenance status, Supabase will drop it in a **minor release**, and **this won't be considered a breaking change**.
+
+> ⚠️ **Node.js 18 Deprecation Notice**
+>
+> Node.js 18 reached end-of-life on April 30, 2025. As announced in [our deprecation notice](https://github.com/orgs/supabase/discussions/37217), support for Node.js 18 was dropped in version `2.79.0`.
+>
+> If you must use Node.js 18, please use version `2.78.0`, which is the last version that supported Node.js 18.
+
+### Deno
+
+We support Deno versions that are currently receiving active development and security updates. We follow the [official Deno release schedule](https://docs.deno.com/runtime/fundamentals/stability_and_releases/) and only support versions from the `stable` and `lts` release channels.
+
+When a Deno version reaches end-of-life and is no longer receiving security updates, Supabase will drop it in a **minor release**, and **this won't be considered a breaking change**.
+
+### Browsers
+
+All modern browsers are supported. We support browsers that provide native `fetch` API. For Realtime features, browsers must also support native `WebSocket` API.
+
+### Bun
+
+We support Bun runtime environments. Bun provides native fetch support and is compatible with Node.js APIs. Since Bun does not follow a structured release schedule like Node.js or Deno, we support current stable versions of Bun and may drop support for older versions in minor releases without considering it a breaking change.
+
+### React Native
+
+We support React Native environments with fetch polyfills provided by the framework. Since React Native does not follow a structured release schedule, we support current stable versions and may drop support for older versions in minor releases without considering it a breaking change.
+
+### Cloudflare Workers
+
+We support Cloudflare Workers runtime environments. Cloudflare Workers provides native fetch support. Since Cloudflare Workers does not follow a structured release schedule, we support current stable versions and may drop support for older versions in minor releases without considering it a breaking change.
+
+### Important Notes
+
+- **Experimental features**: Features marked as experimental may be removed or changed without notice
+
+## Known Build Warnings
+
+### `UNUSED_EXTERNAL_IMPORT` in Vite / Rollup / Nuxt
+
+When bundling your app, you may see warnings like:
+
+```
+"PostgrestError" is imported from external module "@supabase/postgrest-js" but never used in "...supabase-js/dist/index.mjs".
+"FunctionRegion", "FunctionsError", "FunctionsFetchError", "FunctionsHttpError" and "FunctionsRelayError" are imported from external module "@supabase/functions-js" but never used in "...".
+```
+
+**This is a false positive — your bundle is fine.** Here is why it happens:
+
+`@supabase/supabase-js` re-exports `PostgrestError`, `FunctionsError`, and related symbols so you can import them directly from `@supabase/supabase-js`. However, our build tool merges all imports from the same package into a single import statement in the built output:
+
+```js
+// dist/index.mjs (simplified)
+import { PostgrestClient, PostgrestError } from '@supabase/postgrest-js'
+//       ^ used internally    ^ re-exported for you
+```
+
+Your bundler checks which names from that import are used _in the code body_, and flags `PostgrestError` as unused because it only appears in an `export` statement — not called or assigned. The export itself is the usage, but downstream bundlers don't track this correctly. This is a known Rollup/Vite limitation with re-exported external imports.
+
+**Nothing is broken.** Tree-shaking and bundle size are unaffected.
+
+To suppress the warning:
+
+**Vite / Rollup (`vite.config.js` or `rollup.config.js`):**
+
+```js
+export default {
+  build: {
+    rollupOptions: {
+      onwarn(warning, warn) {
+        if (warning.code === 'UNUSED_EXTERNAL_IMPORT' && warning.exporter?.includes('@supabase/'))
+          return
+        warn(warning)
+      },
+    },
+  },
+}
+```
+
+**Nuxt (`nuxt.config.ts`):**
+
+```ts
+export default defineNuxtConfig({
+  vite: {
+    build: {
+      rollupOptions: {
+        onwarn(warning, warn) {
+          if (warning.code === 'UNUSED_EXTERNAL_IMPORT' && warning.exporter?.includes('@supabase/'))
+            return
+          warn(warning)
+        },
+      },
+    },
+  },
+})
+```
+
+## Contributing
+
+We welcome contributions! Please see our [Contributing Guide](../../../CONTRIBUTING.md) for details on how to get started.
+
+For major changes or if you're unsure about something, please open an issue first to discuss your proposed changes.
+
+### Building
+
+```bash
+# From the monorepo root
+npx nx build supabase-js
+
+# Or with watch mode for development
+npx nx build supabase-js --watch
+```
+
+### Testing
+
+There's a complete guide on how to set up your environment for running locally the `supabase-js` integration tests. Please refer to [TESTING.md](./TESTING.md).
+
+## Badges
+
+[![Coverage Status](https://coveralls.io/repos/github/supabase/supabase-js/badge.svg?branch=master)](https://coveralls.io/github/supabase/supabase-js?branch=master)

package/templates/realtime-agent/node_modules/@supabase/supabase-js/dist/cors.cjs

@@ -0,0 +1,89 @@
+
+//#region src/cors.ts
+/**
+* Canonical CORS configuration for Supabase Edge Functions
+*
+* This module exports CORS headers that stay synchronized with the Supabase SDK.
+* When new headers are added to the SDK, they are automatically included here,
+* preventing CORS errors in Edge Functions.
+*
+* @example Basic usage
+* ```typescript
+* import { corsHeaders } from '@supabase/supabase-js/cors'
+*
+* Deno.serve(async (req) => {
+*   if (req.method === 'OPTIONS') {
+*     return new Response('ok', { headers: corsHeaders })
+*   }
+*
+*   return new Response(
+*     JSON.stringify({ data: 'Hello' }),
+*     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
+*   )
+* })
+* ```
+*
+* @module cors
+*/
+/**
+* All custom headers sent by the Supabase SDK.
+* These headers need to be included in CORS configuration to prevent preflight failures.
+*
+* Headers:
+* - authorization: Bearer token for authentication
+* - x-client-info: Library version information
+* - apikey: Project API key
+* - content-type: Standard HTTP content type
+* - x-retry-count: Retry attempt number sent by postgrest-js on retried requests
+*/
+const SUPABASE_HEADERS = [
+	"authorization",
+	"x-client-info",
+	"apikey",
+	"content-type",
+	"x-retry-count"
+].join(", ");
+/**
+* All HTTP methods used by the Supabase SDK
+*/
+const SUPABASE_METHODS = [
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"OPTIONS"
+].join(", ");
+/**
+* Default CORS headers for Supabase Edge Functions.
+*
+* Includes all headers sent by Supabase client libraries and allows all standard HTTP methods.
+* Use this for simple CORS configurations with wildcard origin.
+*
+* @example Basic usage
+* ```typescript
+* import { corsHeaders } from '@supabase/supabase-js/cors'
+*
+* Deno.serve(async (req) => {
+*   if (req.method === 'OPTIONS') {
+*     return new Response('ok', { headers: corsHeaders })
+*   }
+*
+*   return new Response(
+*     JSON.stringify({ data: 'Hello' }),
+*     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
+*   )
+* })
+* ```
+*
+* @category Edge Functions
+*/
+const corsHeaders = {
+	"Access-Control-Allow-Origin": "*",
+	"Access-Control-Allow-Headers": SUPABASE_HEADERS,
+	"Access-Control-Allow-Methods": SUPABASE_METHODS
+};
+
+//#endregion
+exports.corsHeaders = corsHeaders;
+//# sourceMappingURL=cors.cjs.map

package/templates/realtime-agent/node_modules/@supabase/supabase-js/dist/cors.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cors.cjs","names":["corsHeaders: CorsHeaders"],"sources":["../src/cors.ts"],"sourcesContent":["/**\n * Canonical CORS configuration for Supabase Edge Functions\n *\n * This module exports CORS headers that stay synchronized with the Supabase SDK.\n * When new headers are added to the SDK, they are automatically included here,\n * preventing CORS errors in Edge Functions.\n *\n * @example Basic usage\n * ```typescript\n * import { corsHeaders } from '@supabase/supabase-js/cors'\n *\n * Deno.serve(async (req) => {\n *   if (req.method === 'OPTIONS') {\n *     return new Response('ok', { headers: corsHeaders })\n *   }\n *\n *   return new Response(\n *     JSON.stringify({ data: 'Hello' }),\n *     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }\n *   )\n * })\n * ```\n *\n * @module cors\n */\n\n/**\n * All custom headers sent by the Supabase SDK.\n * These headers need to be included in CORS configuration to prevent preflight failures.\n *\n * Headers:\n * - authorization: Bearer token for authentication\n * - x-client-info: Library version information\n * - apikey: Project API key\n * - content-type: Standard HTTP content type\n * - x-retry-count: Retry attempt number sent by postgrest-js on retried requests\n */\nconst SUPABASE_HEADERS = [\n  'authorization',\n  'x-client-info',\n  'apikey',\n  'content-type',\n  'x-retry-count',\n].join(', ')\n\n/**\n * All HTTP methods used by the Supabase SDK\n */\nconst SUPABASE_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'].join(', ')\n\n/**\n * Type representing CORS headers as a record of header names to values\n */\nexport type CorsHeaders = Record<string, string>\n\n/**\n * Default CORS headers for Supabase Edge Functions.\n *\n * Includes all headers sent by Supabase client libraries and allows all standard HTTP methods.\n * Use this for simple CORS configurations with wildcard origin.\n *\n * @example Basic usage\n * ```typescript\n * import { corsHeaders } from '@supabase/supabase-js/cors'\n *\n * Deno.serve(async (req) => {\n *   if (req.method === 'OPTIONS') {\n *     return new Response('ok', { headers: corsHeaders })\n *   }\n *\n *   return new Response(\n *     JSON.stringify({ data: 'Hello' }),\n *     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }\n *   )\n * })\n * ```\n *\n * @category Edge Functions\n */\nexport const corsHeaders: CorsHeaders = {\n  'Access-Control-Allow-Origin': '*',\n  'Access-Control-Allow-Headers': SUPABASE_HEADERS,\n  'Access-Control-Allow-Methods': SUPABASE_METHODS,\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAM,mBAAmB;CACvB;CACA;CACA;CACA;CACA;CACD,CAAC,KAAK,KAAK;;;;AAKZ,MAAM,mBAAmB;CAAC;CAAO;CAAQ;CAAO;CAAS;CAAU;CAAU,CAAC,KAAK,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;AA+BxF,MAAaA,cAA2B;CACtC,+BAA+B;CAC/B,gCAAgC;CAChC,gCAAgC;CACjC"}

package/templates/realtime-agent/node_modules/@supabase/supabase-js/dist/cors.d.cts

@@ -0,0 +1,58 @@
+//#region src/cors.d.ts
+/**
+ * Canonical CORS configuration for Supabase Edge Functions
+ *
+ * This module exports CORS headers that stay synchronized with the Supabase SDK.
+ * When new headers are added to the SDK, they are automatically included here,
+ * preventing CORS errors in Edge Functions.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { corsHeaders } from '@supabase/supabase-js/cors'
+ *
+ * Deno.serve(async (req) => {
+ *   if (req.method === 'OPTIONS') {
+ *     return new Response('ok', { headers: corsHeaders })
+ *   }
+ *
+ *   return new Response(
+ *     JSON.stringify({ data: 'Hello' }),
+ *     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
+ *   )
+ * })
+ * ```
+ *
+ * @module cors
+ */
+/**
+ * Type representing CORS headers as a record of header names to values
+ */
+type CorsHeaders = Record<string, string>;
+/**
+ * Default CORS headers for Supabase Edge Functions.
+ *
+ * Includes all headers sent by Supabase client libraries and allows all standard HTTP methods.
+ * Use this for simple CORS configurations with wildcard origin.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { corsHeaders } from '@supabase/supabase-js/cors'
+ *
+ * Deno.serve(async (req) => {
+ *   if (req.method === 'OPTIONS') {
+ *     return new Response('ok', { headers: corsHeaders })
+ *   }
+ *
+ *   return new Response(
+ *     JSON.stringify({ data: 'Hello' }),
+ *     { headers: { ...corsHeaders, 'Content-Type': 'application/json' } }
+ *   )
+ * })
+ * ```
+ *
+ * @category Edge Functions
+ */
+declare const corsHeaders: CorsHeaders;
+//#endregion
+export { CorsHeaders, corsHeaders };
+//# sourceMappingURL=cors.d.cts.map

package/templates/realtime-agent/node_modules/@supabase/supabase-js/dist/cors.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cors.d.cts","names":[],"sources":["../src/cors.ts"],"sourcesContent":[],"mappings":";;AAqDA;AA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;KA1BY,WAAA,GAAc;;;;;;;;;;;;;;;;;;;;;;;;;cA0Bb,aAAa"}