@c15t/scripts 2.1.0 → 2.2.0-canary-20260804162155

package/docs/integrations/google-tag-manager.md

@@ -0,0 +1,154 @@
+---
+title: Google Tag Manager
+description: Deploy and manage marketing tags centrally with automatic consent
+  state synchronization.
+icon: google-tag-manager
+group: integrations
+---
+Google Tag Manager (GTM) is Google's tag management system that lets you deploy and manage marketing tags, analytics scripts, and conversion pixels without modifying your codebase. Instead of hardcoding multiple scripts, you configure them through GTM's web interface.
+
+c15t automatically injects the GTM script into your page and syncs consent state with GTM using Consent Mode v2. GTM manages its own internal consent state and only fires tags when appropriate consent is granted, which means it can safely load before consent is collected.
+
+This prevents GTM-managed scripts from loading without proper consent while giving you centralized control over your marketing stack.
+
+> ℹ️ **Info:**
+> Use GTM if your team manages many tags centrally in the GTM UI. Use gtag.js if you only need GA4/Google Ads directly in code. Don't run both for the same destination unless intentional, or you may duplicate events.
+
+## Integrate with c15t
+
+Use your GTM container ID, which begins with `GTM-`.
+
+**React**
+
+```tsx
+import { type ReactNode } from 'react';
+import { ConsentManagerProvider } from '@c15t/react';
+import { googleTagManager } from '@c15t/scripts/google-tag-manager';
+
+const scripts = [googleTagManager({ id: 'GTM-XXXXXXX' })];
+
+export function ConsentProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConsentManagerProvider
+      options={{
+        mode: 'hosted',
+        backendURL: 'https://your-instance.c15t.dev',
+        scripts,
+      }}
+    >
+      {children}
+    </ConsentManagerProvider>
+  );
+}
+```
+
+**Next.js**
+
+```tsx
+'use client';
+
+import { type ReactNode } from 'react';
+import { ConsentManagerProvider } from '@c15t/nextjs';
+import { googleTagManager } from '@c15t/scripts/google-tag-manager';
+
+const scripts = [googleTagManager({ id: 'GTM-XXXXXXX' })];
+
+export function ConsentProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConsentManagerProvider
+      options={{
+        mode: 'hosted',
+        backendURL: '/api/c15t',
+        scripts,
+      }}
+    >
+      {children}
+    </ConsentManagerProvider>
+  );
+}
+```
+
+**JavaScript**
+
+```ts
+import { getOrCreateConsentRuntime } from 'c15t';
+import { googleTagManager } from '@c15t/scripts/google-tag-manager';
+
+getOrCreateConsentRuntime({
+  mode: 'hosted',
+  backendURL: 'https://your-instance.c15t.dev',
+  scripts: [googleTagManager({ id: 'GTM-XXXXXXX' })],
+});
+```
+
+## How c15t loads it
+
+* **Category:** `necessary` (Tag Managers)
+* **Loads when:** [`alwaysLoad`](/docs/frameworks/react/script-loader#always-load) — runs on page start with Consent Mode v2 defaults set to denied
+* **On consent change:** c15t pushes a Consent Mode v2 `update` to the data layer; GTM-managed tags re-evaluate against the new state
+
+## Configure the integration
+
+1. **Creating a Tag Manager Container**
+
+   > 📝 Note:
+   > This step is optional if you already have a Tag Manager container. Ensure your container has consent overview enabled.
+
+   After signing into Google Tag Manager, you can create a new container.
+   Continue to Google Tag Manager
+
+   1. In Tag Manager, click Admin > Container Settings.
+   2. Under Additional Settings, select "Enable consent overview".
+
+   Enable consent overview
+
+2. **Custom Update Trigger** We now need to create a custom trigger in GTM to trigger the update event, this is the trigger that is fired when the consent state is updated, e.g. user gives consent to a specific purpose.
+
+   In GTM, you can create a new trigger by clicking on the "Triggers" tab and then clicking on "New".
+
+   For the event name, you can use the default "consent-update", this is customizable later so you can change it if you want.
+
+   Create trigger
+
+3. **Update tags** Now for your existing tags, you can add the "consent-update" trigger to the tag, this will fire the update event when the consent state is updated & it has the appropriate consent state.
+
+   Update tags
+
+## Tracking events in your app
+
+GTM is `alwaysLoad: true`, so the GTM container and `window.dataLayer` are present from page start regardless of consent. Calls like `dataLayer.push({ event: 'signup' })` are **safe at any time** — Consent Mode v2 defaults are set to denied before the user makes a choice, and GTM-managed tags only fire when the matching consent has been granted.
+
+```ts
+window.dataLayer = window.dataLayer || [];
+window.dataLayer.push({ event: 'signup' });
+```
+
+You do not need to wrap `dataLayer.push(...)` in a `useConsentManager().has(...)` check — the consent gate happens inside GTM, not inside c15t.
+
+## Verify setup
+
+1. Open GTM Preview mode and confirm your container (`GTM-...`) loads on page load.
+2. Before giving consent, confirm non-essential tags do not fire in GTM Preview.
+3. Accept consent in the c15t banner/dialog and confirm a `consent-update` event appears in the GTM event timeline.
+4. Confirm measurement/marketing tags fire only after the matching consent is granted.
+5. Revoke consent and confirm a new `consent-update` event appears and affected tags stop firing.
+
+## Types
+
+### GoogleTagManagerOptions
+
+|Property|Value|
+|:--|:--|
+|Type Name|\`GoogleTagManagerOptions\`|
+|Source Path|\`./packages/scripts/src/vendors/tag-managers/google-tag-manager.ts\`|
+
+\*ExtractedTypeTable: Could not extract "GoogleTagManagerOptions" from "./packages/scripts/src/vendors/tag-managers/google-tag-manager.ts" using base path "/home/runner/work/c15t/c15t". Verify the path/name and that the file is included by your tsconfig.\*
+
+### Script
+
+|Property|Value|
+|:--|:--|
+|Type Name|\`Script\`|
+|Source Path|\`./packages/core/src/libs/script-loader/types.ts\`|
+
+\*ExtractedTypeTable: Could not extract "Script" from "./packages/core/src/libs/script-loader/types.ts" using base path "/home/runner/work/c15t/c15t". Verify the path/name and that the file is included by your tsconfig.\*

package/docs/integrations/google-tag.md

@@ -0,0 +1,134 @@
+---
+title: GA4 + Google Ads (gtag.js)
+description: Send data to Google Analytics 4 and Google Ads with automatic
+  Consent Mode v2 support.
+icon: google-analytics
+group: integrations
+---
+Google Tag (`gtag.js`) is Google's unified tracking script for sending data to Google Analytics 4 (GA4), Google Ads, and Floodlight. It measures user behavior, tracks conversions, and powers Google's advertising ecosystem.
+
+c15t initializes Google Tag with Consent Mode v2 defaults set to denied and automatically updates the consent state when users make choices. You don't need to configure Google Consent Mode yourself.
+
+> ℹ️ **Info:**
+> Use GTM if your team needs centralized tag management in the GTM UI. Use gtag.js if you only need GA4/Google Ads directly in code. Don't run both for the same destination unless intentional, or you may duplicate events.
+
+**Choosing the right category:**
+
+* Use `category: 'measurement'` for analytics-only tracking (GA4 events)
+* Use `category: 'marketing'` for advertising and conversion tracking (Google Ads)
+
+## Integrate with c15t
+
+**React**
+
+```tsx
+import { type ReactNode } from 'react';
+import { ConsentManagerProvider } from '@c15t/react';
+import { gtag } from '@c15t/scripts/google-tag';
+
+const scripts = [
+  gtag({
+    id: 'G-XXXXXXXXXX',
+    category: 'measurement', // or 'marketing'
+  }),
+];
+
+export function ConsentProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConsentManagerProvider
+      options={{
+        mode: 'hosted',
+        backendURL: 'https://your-instance.c15t.dev',
+        scripts,
+      }}
+    >
+      {children}
+    </ConsentManagerProvider>
+  );
+}
+```
+
+**Next.js**
+
+```tsx
+'use client';
+
+import { type ReactNode } from 'react';
+import { ConsentManagerProvider } from '@c15t/nextjs';
+import { gtag } from '@c15t/scripts/google-tag';
+
+const scripts = [
+  gtag({
+    id: 'G-XXXXXXXXXX',
+    category: 'measurement', // or 'marketing'
+  }),
+];
+
+export function ConsentProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConsentManagerProvider
+      options={{
+        mode: 'hosted',
+        backendURL: '/api/c15t',
+        scripts,
+      }}
+    >
+      {children}
+    </ConsentManagerProvider>
+  );
+}
+```
+
+**JavaScript**
+
+```ts
+import { getOrCreateConsentRuntime } from 'c15t';
+import { gtag } from '@c15t/scripts/google-tag';
+
+getOrCreateConsentRuntime({
+  mode: 'hosted',
+  backendURL: 'https://your-instance.c15t.dev',
+  scripts: [
+    gtag({
+      id: 'G-XXXXXXXXXX',
+      category: 'measurement', // or 'marketing'
+    }),
+  ],
+});
+```
+
+## How c15t loads it
+
+* **Category:** configurable — `measurement` (default, Analytics) or `marketing`
+* **Loads when:** [`alwaysLoad`](/docs/frameworks/react/script-loader#always-load) — runs on page start regardless of consent state, with Consent Mode v2 defaults set to denied
+* **On consent change:** [persists](/docs/frameworks/react/script-loader#persist-after-revocation) — c15t pushes a Consent Mode v2 `update` to gtag instead of removing the script
+
+## Tracking events in your app
+
+`gtag.js` is `alwaysLoad: true`, so `window.gtag` is present from page start regardless of consent. Calls like `gtag('event', 'sign_up')` are **safe at any time** — c15t sets Consent Mode v2 defaults to denied before the user makes a choice, and Google's SDK suppresses transmission of events while the relevant consent is denied. When consent later changes, c15t emits a Consent Mode v2 `update` so events fire correctly going forward.
+
+```ts
+window.gtag?.('event', 'sign_up', { method: 'email' });
+```
+
+You do not need to wrap `gtag(...)` calls in a `useConsentManager().has(...)` check — Consent Mode handles the suppression for you.
+
+## Types
+
+### GtagOptions
+
+|Property|Value|
+|:--|:--|
+|Type Name|\`GtagOptions\`|
+|Source Path|\`./packages/scripts/src/vendors/analytics/google-tag.ts\`|
+
+\*ExtractedTypeTable: Could not extract "GtagOptions" from "./packages/scripts/src/vendors/analytics/google-tag.ts" using base path "/home/runner/work/c15t/c15t". Verify the path/name and that the file is included by your tsconfig.\*
+
+### Script
+
+|Property|Value|
+|:--|:--|
+|Type Name|\`Script\`|
+|Source Path|\`./packages/core/src/libs/script-loader/types.ts\`|
+
+\*ExtractedTypeTable: Could not extract "Script" from "./packages/core/src/libs/script-loader/types.ts" using base path "/home/runner/work/c15t/c15t". Verify the path/name and that the file is included by your tsconfig.\*

package/docs/integrations/heap.md

@@ -0,0 +1,219 @@
+---
+title: Heap
+description: Load Heap with c15t and gate autocapture product analytics behind
+  measurement consent.
+group: integrations
+icon: heap
+---
+[Heap](https://www.heap.io/) provides product analytics with automatic interaction capture, identity APIs, event properties, and pageview tracking. The `heap()` helper creates Heap's current heap.js v5 callback queue, records your environment ID and optional client configuration, and loads Heap only when `measurement` consent is available.
+
+## Integrate with c15t
+
+**React**
+
+```tsx
+import { type ReactNode } from 'react';
+import { ConsentManagerProvider } from '@c15t/react';
+import { heap } from '@c15t/scripts/heap';
+
+const scripts = [
+  heap({
+    envId: 'YOUR_APP_ID',
+    clientConfig: {
+      disableTextCapture: true,
+    },
+  }),
+];
+
+export function ConsentProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConsentManagerProvider
+      options={{
+        mode: 'hosted',
+        backendURL: 'https://your-instance.c15t.dev',
+        scripts,
+      }}
+    >
+      {children}
+    </ConsentManagerProvider>
+  );
+}
+```
+
+**Next.js**
+
+```tsx
+'use client';
+
+import { type ReactNode } from 'react';
+import { ConsentManagerProvider } from '@c15t/nextjs';
+import { heap } from '@c15t/scripts/heap';
+
+const scripts = [
+  heap({
+    envId: 'YOUR_APP_ID',
+    clientConfig: {
+      disableTextCapture: true,
+    },
+  }),
+];
+
+export function ConsentProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConsentManagerProvider
+      options={{
+        mode: 'hosted',
+        backendURL: '/api/c15t',
+        scripts,
+      }}
+    >
+      {children}
+    </ConsentManagerProvider>
+  );
+}
+```
+
+**JavaScript**
+
+```ts
+import { getOrCreateConsentRuntime } from 'c15t';
+import { heap } from '@c15t/scripts/heap';
+
+getOrCreateConsentRuntime({
+  mode: 'hosted',
+  backendURL: 'https://your-instance.c15t.dev',
+  scripts: [
+    heap({
+      envId: 'YOUR_APP_ID',
+      clientConfig: {
+        disableTextCapture: true,
+      },
+    }),
+  ],
+});
+```
+
+## How c15t loads it
+
+* **Category:** `measurement` (Analytics)
+* **Loads when:** measurement consent is granted
+* **On revocation:** unloaded - c15t removes the script element it created. `window.heap` and `window.heapReadyCb` remain until the next page load (c15t reloads the page on revocation by default), and Heap has no documented browser opt-out API — treat the load gate as the consent boundary.
+
+The helper maps Heap's current web installation snippet into the manifest engine:
+
+```ts
+heap({
+  envId: 'YOUR_APP_ID',
+  clientConfig: {
+    disableTextCapture: true,
+  },
+});
+```
+
+It creates `window.heapReadyCb` and `window.heap`, records:
+
+```ts
+window.heap.envId = 'YOUR_APP_ID';
+window.heap.appid = 'YOUR_APP_ID';
+window.heap.clientConfig = {
+  disableTextCapture: true,
+  shouldFetchServerConfig: false,
+};
+```
+
+and loads:
+
+```txt
+https://cdn.us.heap-api.com/config/YOUR_APP_ID/heap_config.js
+```
+
+Heap's config script then chain-loads the versioned heap.js runtime for that environment. The official snippet stores queued calls as `{ name, fn }` records in `window.heapReadyCb`; c15t reproduces that callback queue instead of using tuple queues such as `['track', ...args]`.
+
+`envId` is required and must be a non-empty string after trimming. Heap app IDs are commonly numeric strings, but Heap's public install docs describe the value as your app ID, so c15t does not enforce a numeric-only format.
+
+## Configure heap.js
+
+Pass `clientConfig` as the second Heap load argument. Values must be JSON-serializable: plain objects, arrays, strings, finite numbers, booleans, and `null`.
+
+```ts
+import { heap } from '@c15t/scripts/heap';
+
+heap({
+  envId: 'YOUR_APP_ID',
+  clientConfig: {
+    disableTextCapture: true,
+    disableSessionReplay: true,
+    metadataStorage: 'localstorage',
+  },
+});
+```
+
+c15t always adds `shouldFetchServerConfig: false`, matching Heap's current installation snippet. Do not pass functions, Dates, Maps, Sets, class instances, symbols, `undefined`, `NaN`, or infinite numbers in `clientConfig`.
+
+To proxy or self-host the config loader, pass a custom URL:
+
+```ts
+heap({
+  envId: 'YOUR_APP_ID',
+  scriptUrl: 'https://analytics.example.com/heap_config.js',
+});
+```
+
+## Consent behavior
+
+c15t blocks Heap from loading until `measurement` consent is granted and unloads it on revocation. Heap autocaptures interactions when heap.js runs, and its web installation docs do not document a consent-mode-style runtime opt-out API that c15t can call to make an already-loaded SDK inert after consent is withdrawn.
+
+That makes the consent gate on load the consent boundary: no Heap config loader, heap.js runtime, cookies, localStorage, automatic page tracking, or interaction capture should start before the user grants `measurement` consent. See the [RudderStack consent notes](/docs/integrations/rudderstack#consent-behavior) for the broader reasoning behind blocking SDK load when a vendor API cannot guarantee denied-by-default collection semantics.
+
+## Tracking events in your app
+
+c15t gates Heap from loading until `measurement` consent is granted. Your application code that calls Heap's runtime API (`window.heap.track`, `identify`, etc.) is **not** automatically gated - `window.heap` does not exist until the script is loaded, so unguarded calls before consent throw.
+
+Guard event calls by checking consent state. From React:
+
+```tsx
+import { useCallback } from 'react';
+import { useConsentManager } from '@c15t/react';
+
+function SignupExample() {
+  const { has } = useConsentManager();
+
+  const trackSignup = useCallback(() => {
+    if (has('measurement')) {
+      window.heap?.track('Signup Completed', { plan: 'pro' });
+    }
+  }, [has]);
+}
+```
+
+From plain JavaScript:
+
+```ts
+import { getOrCreateConsentRuntime } from 'c15t';
+
+const { consentStore } = getOrCreateConsentRuntime();
+
+if (consentStore.getState().has('measurement')) {
+  window.heap?.track('Signup Completed', { plan: 'pro' });
+}
+```
+
+## Types
+
+### HeapOptions
+
+|Property|Value|
+|:--|:--|
+|Type Name|\`HeapOptions\`|
+|Source Path|\`./packages/scripts/src/vendors/analytics/heap.ts\`|
+
+\*ExtractedTypeTable: Could not extract "HeapOptions" from "./packages/scripts/src/vendors/analytics/heap.ts" using base path "/home/runner/work/c15t/c15t". Verify the path/name and that the file is included by your tsconfig.\*
+
+### Script
+
+|Property|Value|
+|:--|:--|
+|Type Name|\`Script\`|
+|Source Path|\`./packages/core/src/libs/script-loader/types.ts\`|
+
+\*ExtractedTypeTable: Could not extract "Script" from "./packages/core/src/libs/script-loader/types.ts" using base path "/home/runner/work/c15t/c15t". Verify the path/name and that the file is included by your tsconfig.\*

package/docs/integrations/hightouch.md

@@ -0,0 +1,199 @@
+---
+title: Hightouch
+description: Load Hightouch Events with c15t and gate the browser SDK behind
+  measurement consent.
+group: integrations
+icon: hightouch
+---
+[Hightouch Events](https://hightouch.com/docs/events/overview) collects customer behavior from websites and sends it into Hightouch for warehouse-backed analytics, activation, and real-time workflows. The `hightouch()` helper creates Hightouch's `window.htevents` queue, records the write key and optional API host for the standalone loader, optionally queues the initial `page()` call, and loads the browser SDK when `measurement` consent is available.
+
+## Integrate with c15t
+
+**React**
+
+```tsx
+import { type ReactNode } from 'react';
+import { ConsentManagerProvider } from '@c15t/react';
+import { hightouch } from '@c15t/scripts/hightouch';
+
+const scripts = [
+  hightouch({
+    writeKey: 'WRITE_KEY',
+    apiHost: 'us-east-1.hightouch-events.com',
+  }),
+];
+
+export function ConsentProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConsentManagerProvider
+      options={{
+        mode: 'hosted',
+        backendURL: 'https://your-instance.c15t.dev',
+        scripts,
+      }}
+    >
+      {children}
+    </ConsentManagerProvider>
+  );
+}
+```
+
+**Next.js**
+
+```tsx
+'use client';
+
+import { type ReactNode } from 'react';
+import { ConsentManagerProvider } from '@c15t/nextjs';
+import { hightouch } from '@c15t/scripts/hightouch';
+
+const scripts = [
+  hightouch({
+    writeKey: 'WRITE_KEY',
+    apiHost: 'us-east-1.hightouch-events.com',
+  }),
+];
+
+export function ConsentProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConsentManagerProvider
+      options={{
+        mode: 'hosted',
+        backendURL: '/api/c15t',
+        scripts,
+      }}
+    >
+      {children}
+    </ConsentManagerProvider>
+  );
+}
+```
+
+**JavaScript**
+
+```ts
+import { getOrCreateConsentRuntime } from 'c15t';
+import { hightouch } from '@c15t/scripts/hightouch';
+
+getOrCreateConsentRuntime({
+  mode: 'hosted',
+  backendURL: 'https://your-instance.c15t.dev',
+  scripts: [
+    hightouch({
+      writeKey: 'WRITE_KEY',
+      apiHost: 'us-east-1.hightouch-events.com',
+    }),
+  ],
+});
+```
+
+## How c15t loads it
+
+* **Category:** `measurement` (Analytics)
+* **Loads when:** measurement consent is granted
+* **On revocation:** unloaded - c15t removes the script element it created. The `window.htevents` runtime object is left in place until the next page load (c15t reloads the page on revocation by default), so treat the load gate as the consent boundary.
+
+The helper maps Hightouch's browser snippet into the manifest engine:
+
+```ts
+hightouch({
+  writeKey: 'WRITE_KEY',
+  apiHost: 'us-east-1.hightouch-events.com',
+});
+```
+
+It creates `window.htevents`, defines the official queue methods, queues:
+
+```ts
+window.htevents.load('WRITE_KEY', {
+  apiHost: 'us-east-1.hightouch-events.com',
+});
+window.htevents.page();
+```
+
+and loads:
+
+```txt
+https://cdn.hightouch-events.com/browser/release/v1-latest/events.min.js
+```
+
+`writeKey` is required and must be a non-empty string after trimming. `apiHost` is optional; Hightouch's SDK defaults to `us-east-1.hightouch-events.com`, so pass it only when your Event Source uses another region or a first-party tracking host.
+
+## Configure page tracking
+
+By default the helper queues `htevents.page()` before the vendor bundle loads. If you want to handle page views yourself, set `trackPageView` to `false`.
+
+```ts
+import { hightouch } from '@c15t/scripts/hightouch';
+
+hightouch({
+  writeKey: 'WRITE_KEY',
+  trackPageView: false,
+});
+```
+
+To proxy or self-host the loader, pass a custom URL:
+
+```ts
+hightouch({
+  writeKey: 'WRITE_KEY',
+  scriptUrl: 'https://analytics.example.com/events.min.js',
+});
+```
+
+## Consent behavior
+
+c15t blocks the Hightouch SDK from loading until `measurement` consent is granted and unloads it on revocation. Hightouch does not expose a browser API that prevents collection while loaded — the SDK writes identifiers and delivers events to Hightouch as soon as it runs — so gating the load is the only default that reliably honors missing or denied consent. See the [RudderStack consent notes](/docs/integrations/rudderstack#consent-behavior) for the full reasoning behind this model versus vendor consent-API mapping (as used for Google Tag Manager).
+
+## Tracking events in your app
+
+c15t gates the Hightouch browser SDK from loading until `measurement` consent is granted. Your application code that calls Hightouch's runtime API (`window.htevents.track`, `identify`, etc.) is **not** automatically gated - `window.htevents` does not exist until c15t initializes the integration, so unguarded calls made before that (or while consent is denied) throw. Once the integration is initialized with consent, early calls queue normally until the SDK finishes loading.
+
+Guard event calls by checking consent state. From React:
+
+```tsx
+import { useCallback } from 'react';
+import { useConsentManager } from '@c15t/react';
+
+function SignupExample() {
+  const { has } = useConsentManager();
+
+  const trackSignup = useCallback(() => {
+    if (has('measurement')) {
+      window.htevents?.track('Signup Completed', { plan: 'pro' });
+    }
+  }, [has]);
+}
+```
+
+From plain JavaScript:
+
+```ts
+import { getOrCreateConsentRuntime } from 'c15t';
+
+const { consentStore } = getOrCreateConsentRuntime();
+
+if (consentStore.getState().has('measurement')) {
+  window.htevents?.track('Signup Completed', { plan: 'pro' });
+}
+```
+
+## Types
+
+### HightouchOptions
+
+|Property|Value|
+|:--|:--|
+|Type Name|\`HightouchOptions\`|
+|Source Path|\`./packages/scripts/src/vendors/analytics/hightouch.ts\`|
+
+\*ExtractedTypeTable: Could not extract "HightouchOptions" from "./packages/scripts/src/vendors/analytics/hightouch.ts" using base path "/home/runner/work/c15t/c15t". Verify the path/name and that the file is included by your tsconfig.\*
+
+### Script
+
+|Property|Value|
+|:--|:--|
+|Type Name|\`Script\`|
+|Source Path|\`./packages/core/src/libs/script-loader/types.ts\`|
+
+\*ExtractedTypeTable: Could not extract "Script" from "./packages/core/src/libs/script-loader/types.ts" using base path "/home/runner/work/c15t/c15t". Verify the path/name and that the file is included by your tsconfig.\*