diff --git a/Makefile b/Makefile
index 6d6f3970..138f3b15 100644
--- a/Makefile
+++ b/Makefile
@@ -84,6 +84,50 @@ else
 endif
 	$(TARGET_OK)
 
+.PHONY: tests-sandbox
+tests-sandbox: .require-compose ## [Tests][docker] Runs jsdom, browser and e2e tests for v1-sandbox
+	$(TARGET_HEADER)
+	$(COMPOSE) run --rm --user "$$(id -u):$$(id -g)" playwright \
+    	  yarn workspace @retailcrm/embed-ui-v1-sandbox test:all
+	$(TARGET_OK)
+
+.PHONY: tests-sandbox-browser
+tests-sandbox-browser: .require-compose ## [Tests][docker] Run browser mod tests for v1-sandbox
+	$(TARGET_HEADER)
+ifdef cli
+	@$(COMPOSE) run --rm --user "$$(id -u):$$(id -g)" playwright \
+		yarn workspace @retailcrm/embed-ui-v1-sandbox test:browser $(cli) --passWithNoTests
+else
+	@$(COMPOSE) run --rm --user "$$(id -u):$$(id -g)" playwright \
+		yarn workspace @retailcrm/embed-ui-v1-sandbox test:browser
+endif
+	$(TARGET_OK)
+
+
+.PHONY: tests-sandbox-e2e
+tests-sandbox-e2e: .require-compose ## [Tests][docker] Run e2e tests for v1-sandbox
+	$(TARGET_HEADER)
+ifdef cli
+	@$(COMPOSE) run --rm --user "$$(id -u):$$(id -g)" playwright \
+		yarn workspace @retailcrm/embed-ui-v1-sandbox test:e2e $(cli)
+else
+	@$(COMPOSE) run --rm --user "$$(id -u):$$(id -g)" playwright \
+		yarn workspace @retailcrm/embed-ui-v1-sandbox test:e2e
+endif
+	$(TARGET_OK)
+
+.PHONY: tests-sandbox-jsdom
+tests-sandbox-jsdom: .require-compose ## [Tests][docker] Run jsdom tests for v1-sandbox
+	$(TARGET_HEADER)
+ifdef cli
+	@$(COMPOSE) run --rm --user "$$(id -u):$$(id -g)" playwright \
+		yarn workspace @retailcrm/embed-ui-v1-sandbox test:jsdom $(cli) --passWithNoTests
+else
+	@$(COMPOSE) run --rm --user "$$(id -u):$$(id -g)" playwright \
+		yarn workspace @retailcrm/embed-ui-v1-sandbox test:jsdom
+endif
+	$(TARGET_OK)
+
 .PHONY: tests-browser
 tests-browser: .require-compose ## [Tests][docker] Runs browser mode tests for all workspaces
 	$(TARGET_HEADER)
diff --git a/docker-compose.yml b/docker-compose.yml
index 5326ef90..0f5b89d4 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -43,6 +43,8 @@ services:
     environment:
       - COREPACK_ENABLE_DOWNLOAD_PROMPT=0
       - PATH=/project/node_modules/.bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+      - HOME=/tmp
+      - COREPACK_HOME=/tmp/corepack
     volumes:
       - ./:/project
     working_dir: /project
diff --git a/packages/v1-sandbox/README.md b/packages/v1-sandbox/README.md
index eec89fd2..e791853a 100644
--- a/packages/v1-sandbox/README.md
+++ b/packages/v1-sandbox/README.md
@@ -39,8 +39,21 @@ npx @retailcrm/embed-ui-v1-sandbox serve
 embed-ui-v1-sandbox serve --host 0.0.0.0 --port 4173
 ```
 
-Откройте URL из вывода команды, укажите URL расширения
-`%extension-url%/extension/%extension-id%`, выберите режим и fixture, затем нажмите `Apply`.
+Откройте URL из вывода команды и вставьте runtime-дескриптор расширения:
+
+```json
+{
+  "code": "returnsModule",
+  "baseUrl": "https://extension.test",
+  "entrypoint": "/build/worker.js",
+  "pages": ["returns"],
+  "stylesheet": "/build/extension.css",
+  "targets": []
+}
+```
+
+`entrypoint` и `stylesheet` разрешаются относительно `baseUrl`. JSON можно
+вставить целиком либо заполнить те же поля отдельно в DevPanel.
 
 ## Применение в тестах
 
@@ -68,8 +81,15 @@ test('loads extension page in sandbox', async ({ page }) => {
   await page.goto('/')
 
   await launchSandboxExtension(page, {
+    descriptor: {
+      code: 'returnsModule',
+      baseUrl: 'https://extension.test',
+      entrypoint: '/build/worker.js',
+      pages: ['returns'],
+      stylesheet: '/build/extension.css',
+      targets: [],
+    },
     fixture: 'order-basic',
-    manifestUrl: '%extension-url%/extension/%extension-id%',
     mode: 'page',
     pageCode: 'returns',
   })
diff --git a/packages/v1-sandbox/docs/api.md b/packages/v1-sandbox/docs/api.md
index 2d065110..630fcac0 100644
--- a/packages/v1-sandbox/docs/api.md
+++ b/packages/v1-sandbox/docs/api.md
@@ -123,9 +123,15 @@ HostAPI snapshot from `window.__CRM_EMBED_SANDBOX__`:
 
 ```ts
 await page.goto(createSandboxPagePath({
-  extensionUrl: '%extension-url%/extension/%extension-id%',
+  descriptor: {
+    code: 'returnsModule',
+    baseUrl: 'https://extension.test',
+    entrypoint: '/build/worker.js',
+    pages: ['returns'],
+    stylesheet: '/build/extension.css',
+    targets: [],
+  },
   pageCode: 'returns',
-  targets: ['order/card:common.after'],
 }))
 
 const snapshot = await readSandboxSnapshot(page)
@@ -156,24 +162,40 @@ from package delivery or a test process.
 
 The sandbox app is controlled by query parameters:
 
-- `manifestUrl`: full extension descriptor/entrypoint/script URL.
+- `descriptor`: URL-encoded JSON runtime descriptor. This is the primary mode.
 - `mode`: `widget` or `page`.
 - `fixture`: sandbox fixture code, for example `order-basic`.
 - `pageCode`: page runner code for `mode=page`.
 - `targets`: comma-separated widget targets for `mode=widget`.
 - `widgetId`: base widget instance id.
-- `extensionUrl`: low-level fallback for direct worker entrypoints.
+
+The runtime descriptor has exactly these fields:
+
+```ts
+type SandboxExtensionDescriptor = {
+  code: string
+  baseUrl: string
+  entrypoint: string
+  stylesheet: string | null
+  pages: string[]
+  targets: TargetName[]
+}
+```
+
+`baseUrl` must be an absolute HTTP(S) URL. `entrypoint` and non-null
+`stylesheet` may be relative to it or absolute. Unknown fields, including
+`runner` and `uuid`, are rejected.
 
 Example page URL:
 
 ```text
-%sandbox-url%/?manifestUrl=%extension-url%/extension/%extension-id%&mode=page&pageCode=returns&fixture=order-basic
+%sandbox-url%/?descriptor=%url-encoded-descriptor-json%&mode=page&pageCode=returns&fixture=order-basic
 ```
 
 Example widget URL:
 
 ```text
-%sandbox-url%/?manifestUrl=%extension-url%/extension/%extension-id%&mode=widget&targets=order/card:common.after&fixture=order-basic
+%sandbox-url%/?descriptor=%url-encoded-descriptor-json%&mode=widget&targets=order/card:common.after&fixture=order-basic
 ```
 
 ## HostAPI HTTP Contract
@@ -184,7 +206,8 @@ Extensions call:
 await host.httpCall('/returns', payload)
 ```
 
-When the sandbox can infer the backend base from `manifestUrl`, it sends:
+In descriptor mode the backend base is `baseUrl`; the call
+above sends:
 
 ```text
 POST %extension-url%/returns
diff --git a/packages/v1-sandbox/docs/examples.md b/packages/v1-sandbox/docs/examples.md
index 9dfe0d64..ad69c16f 100644
--- a/packages/v1-sandbox/docs/examples.md
+++ b/packages/v1-sandbox/docs/examples.md
@@ -11,22 +11,29 @@ Start the sandbox app:
 npx @retailcrm/embed-ui-v1-sandbox serve
 ```
 
-Open the printed URL and paste a full extension endpoint:
+Open the printed URL and paste a runtime descriptor:
 
-```text
-%extension-url%/extension/%extension-id%
+```json
+{
+  "code": "promoModule",
+  "baseUrl": "http://web-extensions-server.simla.local",
+  "entrypoint": "/extension/8ebe1617-d609-43e4-b35a-fbfae011eee3/script",
+  "stylesheet": "/extension/8ebe1617-d609-43e4-b35a-fbfae011eee3/stylesheet",
+  "targets": [],
+  "pages": ["settings"],
+}
 ```
 
 Page runner direct URL:
 
 ```text
-%sandbox-url%/?manifestUrl=%extension-url%/extension/%extension-id%&mode=page&pageCode=returns&fixture=order-basic
+%sandbox-url%/?descriptor=%url-encoded-descriptor-json%&mode=page&pageCode=returns&fixture=order-basic
 ```
 
 Widget runner direct URL:
 
 ```text
-%sandbox-url%/?manifestUrl=%extension-url%/extension/%extension-id%&mode=widget&targets=order/card:common.after&fixture=order-basic
+%sandbox-url%/?descriptor=%url-encoded-descriptor-json%&mode=widget&targets=order/card:common.after&fixture=order-basic
 ```
 
 Use the DevPanel to switch fixtures, edit Context JSON, or change page/widget
@@ -88,8 +95,15 @@ afterEach(() => {
 
 test('mounts page extension in browser mode', async () => {
   sandbox = await launchSandboxExtension({
+    descriptor: {
+      baseUrl: new URL('/tests/fixtures/extensions/returnsModule/', window.location.href).href,
+      code: 'returnsModule',
+      entrypoint: 'index.ts',
+      pages: ['returns'],
+      stylesheet: null,
+      targets: [],
+    },
     fixture: 'order-basic',
-    manifestUrl: '/tests/fixtures/extensions/returnsModule/index.ts',
     mode: 'page',
     pageCode: 'returns',
   })
@@ -119,8 +133,15 @@ import { expect, test } from '@playwright/test'
 
 test('loads returns page extension', async ({ page }) => {
   await page.goto(
-    '/?manifestUrl='
-    + encodeURIComponent('%extension-url%/extension/%extension-id%')
+    '/?descriptor='
+    + encodeURIComponent(JSON.stringify({
+      code: 'returnsModule',
+      baseUrl: 'https://extension.test',
+      entrypoint: '/build/worker.js',
+      pages: ['returns'],
+      stylesheet: '/build/extension.css',
+      targets: [],
+    }))
     + '&mode=page'
     + '&pageCode=returns'
     + '&fixture=order-basic'
@@ -142,8 +163,15 @@ import {
 await page.goto('/')
 
 await launchSandboxExtension(page, {
+  descriptor: {
+    code: 'promoModule',
+    baseUrl: 'https://extension.test',
+    entrypoint: '/build/worker.js',
+    pages: [],
+    stylesheet: null,
+    targets: ['order/card:common.after'],
+  },
   fixture: 'order-basic',
-  manifestUrl: '%extension-url%/extension/%extension-id%',
   mode: 'widget',
   targets: ['order/card:common.after'],
 })
diff --git a/packages/v1-sandbox/docs/usage-guide.md b/packages/v1-sandbox/docs/usage-guide.md
index 539553b5..d2f1afab 100644
--- a/packages/v1-sandbox/docs/usage-guide.md
+++ b/packages/v1-sandbox/docs/usage-guide.md
@@ -1,9 +1,9 @@
 # v1-sandbox Usage Guide
 
 `v1-sandbox` is a local CRM-like environment for running JS extensions before
-installing them into a real CRM. The sandbox loads an external extension by URL,
-mounts it into a selected widget target or page area, provides fixture-backed
-context, and simulates HostAPI.
+installing them into a real CRM. The sandbox loads an external extension from a
+runtime descriptor, mounts it into a selected widget target or page area,
+provides fixture-backed context, and simulates HostAPI.
 
 Related docs:
 
@@ -36,30 +36,30 @@ yarn embed-ui-v1-sandbox serve
 uses Traefik and the `.test` top-level domain; OrbStack on macOS uses `.local`
 from its domain namespace.
 
-3. Start your extension project separately. It must expose the extension module
-over HTTP. The standard URL shape is:
+3. Start your extension project separately. It must expose the worker module
+and optional stylesheet over HTTP(S). Prepare a runtime descriptor:
 
-```text
-%extension-url%/extension/%extension-id%
+```json
+{
+  "baseUrl": "https://extension.test/build/",
+  "code": "returnsModule",
+  "entrypoint": "worker.js",
+  "pages": ["returns"],
+  "stylesheet": "extension.css",
+  "targets": []
+}
 ```
 
-`%extension-url%` is the delivery server origin without
-`/extension/%extension-id%`. It can be `http://web-extensions-server.simla.local`,
-`http://web-extensions-server.simla.test`, `https://ycp-retail.ru`, or any other
-available extension server. `manifestUrl` must include the `/extension/` path
-and `%extension-id%`.
+This descriptor is the runtime contract, not the raw `extensionrc.json` from an
+extension project. `baseUrl` is absolute, while `entrypoint` and `stylesheet`
+may be relative to it. `pages` contains page-code strings, and the descriptor
+has no `runner` or `uuid` field. The sandbox supports worker extensions only.
 
 4. In the sandbox, click the `</>` icon in the lower part of the dark rail. The
    sandbox control panel opens.
 
-5. Paste the extension URL into `Manifest / extension URL`.
-
-- `%extension-url%`: delivery server origin without `/extension/%extension-id%`;
-- `/extension/`: the default extension server API path. If your server uses a
-  different descriptor path, paste the full endpoint URL;
-- `%extension-id%`: id/UUID of the JS module or extension record on the
-  extension server. It is not a `pageCode` and not a target; one extension can
-  contain pages and widgets.
+5. Paste the JSON into `Descriptor JSON`, or fill in `Code`, `Base URL`,
+   `Entrypoint`, and `Stylesheet` separately.
 
 6. Select a mode:
 
@@ -102,38 +102,39 @@ The CLI prints the URL it serves. Use that URL as `%sandbox-url%` in the
 examples below.
 
 The built app does not contain extension code. Your extension server still runs
-separately, and the sandbox receives it through `Manifest / extension URL`.
-
-## What to Paste into Manifest / Extension URL
-
-The primary value is the descriptor or entrypoint URL:
-
-```text
-%extension-url%/extension/%extension-id%
-```
-
-The sandbox can load:
+separately, and the sandbox receives its runtime descriptor through
+`Descriptor JSON`.
 
-- an HTML entrypoint, using the first `<script src>` from `<head>`;
-- a direct JS script.
+## What to Paste into Descriptor JSON
 
-Core-style delivery usually exposes the script here:
+The value is a JSON object with exactly seven fields:
 
-```text
-%extension-url%/extension/%extension-id%/script
+```json
+{
+  "baseUrl": "https://extension.test/assets/",
+  "code": "returnsModule",
+  "entrypoint": "worker.js",
+  "pages": ["returns"],
+  "stylesheet": "styles.css",
+  "targets": ["order/card:common.after"]
+}
 ```
 
-In the control panel, normally paste the full extension endpoint URL:
-
-```text
-%extension-url%/extension/%extension-id%
-```
+The sandbox passes `entrypoint` to the worker and connects `stylesheet`
+directly, without fetching or analyzing HTML first. Relative resource paths
+are resolved against `baseUrl`; absolute HTTP(S) resource URLs are also
+accepted. `host.httpCall` uses `baseUrl` as its backend base. `code` and every
+array item must be non-empty strings, while `stylesheet` may be `null`. Extra
+fields, including `runner` and `uuid`, are rejected.
 
 ## Control Panel Fields
 
-- `Manifest / extension URL`: full descriptor/entrypoint/script URL fetched by
-  the sandbox. For the standard extension server, use
-  `%extension-url%/extension/%extension-id%`.
+- `Descriptor JSON`: the complete runtime descriptor. It is synchronized with
+  the individual descriptor fields below it.
+- `Code`: stable module code used as the worker and Host API identity.
+- `Base URL`: absolute HTTP(S) base address of the extension server.
+- `Entrypoint`: worker script URL, relative to `Base URL` or absolute.
+- `Stylesheet`: optional stylesheet URL, relative to `Base URL` or absolute.
 - `Mode`: selects the runner type. `Widgets` mounts widgets into CRM slots;
   `Page` mounts a page runner by `Page code`.
 - `Selected fixture`: CRM mock state for the next launch: order context, custom
@@ -153,9 +154,9 @@ The control panel validates launch values when you click `Apply` and validates
 the context editor when you click `Apply context`. It does not check network
 availability.
 
-- `Manifest / extension URL` is required before applying the launch settings.
-  It must be an absolute `http` or `https` URL and, for the standard extension
-  server, include `/extension/%extension-id%`.
+- `Descriptor JSON` is required and validated strictly. `Base URL` must be an
+  absolute HTTP(S) URL; `Entrypoint` and non-null `Stylesheet` must resolve to
+  HTTP(S) URLs.
 - `Mode` must be `Widgets` or `Page`.
 - `Selected fixture` must be one of the sandbox fixtures.
 - `Page code` is required only in `Page` mode.
@@ -164,7 +165,7 @@ availability.
   known context keys, and each context value must be an object.
 
 The `Apply` button is disabled until the required launch fields are filled:
-extension URL, mode, fixture, at least one widget target in `Widgets` mode, and
+extension descriptor, mode, fixture, at least one widget target in `Widgets` mode, and
 page code in `Page` mode.
 
 `Apply context` is available only while an extension is connected, the JSON
@@ -178,7 +179,7 @@ Use `Widgets` mode when an extension registers `widgets` with `defineRunner`.
 
 Control panel flow:
 
-1. Paste `Manifest / extension URL`.
+1. Paste `Descriptor JSON` or fill its individual fields.
 2. Select `Mode: Widgets`.
 3. Choose the required value in `Selected fixture`.
 4. Check the required `Widget targets`.
@@ -190,7 +191,7 @@ two widget instances and calls the runner for each selected slot.
 Example direct URL:
 
 ```text
-%sandbox-url%/?manifestUrl=%extension-url%/extension/%extension-id%&mode=widget&targets=order/card:common.before,order/card:common.after&fixture=order-basic
+%sandbox-url%/?descriptor=%url-encoded-descriptor-json%&mode=widget&targets=order/card:common.before,order/card:common.after&fixture=order-basic
 ```
 
 ## Running a Page
@@ -199,7 +200,7 @@ Use `Page` mode when an extension registers `pages` with `defineRunner`.
 
 Control panel flow:
 
-1. Paste `Manifest / extension URL`.
+1. Paste `Descriptor JSON` or fill its individual fields.
 2. Select `Mode: Page`.
 3. Enter the page runner code into `Page code`.
 4. Choose the required value in `Selected fixture`.
@@ -208,22 +209,23 @@ Control panel flow:
 Important: `Page code` is not the extension UUID and not a module code. It is
 the value from the extension `pages` registration.
 
-Example extension descriptor:
+Example runtime descriptor:
 
 ```json
 {
-  "uuid": "05a9f990-7cfc-46c2-af0f-3abfd3d4c334",
-  "pages": [
-    { "code": "board" },
-    { "code": "summary" }
-  ]
+  "baseUrl": "https://extension.test/build/",
+  "code": "returnsModule",
+  "entrypoint": "worker.js",
+  "pages": ["board", "summary"],
+  "stylesheet": null,
+  "targets": []
 }
 ```
 
 For this extension:
 
 ```text
-Manifest / extension URL = %extension-url%/extension/05a9f990-7cfc-46c2-af0f-3abfd3d4c334
+Descriptor JSON = {runtime descriptor JSON above}
 Page code = board
 ```
 
@@ -236,7 +238,7 @@ Page code = summary
 Example direct URL:
 
 ```text
-%sandbox-url%/?manifestUrl=%extension-url%/extension/%extension-id%&mode=page&pageCode=%page-code%&fixture=order-basic
+%sandbox-url%/?descriptor=%url-encoded-descriptor-json%&mode=page&pageCode=%page-code%&fixture=order-basic
 ```
 
 ## Fixtures and Context JSON
@@ -295,7 +297,7 @@ that backend.
 Example:
 
 ```text
-Manifest / extension URL = %extension-url%/extension/%extension-id%
+Descriptor entrypoint = %extension-url%/build/worker.js
 Extension call = host.httpCall('/returns', payload)
 Sandbox request = POST %extension-url%/returns
 ```
@@ -335,13 +337,13 @@ The snapshot can be used to inspect:
 Check three things:
 
 1. The extension UI appears in the selected widget target or page area.
-2. DevTools Network shows requests to the extension server:
-   descriptor/entrypoint/script/stylesheet.
+2. DevTools Network shows requests to the descriptor's entrypoint and optional
+   stylesheet URLs.
 3. The console has no runner startup errors.
 
 If the page is blank:
 
-- check that `Manifest / extension URL` is not empty;
+- check that `Descriptor JSON` is not empty;
 - in `Page` mode, verify the `Page code`;
 - in `Widgets` mode, verify that the selected target is actually registered by
   the extension;
@@ -368,16 +370,23 @@ export default defineConfig({
 })
 ```
 
-Then open the sandbox with the extension URL in the test:
+Then open the sandbox with the extension descriptor in the test:
 
 ```ts
 import { expect, test } from '@playwright/test'
 
 test('mounts widget extension in sandbox', async ({ page }) => {
-  const extensionUrl = '%extension-url%/extension/%extension-id%'
+  const descriptor = {
+    baseUrl: '%extension-url%/',
+    code: 'returnsModule',
+    entrypoint: 'build/worker.js',
+    pages: [],
+    stylesheet: 'build/extension.css',
+    targets: ['order/card:common.after'],
+  }
 
   await page.goto(
-    `/?manifestUrl=${encodeURIComponent(extensionUrl)}`
+    `/?descriptor=${encodeURIComponent(JSON.stringify(descriptor))}`
     + '&mode=widget'
     + '&fixture=order-basic'
     + '&targets=order/card:common.after'
@@ -394,9 +403,8 @@ second Playwright `webServer`.
 
 The sandbox repository keeps fixture extensions in
 `tests/__fixtures__/extensions/`. Each fixture entrypoint should be real
-extension code. For example, a browser test can point `manifestUrl` directly to
-`/tests/__fixtures__/extensions/returnsModule/index.ts` and let the sandbox
-load it through the normal manifest resolver.
+extension code. Browser tests can pass the fixture entrypoint to the worker
+runtime directly; full sandbox-app tests use a runtime descriptor.
 
 ### Fixture Extension Format
 
@@ -414,15 +422,16 @@ tests/__fixtures__/extensions/%extension-name%/
 register or export the same extension code that would be delivered by the
 external extension server.
 
-The test also needs a small descriptor with runtime metadata:
+The test also needs fixture metadata that can be converted to the strict
+runtime descriptor:
 
 - `fixtureName`: local folder name under `tests/__fixtures__/extensions/`;
-- `uuid`: extension id used to build
-  `%extension-url%/extension/%extension-id%`;
+- `uuid`: extension id kept in the source fixture metadata when the real module
+  has one; it is not copied to the runtime descriptor;
 - `targets`: widget mount slots, required for `mode=widget`;
 - `pages[].code`: page codes, required for `mode=page`.
 
-There are two supported ways to provide that descriptor.
+There are two supported ways to provide this fixture metadata.
 
 Use `extensionrc.json` when the fixture can keep metadata next to its source:
 
@@ -446,15 +455,19 @@ Then the test can read it:
 ```ts
 const extension = readExtensionFixture('returnsModule')
 const [pageCode] = getExtensionPageCodes(extension)
+const descriptor = createRuntimeExtensionDescriptor(extension)
 
 await page.goto(createSandboxPagePath({
-  extensionUrl: createExternalExtensionUrl(extension),
-  manifestUrl: createExtensionManifestUrl(extension),
+  descriptor,
   pageCode,
-  targets: getExtensionTargets(extension),
 }))
 ```
 
+Raw `extensionrc.json` is not passed to the sandbox. The helper converts page
+objects to code strings, creates a runtime `baseUrl` with relative
+entrypoint/stylesheet paths, uses the fixture name as `code`, and drops
+project-only fields such as `runner` and `uuid`.
+
 Use an inline descriptor when the extension source is copied from an external
 project and should not get a local `extensionrc.json`:
 
@@ -469,17 +482,16 @@ const extension = {
 const [target] = getExtensionTargets(extension)
 
 await page.goto(createSandboxWidgetPath({
-  extensionUrl: createExternalExtensionUrl(extension),
-  manifestUrl: createExtensionManifestUrl(extension),
+  descriptor: createRuntimeExtensionDescriptor(extension),
   targets: [target],
 }))
 ```
 
-Both variants produce the same sandbox launch config. The difference is only
-where the descriptor data comes from: a local JSON file or the test itself.
+Both variants produce the same strict runtime descriptor. The difference is
+only where the source fixture metadata comes from.
 
-When an extension calls `host.httpCall(action, payload)`, the sandbox uses
-`extensionUrl` to find the external backend base and proxies the call to
+When an extension calls `host.httpCall(action, payload)`, the sandbox uses the
+runtime descriptor's `baseUrl` and proxies the call to
 `%extension-url%/%action%`. That keeps tests close to the real CRM flow without
 hardcoding backend response shapes in Playwright.
 
@@ -555,8 +567,8 @@ sandbox app:
 
 1. Read the extension fixture descriptor or provide a small descriptor in the
    test when the fixture intentionally has no local config.
-2. Build a sandbox URL with local `manifestUrl`, external `extensionUrl`,
-   `mode`, `fixture`, and either `pageCode` or `targets`.
+2. Convert it to a strict runtime descriptor and build a sandbox URL with
+   `descriptor`, `mode`, `fixture`, and either `pageCode` or `targets`.
 3. Open that URL with `page.goto(...)`.
 4. Verify that the extension UI is mounted.
 5. Exercise the primary user path of the extension, not only the mount smoke.
@@ -576,9 +588,8 @@ Run in this repository:
 yarn workspace @retailcrm/embed-ui-v1-sandbox test:e2e
 ```
 
-The repository examples use fixture extensions that look like real extensions:
-`promoModule` for a widget target and `returnsModule` for a page runner. They
-are loaded from their fixture `index.ts` files. Backend calls are proxied
+The repository examples use fixture extensions that look like real extensions.
+They are loaded from their fixture `index.ts` files through runtime descriptors. Backend calls are proxied
 through the same sandbox `host.httpCall` middleware that the manual sandbox app
 uses.
 
@@ -610,9 +621,9 @@ Variables:
   can start the sandbox server itself. Set it when the sandbox is already
   running, for example `http://v1.embed-ui-sandbox.local` on OrbStack/macOS or
   `http://v1.embed-ui-sandbox.test` on Linux/Traefik.
-- `SANDBOX_EXTENSION_URL`: extension server prefix in the form
-  `%extension-url%/extension/`. Tests append the extension UUID from the fixture
-  descriptor to get the backend endpoint. For this repository's own E2E suite,
+- `SANDBOX_EXTENSION_URL`: extension server base URL. Runtime-descriptor helpers
+  derive a per-fixture `baseUrl` and use relative entrypoint/stylesheet paths.
+  For this repository's own E2E suite,
   an empty value makes Playwright build and start the local fixture extension
   server at `http://127.0.0.1:4175/extension/`; set the variable to override it
   with an external server.
@@ -657,19 +668,19 @@ Playwright covers:
 Widget:
 
 ```text
-%sandbox-url%/?manifestUrl=%extension-url%/extension/%extension-id%&mode=widget&targets=order/card:common.after&fixture=order-basic
+%sandbox-url%/?descriptor=%url-encoded-descriptor-json%&mode=widget&targets=order/card:common.after&fixture=order-basic
 ```
 
 Multiple widgets:
 
 ```text
-%sandbox-url%/?manifestUrl=%extension-url%/extension/%extension-id%&mode=widget&targets=order/card:common.before,order/card:common.after&fixture=order-basic
+%sandbox-url%/?descriptor=%url-encoded-descriptor-json%&mode=widget&targets=order/card:common.before,order/card:common.after&fixture=order-basic
 ```
 
 Page:
 
 ```text
-%sandbox-url%/?manifestUrl=%extension-url%/extension/%extension-id%&mode=page&pageCode=%page-code%&fixture=order-basic
+%sandbox-url%/?descriptor=%url-encoded-descriptor-json%&mode=page&pageCode=%page-code%&fixture=order-basic
 ```
 
 Placeholders:
@@ -677,10 +688,7 @@ Placeholders:
 - `%sandbox-url%`: sandbox shell URL in the current local container/DNS setup.
   Linux Docker usually uses Traefik and `.test`; OrbStack on macOS uses
   `.local` from its domain namespace.
-- `%extension-url%`: external extension server origin without
-  `/extension/%extension-id%`. It can be `http://web-extensions-server.simla.local`,
-  `http://web-extensions-server.simla.test`, `https://ycp-retail.ru`, or any
-  other available address.
-- `%extension-id%`: id/UUID of the JS module or extension record on the
-  extension server. It is not a `pageCode` and not a target.
+- `%extension-url%`: external extension server base URL.
+- `%url-encoded-descriptor-json%`: the complete runtime descriptor serialized
+  as JSON and encoded for a query parameter.
 - `%page-code%`: page code from the extension manifest/runner.
diff --git a/packages/v1-sandbox/package.json b/packages/v1-sandbox/package.json
index e6270bc1..2e06fee4 100644
--- a/packages/v1-sandbox/package.json
+++ b/packages/v1-sandbox/package.json
@@ -148,6 +148,7 @@
     "less": "^4.4.2",
     "nyc": "^18.0.0",
     "playwright": "1.58.2",
+    "tslib": "^2.8.1",
     "typescript": "^5.9.3",
     "vite": "^7.3.5",
     "vite-plugin-dts": "^4.5.4",
diff --git a/packages/v1-sandbox/src/app/App.vue b/packages/v1-sandbox/src/app/App.vue
index 51a283e6..7601c911 100644
--- a/packages/v1-sandbox/src/app/App.vue
+++ b/packages/v1-sandbox/src/app/App.vue
@@ -171,10 +171,14 @@ import { createOrderSandboxController } from '@/scenario/fixtures'
 import { DEFAULT_SANDBOX_TARGETS } from '@/runtime/mount'
 import { getOrderSandboxFixture } from '@/scenario/fixtures'
 import { isContextJsonEqual } from '@/app/contextJson'
-import { isContextName, isWorkerReadyMessage } from '@/app/predicates'
+import { isContextName } from '@/app/predicates'
+import { isSandboxOrderTarget } from '@/scenario/predicates'
+import { isWorkerReadyMessage } from '@/app/predicates'
+import { parseSandboxExtensionDescriptorJson } from '@/scenario/descriptor'
 import { parseSandboxLaunchConfig } from '@/scenario/launch'
 import { resolveSandboxExtensionSource } from '@/scenario/manifest'
 import { SANDBOX_LAUNCH_BRIDGE_GLOBAL_KEY } from '@/automation/bridge'
+import { serializeSandboxExtensionDescriptor } from '@/scenario/descriptor'
 import { updateSandboxLaunchQuery } from '@/scenario/launch'
 import {
   validateContextJsonInput,
@@ -184,20 +188,18 @@ import {
 const searchParams = new URLSearchParams(window.location.search)
 const hasExplicitExtensionUrl = Boolean(searchParams.get('extensionUrl')?.trim())
 const hasExplicitLaunchMode = searchParams.has('mode')
-const launchConfig = parseSandboxLaunchConfig(searchParams, {
-  manifestUrl: createDefaultSandboxManifestUrl(),
-  targets: DEFAULT_SANDBOX_TARGETS,
-})
-const LAUNCH_NOTICE_STORAGE_KEY = 'v1-sandbox:launch-notice'
+const initialLaunch = parseInitialLaunchConfig(searchParams)
+const launchConfig = initialLaunch.config
+const launchConfigError = initialLaunch.error
 const fixture = ref(launchConfig.fixture)
-const manifestUrl = ref(launchConfig.manifestUrl)
+const manifestUrl = ref(formatExtensionSource(launchConfig))
 const mode = ref<SandboxLaunchMode>(launchConfig.mode)
 const pageCode = ref(launchConfig.pageCode)
 const selectedTargets = ref<SandboxOrderTarget[]>([...launchConfig.targets])
 const extensionHttpBaseUrl = ref<string | null>(null)
-const extensionDescriptorUuid = ref<string | undefined>()
+const extensionDescriptorCode = ref<string | undefined>()
 const sandbox = createOrderSandboxController(launchConfig.fixture, {
-  getDescriptorUuid: () => extensionDescriptorUuid.value,
+  getDescriptorUuid: () => extensionDescriptorCode.value,
   getHttpCallBaseUrl: () => extensionHttpBaseUrl.value,
   globalBridge: {},
 })
@@ -214,8 +216,46 @@ const contextApplySucceeded = ref(false)
 const contextHasManualChanges = ref(false)
 const devPanelValidationErrors = ref<DevPanelValidationErrors>({})
 let isAppMounted = false
+let targetsManuallyChanged = false
+
+function parseInitialLaunchConfig(params: URLSearchParams): {
+  config: SandboxLaunchConfig;
+  error: unknown;
+} {
+  const options = {
+    manifestUrl: createDefaultSandboxManifestUrl(),
+    ...(params.has('descriptor') ? {} : { targets: DEFAULT_SANDBOX_TARGETS }),
+  }
 
-const shouldShowOnboarding = computed(() => !launchConfig.manifestUrl && !hasExplicitExtensionUrl)
+  try {
+    return {
+      config: parseSandboxLaunchConfig(params, options),
+      error: null,
+    }
+  } catch (error) {
+    const fallbackParams = new URLSearchParams(params)
+
+    fallbackParams.delete('descriptor')
+    fallbackParams.delete('extensionUrl')
+    fallbackParams.delete('manifestUrl')
+
+    return {
+      config: parseSandboxLaunchConfig(fallbackParams, options),
+      error,
+    }
+  }
+}
+
+function formatExtensionSource(config: SandboxLaunchConfig): string {
+  return config.descriptor
+    ? serializeSandboxExtensionDescriptor(config.descriptor, 2)
+    : config.manifestUrl
+}
+
+const LAUNCH_NOTICE_STORAGE_KEY = 'v1-sandbox:launch-notice'
+
+const shouldShowOnboarding = computed(() => Boolean(launchConfigError)
+  || (!launchConfig.descriptor && !launchConfig.manifestUrl && !hasExplicitExtensionUrl))
 const runModeLabel = computed(() => launchConfig.mode === 'page'
   ? t('app.runMode.page', { pageCode: launchConfig.pageCode })
   : t('app.runMode.widgets', { count: launchConfig.targets.length }))
@@ -227,7 +267,7 @@ const isExtensionConnected = computed(() => runtime.value !== null)
 const launchConfigChanged = computed(() => {
   if (
     fixture.value !== launchConfig.fixture
-    || manifestUrl.value.trim() !== launchConfig.manifestUrl
+    || manifestUrl.value.trim() !== formatExtensionSource(launchConfig)
     || mode.value !== launchConfig.mode
   ) {
     return true
@@ -266,7 +306,7 @@ const mountExtension = async (): Promise<boolean> => {
     if (redirectToInferredPageMode(extensionSource.descriptor)) return false
 
     extensionHttpBaseUrl.value = extensionSource.httpBaseUrl
-    extensionDescriptorUuid.value = extensionSource.descriptor.uuid
+    extensionDescriptorCode.value = extensionSource.descriptor.code
 
     const diagnostic = createLaunchDiagnostic(extensionSource.descriptor)
 
@@ -278,7 +318,7 @@ const mountExtension = async (): Promise<boolean> => {
 
     stylesheet = mountExtensionStylesheet(extensionSource.descriptor.stylesheet)
     const connections = await mountWorkerExtension(
-      extensionSource.descriptor.uuid,
+      extensionSource.descriptor.code,
       extensionSource.entrypoint
     )
 
@@ -357,6 +397,24 @@ const createLaunchDiagnostic = (
     }
   }
 
+  if (
+    launchConfig.mode === 'widget'
+  ) {
+    const missingTargets = launchConfig.targets.filter(
+      target => !descriptor.targets.includes(target)
+    )
+
+    if (missingTargets.length > 0) {
+      return {
+        blocking: true,
+        message: t('app.alerts.missingWidgetTargets.message', {
+          targets: missingTargets.join(', '),
+        }),
+        title: t('app.alerts.missingWidgetTargets.title'),
+      }
+    }
+  }
+
   if (
     launchConfig.mode === 'widget'
     && hasExplicitLaunchMode
@@ -499,6 +557,9 @@ const applyLaunchConfig = async () => {
   devPanelValidationErrors.value = {}
 
   const config: SandboxLaunchConfig = {
+    ...(validationResult.data.descriptor
+      ? { descriptor: validationResult.data.descriptor }
+      : {}),
     extensionUrl: '',
     fixture: validationResult.data.fixture,
     manifestUrl: validationResult.data.manifestUrl,
@@ -682,6 +743,25 @@ const setManifestUrl = (value: string) => {
   clearDevPanelValidationError('manifestUrl')
   clearDevPanelValidationError('pageCode')
 
+  if (
+    !targetsManuallyChanged
+    && value.trim() !== formatExtensionSource(launchConfig)
+    && value.trim().startsWith('{')
+  ) {
+    try {
+      const descriptorTargets = parseSandboxExtensionDescriptorJson(value)
+        .targets
+        .filter(isSandboxOrderTarget)
+
+      if (descriptorTargets.length > 0) {
+        selectedTargets.value = descriptorTargets
+        clearDevPanelValidationError('targets')
+      }
+    } catch {
+      // The regular launch validation reports incomplete or invalid descriptor JSON.
+    }
+  }
+
   const pageCodeError = getPageCodeValidationError(pageCode.value)
 
   if (pageCode.value && pageCodeError) {
@@ -723,6 +803,7 @@ const setPageCode = (value: string) => {
 }
 
 const setTargetSelected = (target: SandboxOrderTarget, checked: boolean) => {
+  targetsManuallyChanged = true
   selectedTargets.value = checked
     ? Array.from(new Set([...selectedTargets.value, target]))
     : selectedTargets.value.filter(item => item !== target)
@@ -740,13 +821,26 @@ const getCurrentLaunchConfig = (): SandboxLaunchConfig => ({
 })
 
 const createLaunchConfigFromInput = (input: SandboxLaunchInput): SandboxLaunchConfig => ({
-  ...getCurrentLaunchConfig(),
-  ...input,
-  targets: input.targets
-    ? [...input.targets]
-    : [...launchConfig.targets],
+  ...createLaunchConfigWithSource(input),
+  targets: input.targets ? [...input.targets] : [...launchConfig.targets],
 })
 
+const createLaunchConfigWithSource = (input: SandboxLaunchInput): SandboxLaunchConfig => {
+  const config: SandboxLaunchConfig = {
+    ...getCurrentLaunchConfig(),
+    ...input,
+  }
+
+  if (input.descriptor) {
+    config.extensionUrl = ''
+    config.manifestUrl = ''
+  } else if (input.extensionUrl !== undefined || input.manifestUrl !== undefined) {
+    delete config.descriptor
+  }
+
+  return config
+}
+
 const createLaunchBridge = (): SandboxLaunchBridge => ({
   createLaunchUrl(config) {
     return updateSandboxLaunchQuery(createLaunchConfigFromInput(config)).toString()
@@ -918,11 +1012,7 @@ const createDevPanelValidationMessages = (): DevPanelValidationMessages => ({
   contextJsonRootObject: t('app.validation.contextJson.rootObject'),
   contextJsonUnknownContext: context => t('app.validation.contextJson.unknownContext', { context }),
   fixture: t('app.validation.fixture'),
-  manifestUrlEndpoint: t('app.validation.manifestUrl.endpoint'),
-  manifestUrlFormat: t('app.validation.manifestUrl.format', {
-    close: '>',
-    open: '<',
-  }),
+  manifestUrlDescriptor: t('app.validation.manifestUrl.descriptor'),
   manifestUrlRequired: t('app.validation.manifestUrl.required'),
   mode: t('app.validation.mode'),
   pageCodeFormat: t('app.validation.pageCodeFormat'),
@@ -966,6 +1056,15 @@ onMounted(() => {
   isAppMounted = true
   showStoredLaunchNotice()
 
+  if (launchConfigError) {
+    showSandboxAlert(
+      t('app.alerts.runtimeError.title'),
+      t('app.alerts.runtimeError.message', { message: getErrorMessage(launchConfigError) })
+    )
+
+    return
+  }
+
   if (!shouldShowOnboarding.value) {
     void mountExtension()
   }
diff --git a/packages/v1-sandbox/src/app/i18n/en-GB.json b/packages/v1-sandbox/src/app/i18n/en-GB.json
index ca80febb..1efa71c3 100644
--- a/packages/v1-sandbox/src/app/i18n/en-GB.json
+++ b/packages/v1-sandbox/src/app/i18n/en-GB.json
@@ -9,6 +9,10 @@
         "message": "The extension does not expose the \"{pageCode}\" page. Available pages: {pages}.",
         "title": "Extension page was not found"
       },
+      "missingWidgetTargets": {
+        "message": "The extension does not expose the selected mount targets: {targets}.",
+        "title": "Extension mount target was not found"
+      },
       "runtimeError": {
         "message": "{message}",
         "title": "Failed to start extension"
@@ -70,9 +74,8 @@
       },
       "fixture": "Choose an existing fixture.",
       "manifestUrl": {
-        "endpoint": "URL must match %extension-url%/extension/%extension-id%.",
-        "format": "Enter an absolute http/https URL. Example: http://127.0.0.1:4175/extension/{open}uuid{close}",
-        "required": "Enter the extension URL."
+        "descriptor": "Enter a valid descriptor with code, baseUrl, entrypoint, stylesheet, pages, and targets. Resource URLs may be relative to an absolute http/https baseUrl.",
+        "required": "Enter the extension descriptor."
       },
       "mode": "Choose a launch mode.",
       "pageCodeFormat": "The page code may contain only Latin letters (A–Z, a–z) and hyphens.",
diff --git a/packages/v1-sandbox/src/app/i18n/es-ES.json b/packages/v1-sandbox/src/app/i18n/es-ES.json
index 4c2b69ae..d656d9c6 100644
--- a/packages/v1-sandbox/src/app/i18n/es-ES.json
+++ b/packages/v1-sandbox/src/app/i18n/es-ES.json
@@ -9,6 +9,10 @@
         "message": "La extensión no expone la página «{pageCode}». Páginas disponibles: {pages}.",
         "title": "No se encontró la página de la extensión"
       },
+      "missingWidgetTargets": {
+        "message": "La extensión no expone los puntos de montaje seleccionados: {targets}.",
+        "title": "No se encontró el punto de montaje de la extensión"
+      },
       "runtimeError": {
         "message": "{message}",
         "title": "No se pudo iniciar la extensión"
@@ -70,9 +74,8 @@
       },
       "fixture": "Seleccione unos datos de prueba existentes.",
       "manifestUrl": {
-        "endpoint": "La URL debe tener el formato %extension-url%/extension/%extension-id%.",
-        "format": "Introduce una URL http/https absoluta. Ejemplo: http://127.0.0.1:4175/extension/{open}uuid{close}",
-        "required": "Introduce la URL de la extensión."
+        "descriptor": "Introduzca un descriptor válido con code, baseUrl, entrypoint, stylesheet, pages y targets. Las URL de recursos pueden ser relativas a un baseUrl http/https absoluto.",
+        "required": "Introduzca el descriptor de la extensión."
       },
       "mode": "Elige un modo de inicio.",
       "pageCodeFormat": "El código de página solo puede contener letras latinas (A–Z, a–z) y guiones.",
diff --git a/packages/v1-sandbox/src/app/i18n/ru-RU.json b/packages/v1-sandbox/src/app/i18n/ru-RU.json
index 5b070f69..9a7e57e8 100644
--- a/packages/v1-sandbox/src/app/i18n/ru-RU.json
+++ b/packages/v1-sandbox/src/app/i18n/ru-RU.json
@@ -9,6 +9,10 @@
         "message": "В расширении нет страницы «{pageCode}». Доступные страницы: {pages}.",
         "title": "Страница расширения не найдена"
       },
+      "missingWidgetTargets": {
+        "message": "Расширение не поддерживает выбранные места встраивания: {targets}.",
+        "title": "Место встраивания расширения не найдено"
+      },
       "runtimeError": {
         "message": "{message}",
         "title": "Не удалось запустить расширение"
@@ -70,9 +74,8 @@
       },
       "fixture": "Выберите существующую фикстуру.",
       "manifestUrl": {
-        "endpoint": "URL должен быть вида %extension-url%/extension/%extension-id%.",
-        "format": "Введите абсолютный http/https URL. Например: http://127.0.0.1:4175/extension/{open}uuid{close}",
-        "required": "Укажите URL расширения."
+        "descriptor": "Введите валидный дескриптор с полями code, baseUrl, entrypoint, stylesheet, pages и targets. Адреса ресурсов могут быть относительными к абсолютному http/https baseUrl.",
+        "required": "Укажите дескриптор расширения."
       },
       "mode": "Выберите режим запуска.",
       "pageCodeFormat": "Код страницы может содержать только латинские буквы (A–Z, a–z) и дефисы.",
diff --git a/packages/v1-sandbox/src/automation/playwright.ts b/packages/v1-sandbox/src/automation/playwright.ts
index accab8cd..ace7c290 100644
--- a/packages/v1-sandbox/src/automation/playwright.ts
+++ b/packages/v1-sandbox/src/automation/playwright.ts
@@ -1,4 +1,4 @@
-import type { SandboxLaunchConfig } from '@/scenario'
+import type { SandboxExtensionDescriptor, SandboxLaunchConfig } from '@/scenario'
 import type { SandboxLaunchInput } from '@/automation/bridge'
 import type { SandboxOrderTarget } from '@/scenario'
 import type { SandboxSnapshot } from '@/core/state'
@@ -6,6 +6,7 @@ import type { SandboxSnapshot } from '@/core/state'
 import { DEFAULT_SANDBOX_TARGET, DefaultSandbox } from '@/scenario'
 import { isSandboxOrderTarget } from '@/scenario'
 import { SANDBOX_LAUNCH_BRIDGE_GLOBAL_KEY } from '@/automation/bridge'
+import { serializeSandboxExtensionDescriptor } from '@/scenario'
 import { updateSandboxLaunchQuery } from '@/scenario'
 
 const DEFAULT_SANDBOX_BASE_URL = 'http://127.0.0.1:4173'
@@ -46,7 +47,8 @@ export type CreateSandboxBrowserPathOptions = {
 }
 
 export type CreateSandboxExtensionPathOptions = CreateSandboxBrowserPathOptions & {
-  extensionUrl: string;
+  descriptor?: SandboxExtensionDescriptor;
+  extensionUrl?: string;
   fixture?: string;
   manifestUrl?: string;
   pageCode?: string;
@@ -88,6 +90,12 @@ export const launchSandboxExtension = async (
             return true
           }
 
+          if (key === 'descriptor') {
+            return url.searchParams.get(key) === serializeSandboxExtensionDescriptor(
+              value as SandboxExtensionDescriptor
+            )
+          }
+
           return url.searchParams.get(key) === String(value)
         })
       }),
@@ -116,9 +124,10 @@ export const createSandboxBrowserPath = (
 export const createSandboxPagePath = (
   options: CreateSandboxExtensionPathOptions
 ): string => createSandboxBrowserPath({
-  extensionUrl: options.extensionUrl,
+  ...(options.descriptor ? { descriptor: options.descriptor } : {}),
+  extensionUrl: options.extensionUrl ?? '',
   fixture: options.fixture ?? DefaultSandbox.Fixture,
-  manifestUrl: options.manifestUrl ?? options.extensionUrl,
+  manifestUrl: options.descriptor ? '' : (options.manifestUrl ?? options.extensionUrl ?? ''),
   mode: 'page',
   pageCode: options.pageCode ?? DefaultSandbox.PageCode,
   targets: normalizeTargets(options.targets),
@@ -128,9 +137,10 @@ export const createSandboxPagePath = (
 export const createSandboxWidgetPath = (
   options: CreateSandboxExtensionPathOptions
 ): string => createSandboxBrowserPath({
-  extensionUrl: options.extensionUrl,
+  ...(options.descriptor ? { descriptor: options.descriptor } : {}),
+  extensionUrl: options.extensionUrl ?? '',
   fixture: options.fixture ?? DefaultSandbox.Fixture,
-  manifestUrl: options.manifestUrl ?? options.extensionUrl,
+  manifestUrl: options.descriptor ? '' : (options.manifestUrl ?? options.extensionUrl ?? ''),
   mode: 'widget',
   pageCode: options.pageCode ?? DefaultSandbox.PageCode,
   targets: normalizeTargets(options.targets),
diff --git a/packages/v1-sandbox/src/components/DevPanel.vue b/packages/v1-sandbox/src/components/DevPanel.vue
index 8ce5118b..e80a3ea0 100644
--- a/packages/v1-sandbox/src/components/DevPanel.vue
+++ b/packages/v1-sandbox/src/components/DevPanel.vue
@@ -4,7 +4,21 @@
             :id="uid + '-dev-panel-controls'"
             :class="$style['dev-panel__card']"
         >
-            <div :class="$style['dev-panel__field']">
+            <div :class="$style['dev-panel__descriptor-switcher']">
+                <UiToggleButton
+                    :aria-pressed="isDescriptorJsonVisible"
+                    :pressed="isDescriptorJsonVisible"
+                    size="xs"
+                    @click="toggleDescriptorView"
+                >
+                    JSON
+                </UiToggleButton>
+            </div>
+
+            <div
+                v-if="isDescriptorJsonVisible"
+                :class="$style['dev-panel__field']"
+            >
                 <div :class="$style['dev-panel__field-heading']">
                     <label
                         :class="$style['dev-panel__field-label']"
@@ -35,25 +49,123 @@
                 <UiTextbox
                     :id="uid + '-dev-panel-manifest-url'"
                     :aria-describedby="getErrorDescribedBy('manifestUrl')"
-                    :class="$style['dev-panel__control']"
+                    :class="[
+                        $style['dev-panel__control'],
+                        $style['dev-panel__json-editor'],
+                    ]"
                     :invalid="Boolean(props.validationErrors.manifestUrl)"
-                    :placeholder="extensionUrlExample"
+                    :placeholder="defaultDescriptor"
                     :value="props.manifestUrl"
-                    type="text"
+                    multiline
+                    rows="8"
                     @update:value="updateManifestUrl"
                 />
+            </div>
 
-                <span
-                    v-if="props.validationErrors.manifestUrl"
-                    :id="getErrorId('manifestUrl')"
-                    :class="$style['dev-panel__error']"
-                    role="alert"
-                >
-                    {{ props.validationErrors.manifestUrl }}
+            <fieldset
+                v-else
+                :aria-describedby="getErrorDescribedBy('manifestUrl')"
+                :aria-invalid="Boolean(props.validationErrors.manifestUrl)"
+                :class="$style['dev-panel__descriptor-fields']"
+            >
+                <legend :class="$style['dev-panel__field-label']">
+                    {{ t('devPanel.descriptorFields') }}
+                </legend>
+
+                <span :class="$style['dev-panel__field-hint']">
+                    {{ t('devPanel.descriptorFieldsHint') }}
                 </span>
-            </div>
 
-            <div :class="$style['dev-panel__field']">
+                <div :class="$style['dev-panel__descriptor-grid']">
+                    <label :class="$style['dev-panel__field']">
+                        <span :class="$style['dev-panel__field-label']">
+                            {{ t('devPanel.code') }}
+                        </span>
+                        <UiTextbox
+                            :class="$style['dev-panel__control']"
+                            :placeholder="t('devPanel.placeholders.code')"
+                            :value="descriptorFields.code"
+                            type="text"
+                            @update:value="updateDescriptorCode"
+                        />
+                    </label>
+
+                    <label :class="$style['dev-panel__field']">
+                        <span :class="$style['dev-panel__field-label']">
+                            {{ t('devPanel.baseUrl') }}
+                        </span>
+                        <UiTextbox
+                            :class="$style['dev-panel__control']"
+                            :placeholder="t('devPanel.placeholders.baseUrl')"
+                            :value="descriptorFields.baseUrl"
+                            type="text"
+                            @update:value="updateDescriptorBaseUrl"
+                        />
+                    </label>
+
+                    <label :class="$style['dev-panel__field']">
+                        <span :class="$style['dev-panel__field-label']">
+                            {{ t('devPanel.entrypoint') }}
+                        </span>
+                        <UiTextbox
+                            :class="$style['dev-panel__control']"
+                            :placeholder="t('devPanel.placeholders.entrypoint')"
+                            :value="descriptorFields.entrypoint"
+                            type="text"
+                            @update:value="updateDescriptorEntrypoint"
+                        />
+                    </label>
+
+                    <div :class="$style['dev-panel__field']">
+                        <div :class="$style['dev-panel__field-heading']">
+                            <label
+                                :class="$style['dev-panel__field-label']"
+                                :for="uid + '-dev-panel-descriptor-stylesheet'"
+                            >
+                                {{ t('devPanel.stylesheet') }}
+                            </label>
+
+                            <UiPopperConnector>
+                                <UiButton
+                                    :aria-label="t('devPanel.tooltips.stylesheet')"
+                                    appearance="tertiary"
+                                    size="xs"
+                                >
+                                    <HelpOutlined aria-hidden="true" />
+                                </UiButton>
+
+                                <UiTooltip>
+                                    <span>{{ t('devPanel.tooltips.stylesheet') }}</span>
+                                </UiTooltip>
+                            </UiPopperConnector>
+                        </div>
+
+                        <UiTextbox
+                            :id="uid + '-dev-panel-descriptor-stylesheet'"
+                            :class="$style['dev-panel__control']"
+                            :placeholder="t('devPanel.placeholders.stylesheet')"
+                            :value="descriptorFields.stylesheet"
+                            type="text"
+                            @update:value="updateDescriptorStylesheet"
+                        />
+                    </div>
+                </div>
+            </fieldset>
+
+            <UiAlert
+                v-if="props.validationErrors.manifestUrl"
+                :id="getErrorId('manifestUrl')"
+                :text="props.validationErrors.manifestUrl"
+                variant="danger"
+                scroll-to-alert
+                fluid
+                small
+            />
+
+            <div
+                v-if="!isDescriptorJsonVisible"
+                :class="$style['dev-panel__field']"
+            >
                 <div :class="$style['dev-panel__field-heading']">
                     <label
                         :id="uid + '-dev-panel-mode-label'"
@@ -84,7 +196,7 @@
                     :labelled-by="uid + '-dev-panel-mode-label'"
                     :options="modeOptions"
                     :value="props.mode"
-                    @update:value="value => props.setMode(value as SandboxLaunchMode)"
+                    @update:value="setDescriptorMode"
                 />
 
                 <span
@@ -98,7 +210,7 @@
             </div>
 
             <div
-                v-if="props.mode === 'page'"
+                v-if="!isDescriptorJsonVisible && props.mode === 'page'"
                 :class="$style['dev-panel__field']"
             >
                 <div :class="$style['dev-panel__field-heading']">
@@ -146,7 +258,7 @@
             </div>
 
             <div
-                v-else
+                v-else-if="!isDescriptorJsonVisible"
                 :class="$style['dev-panel__field']"
             >
                 <div :class="$style['dev-panel__field-heading']">
@@ -308,6 +420,7 @@
                     :class="[
                         $style['dev-panel__control'],
                         $style['dev-panel__context-editor'],
+                        $style['dev-panel__json-editor'],
                     ]"
                     :input-attributes="{
                         spellcheck: false,
@@ -386,6 +499,7 @@
                 v-if="props.contextApplySucceeded"
                 :text="t('devPanel.contextApplied')"
                 variant="success"
+                scrol-to-alert
                 closable
                 small
             />
@@ -397,7 +511,7 @@
 import type { DevPanelField, DevPanelValidationErrors } from '@/scenario/validation'
 import type { SandboxLaunchMode, SandboxOrderTarget } from '@/scenario/types'
 
-import { computed } from 'vue'
+import { computed, ref } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { useId } from 'vue'
 
@@ -406,6 +520,7 @@ import {
   UiButton,
   UiPopperConnector,
   UiTextbox,
+  UiToggleButton,
   UiTooltip,
 } from '@retailcrm/embed-ui-v1-components/host'
 
@@ -414,8 +529,10 @@ import VSelect from '@/components/VSelect.vue'
 import HelpOutlined from '@retailcrm/embed-ui-v1-components/assets/sprites/actions/help-outlined.svg'
 
 import { getOrderSandboxFixturePresentations } from '@/app/fixturePresentation'
+import { isSandboxOrderTarget } from '@/scenario/predicates'
 import { isValidSandboxPageCode } from '@/scenario/validation'
 import { ORDER_SANDBOX_SLOTS } from '@/scenario/targets'
+import { parseSandboxExtensionDescriptorJson } from '@/scenario/descriptor'
 
 const props = defineProps<{
   activeFixture: string;
@@ -449,7 +566,15 @@ const props = defineProps<{
 const { t } = useI18n()
 const { t: tGlobal } = useI18n({ useScope: 'global' })
 const uid = useId()
-const extensionUrlExample = 'http://127.0.0.1:4175/extension/<uuid>'
+const isDescriptorJsonVisible = ref(false)
+const defaultDescriptor = JSON.stringify({
+  code: 'promoModule',
+  baseUrl: 'http://web-extensions-server.simla.local',
+  entrypoint: '/extension/8ebe1617-d609-43e4-b35a-fbfae011eee3/script',
+  stylesheet: '/extension/8ebe1617-d609-43e4-b35a-fbfae011eee3/stylesheet',
+  targets: [],
+  pages: ['settings'],
+}, null, 2)
 const modeOptions = computed<Array<{
   label: string;
   value: SandboxLaunchMode;
@@ -483,6 +608,100 @@ const targetOptions = ORDER_SANDBOX_SLOTS.map(slot => ({
   label: slot.target,
   value: slot.target,
 }))
+type EditableDescriptorField = 'baseUrl' | 'code' | 'entrypoint' | 'stylesheet'
+
+type DescriptorFields = Record<EditableDescriptorField, string>
+
+const emptyDescriptorFields = (): DescriptorFields => ({
+  baseUrl: '',
+  code: '',
+  entrypoint: '',
+  stylesheet: '',
+})
+
+const readDescriptorDraft = (): Record<string, unknown> | null => {
+  const value = props.manifestUrl.trim()
+
+  if (!value.startsWith('{')) return null
+
+  try {
+    const parsed = JSON.parse(value) as unknown
+
+    return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : null
+  } catch {
+    return null
+  }
+}
+
+const descriptorFields = computed<DescriptorFields>(() => {
+  const descriptor = readDescriptorDraft()
+  if (!descriptor) return emptyDescriptorFields()
+
+  return {
+    baseUrl: typeof descriptor.baseUrl === 'string' ? descriptor.baseUrl : '',
+    code: typeof descriptor.code === 'string' ? descriptor.code : '',
+    entrypoint: typeof descriptor.entrypoint === 'string' ? descriptor.entrypoint : '',
+    stylesheet: typeof descriptor.stylesheet === 'string' ? descriptor.stylesheet : '',
+  }
+})
+
+const updateDescriptorField = (
+  field: EditableDescriptorField,
+  value: string | number
+): void => {
+  const descriptor = readDescriptorDraft() ?? {
+    baseUrl: '',
+    code: '',
+    entrypoint: '',
+    pages: props.mode === 'page' && props.pageCode ? [props.pageCode] : [],
+    stylesheet: null,
+    targets: [...props.selectedTargets],
+  }
+
+  descriptor[field] = field === 'stylesheet' && !String(value).trim()
+    ? null
+    : String(value)
+
+  props.setManifestUrl(JSON.stringify(descriptor, null, 2))
+}
+
+const updateDescriptorBaseUrl = (value: string | number) => updateDescriptorField('baseUrl', value)
+const updateDescriptorCode = (value: string | number) => updateDescriptorField('code', value)
+const updateDescriptorEntrypoint = (value: string | number) => updateDescriptorField('entrypoint', value)
+const updateDescriptorStylesheet = (value: string | number) => updateDescriptorField('stylesheet', value)
+
+const updateDescriptorCapabilities = (
+  pages: string[],
+  targets: SandboxOrderTarget[]
+): void => {
+  const descriptor = readDescriptorDraft()
+  if (!descriptor) return
+
+  descriptor.pages = pages
+  descriptor.targets = targets
+  props.setManifestUrl(JSON.stringify(descriptor, null, 2))
+}
+
+const setDescriptorMode = (value: string | string[]) => {
+  const mode = value as SandboxLaunchMode
+
+  props.setMode(mode)
+  updateDescriptorCapabilities(
+    [],
+    mode === 'widget' ? [...props.selectedTargets] : []
+  )
+}
+
+const toggleDescriptorView = () => {
+  isDescriptorJsonVisible.value = !isDescriptorJsonVisible.value
+
+  if (isDescriptorJsonVisible.value) {
+    syncLaunchSelectionFromDescriptor(props.manifestUrl)
+  }
+}
+
 const isApplyDisabled = computed(() => {
   if (!props.manifestUrl.trim() || !props.fixture || !props.mode) return true
 
@@ -499,15 +718,62 @@ const isApplyContextDisabled = computed(() =>
 )
 
 const updateManifestUrl = (value: string | number) => {
-  props.setManifestUrl(String(value))
+  const descriptorJson = String(value)
+
+  props.setManifestUrl(descriptorJson)
+  syncLaunchSelectionFromDescriptor(descriptorJson)
+}
+
+const syncLaunchSelectionFromDescriptor = (value: string): void => {
+  try {
+    const descriptor = parseSandboxExtensionDescriptorJson(value)
+    const descriptorTargets = descriptor.targets.filter(isSandboxOrderTarget)
+    const hasPages = descriptor.pages.length > 0
+    const hasTargets = descriptorTargets.length > 0
+    const nextMode = hasPages && !hasTargets
+      ? 'page'
+      : hasTargets && !hasPages
+        ? 'widget'
+        : props.mode
+
+    if (nextMode === 'page') {
+      const canKeepPageCode = props.mode === 'page'
+        && descriptor.pages.includes(props.pageCode)
+      const nextPageCode = canKeepPageCode
+        ? props.pageCode
+        : descriptor.pages[0]
+
+      if (props.mode !== 'page') props.setMode('page')
+      if (nextPageCode && (props.mode !== 'page' || nextPageCode !== props.pageCode)) {
+        props.setPageCode(nextPageCode)
+      }
+
+      return
+    }
+
+    if (props.mode !== 'widget') props.setMode('widget')
+
+    ORDER_SANDBOX_SLOTS.forEach(({ target }) => {
+      const selected = descriptorTargets.includes(target)
+
+      if (props.selectedTargets.includes(target) !== selected) {
+        props.setTargetSelected(target, selected)
+      }
+    })
+  } catch {
+    // Launch validation reports incomplete or invalid descriptor JSON.
+  }
 }
 
 const updatePageCode = (value: string | number) => {
-  props.setPageCode(String(value))
+  const pageCode = String(value)
+
+  props.setPageCode(pageCode)
+  updateDescriptorCapabilities(pageCode ? [pageCode] : [], [])
 }
 
 const updateTargets = (value: string | string[]) => {
-  const targets = Array.isArray(value) ? value : []
+  const targets = (Array.isArray(value) ? value : []).filter(isSandboxOrderTarget)
 
   ORDER_SANDBOX_SLOTS.forEach(({ target }) => {
     const selected = targets.includes(target)
@@ -516,6 +782,8 @@ const updateTargets = (value: string | string[]) => {
       props.setTargetSelected(target, selected)
     }
   })
+
+  updateDescriptorCapabilities([], targets)
 }
 
 const getErrorId = (field: DevPanelField): string => `${uid}-dev-panel-${field}-error`
@@ -545,8 +813,13 @@ const getErrorDescribedBy = (field: DevPanelField): string | undefined =>
             "fixture": "Original fixture context"
         },
         "currentRunFixture": "Current run",
-        "extensionHint": "Enter the full extension URL using the example shown in the field. Replace the UUID with the value from extensionrc.json and make sure the resulting page opens in the browser.",
-        "extensionUrl": "Manifest / extension URL",
+        "baseUrl": "Base URL",
+        "code": "Module code",
+        "descriptorFields": "Descriptor fields",
+        "descriptorFieldsHint": "Fill in the descriptor fields or switch to JSON. Both representations stay synchronized.",
+        "entrypoint": "Entrypoint",
+        "extensionHint": "Paste the complete descriptor configuration in JSON format.",
+        "extensionUrl": "Descriptor JSON",
         "fixture": "Selected fixture",
         "fixturePending": "The “{fixture}” fixture has not been applied yet. Use Apply to start it.",
         "mode": "Mode",
@@ -556,14 +829,22 @@ const getErrorDescribedBy = (field: DevPanelField): string | undefined =>
         },
         "pageCode": "Page code",
         "pageCodePlaceholder": "Enter page code",
+        "placeholders": {
+            "baseUrl": "Enter extension URL",
+            "code": "Enter module code",
+            "entrypoint": "Enter entrypoint",
+            "stylesheet": "Enter stylesheet"
+        },
+        "stylesheet": "Stylesheet",
         "targets": "Widget mount targets",
         "targetsHint": "Targets are CRM slots where widget runners are mounted. They are used only in widget mode.",
         "targetsPlaceholder": "Select mount targets",
         "tooltips": {
             "contextJson": "Context used by the current connected extension. It is independent from the fixture selected for the next launch.",
-            "extensionUrl": "The extension URL can point to any external application that serves the extension, for example http://web-extensions-server.simla.local/extension/.",
+            "extensionUrl": "A descriptor contains code, baseUrl, entrypoint, stylesheet, pages and targets. Entrypoint and stylesheet may be relative to baseUrl.",
             "mode": "Widgets mount into selected CRM targets. Page mounts a page runner by page code.",
             "pageCode": "Use the code from the extension pages registration, not the extension id. Only Latin letters (A–Z, a–z) and hyphens are allowed.",
+            "stylesheet": "Leave this field empty if the extension has no CSS. Otherwise, enter the path to the stylesheet.",
             "targets": "Targets are widget mount slots. Select the same targets that the extension registers."
         }
     }
@@ -591,8 +872,13 @@ const getErrorDescribedBy = (field: DevPanelField): string | undefined =>
             "fixture": "Contexto original de los datos de prueba"
         },
         "currentRunFixture": "Ejecución actual",
-        "extensionHint": "Introduzca la URL completa utilizando el ejemplo del campo. Sustituya el UUID por el valor de extensionrc.json y compruebe que la página resultante se abre en el navegador.",
-        "extensionUrl": "Manifiesto / URL de la extensión",
+        "baseUrl": "URL base",
+        "code": "Código del módulo",
+        "descriptorFields": "Campos del descriptor",
+        "descriptorFieldsHint": "Complete los campos del descriptor o cambie a JSON. Ambas representaciones permanecen sincronizadas.",
+        "entrypoint": "Entrypoint",
+        "extensionHint": "Pegue la configuración completa del descriptor en formato JSON.",
+        "extensionUrl": "JSON del descriptor",
         "fixture": "Datos de prueba seleccionados",
         "fixturePending": "Los datos de prueba «{fixture}» aún no se han aplicado. Utilice «Aplicar» para iniciarlos.",
         "mode": "Modo",
@@ -602,14 +888,22 @@ const getErrorDescribedBy = (field: DevPanelField): string | undefined =>
         },
         "pageCode": "Código de página",
         "pageCodePlaceholder": "Introduzca el código de la página",
+        "placeholders": {
+            "baseUrl": "Introduzca la URL de la extensión",
+            "code": "Introduzca el código del módulo",
+            "entrypoint": "Introduzca el entrypoint",
+            "stylesheet": "Introduzca el stylesheet"
+        },
+        "stylesheet": "Hoja de estilos",
         "targets": "Puntos de montaje de widgets",
         "targetsHint": "Los puntos de montaje son áreas de la interfaz de CRM donde se ejecutan los widgets. Solo se utilizan en el modo «Widgets».",
         "targetsPlaceholder": "Seleccione los puntos de montaje",
         "tooltips": {
             "contextJson": "Contexto utilizado por la extensión conectada actualmente. Es independiente de los datos de prueba seleccionados para el siguiente inicio.",
-            "extensionUrl": "La URL de la extensión puede apuntar a cualquier aplicación externa que sirva la extensión, por ejemplo http://web-extensions-server.simla.local/extension/.",
+            "extensionUrl": "El descriptor contiene code, baseUrl, entrypoint, stylesheet, pages y targets. Entrypoint y stylesheet pueden ser relativos a baseUrl.",
             "mode": "En el modo «Widgets», los widgets se añaden a los puntos de montaje seleccionados. En el modo «Página», se ejecuta una página mediante su código.",
             "pageCode": "Utilice el valor code del registro pages, no el UUID de la extensión. Solo se permiten letras latinas (A–Z, a–z) y guiones.",
+            "stylesheet": "Deje este campo vacío si la extensión no tiene CSS. Si tiene estilos, introduzca la ruta del stylesheet.",
             "targets": "Los puntos de montaje son áreas de la interfaz de CRM para widgets. Seleccione los mismos puntos que registra la extensión."
         }
     }
@@ -637,8 +931,13 @@ const getErrorDescribedBy = (field: DevPanelField): string | undefined =>
             "fixture": "Исходный контекст фикстуры"
         },
         "currentRunFixture": "Текущий запуск",
-        "extensionHint": "Укажите полный URL расширения по примеру в поле. Замените UUID на значение из extensionrc.json и убедитесь, что получившаяся страница открывается в браузере.",
-        "extensionUrl": "Манифест / URL расширения",
+        "baseUrl": "Базовый URL",
+        "code": "Код модуля",
+        "descriptorFields": "Поля дескриптора",
+        "descriptorFieldsHint": "Заполните поля дескриптора или переключитесь на JSON. Оба представления синхронизированы.",
+        "entrypoint": "Entrypoint",
+        "extensionHint": "Вставьте конфигурацию дескриптора целиком в формате JSON.",
+        "extensionUrl": "JSON дескриптора",
         "fixture": "Выбранная фикстура",
         "fixturePending": "Фикстура «{fixture}» ещё не применена. Запустите её кнопкой «Применить».",
         "mode": "Режим",
@@ -648,14 +947,22 @@ const getErrorDescribedBy = (field: DevPanelField): string | undefined =>
         },
         "pageCode": "Код страницы",
         "pageCodePlaceholder": "Введите код страницы",
+        "placeholders": {
+            "baseUrl": "Введите URL расширения",
+            "code": "Введите код модуля",
+            "entrypoint": "Введите entrypoint",
+            "stylesheet": "Введите stylesheet"
+        },
+        "stylesheet": "Stylesheet",
         "targets": "Места встраивания виджетов",
         "targetsHint": "Места встраивания — это области интерфейса CRM, в которых запускаются виджеты. Они используются только в режиме «Виджеты».",
         "targetsPlaceholder": "Выберите места встраивания",
         "tooltips": {
             "contextJson": "Контекст текущего подключённого расширения. Он не зависит от фикстуры, выбранной для следующего запуска.",
-            "extensionUrl": "URL расширения может указывать на любое стороннее приложение, которое отдаёт расширение, например http://web-extensions-server.simla.local/extension/.",
+            "extensionUrl": "Дескриптор содержит code, baseUrl, entrypoint, stylesheet, pages и targets. Entrypoint и stylesheet могут быть относительными к baseUrl.",
             "mode": "В режиме «Виджеты» виджеты добавляются в выбранные места встраивания. В режиме «Страница» запускается страница по её коду.",
             "pageCode": "Укажите значение code из массива pages в дескрипторе, а не UUID расширения. Допустимы только латинские буквы (A–Z, a–z) и дефисы.",
+            "stylesheet": "Оставьте поле пустым, если у расширения нет CSS. Если стили есть, укажите путь к stylesheet.",
             "targets": "Места встраивания — это области интерфейса CRM для виджетов. Выберите те же места, которые зарегистрированы расширением."
         }
     }
@@ -684,6 +991,26 @@ const getErrorDescribedBy = (field: DevPanelField): string | undefined =>
         padding: 18px;
     }
 
+    &__descriptor-fields {
+        border: 0;
+        display: grid;
+        gap: @spacing-xs;
+        margin: 0;
+        min-width: 0;
+        padding: 0;
+    }
+
+    &__descriptor-switcher {
+        display: flex;
+        justify-content: flex-end;
+    }
+
+    &__descriptor-grid {
+        display: grid;
+        gap: @spacing-s;
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+    }
+
     &__field-heading {
         align-items: center;
         display: flex;
@@ -726,6 +1053,12 @@ const getErrorDescribedBy = (field: DevPanelField): string | undefined =>
         }
     }
 
+    &__json-editor {
+        :global(textarea) {
+            font-size: 12px;
+        }
+    }
+
     &__context-actions {
         display: flex;
         flex-wrap: wrap;
diff --git a/packages/v1-sandbox/src/components/ExtensionOnboarding.vue b/packages/v1-sandbox/src/components/ExtensionOnboarding.vue
index fb251b28..76168a03 100644
--- a/packages/v1-sandbox/src/components/ExtensionOnboarding.vue
+++ b/packages/v1-sandbox/src/components/ExtensionOnboarding.vue
@@ -22,16 +22,11 @@
                 {{ t('extensionOnboarding.description') }}
             </p>
 
-            <ol :class="$style['extension-onboarding__steps']">
-                <li>{{ t('extensionOnboarding.steps.extensionServer') }}</li>
+            <div :class="$style['extension-onboarding__descriptor']">
+                <span>Формат передаваемого дескриптора </span>
 
-                <li>{{ t('extensionOnboarding.steps.sandboxServer') }}</li>
-
-                <li>
-                    {{ t('extensionOnboarding.steps.extensionUrl') }}
-                    <code>{{ extensionUrlExample }}</code>
-                </li>
-            </ol>
+                <pre :class="$style['extension-onboarding__example']"><code>{{ descriptorExample }}</code></pre>
+            </div>
 
             <p :class="$style['extension-onboarding__note']">
                 {{ t('extensionOnboarding.note') }}
@@ -41,46 +36,6 @@
                 {{ t('extensionOnboarding.modeNote') }}
             </p>
 
-            <UiCollapseBox v-model:expanded="isUrlTemplateExpanded">
-                <template #icon>
-                    <IconSettingsOutlined />
-                </template>
-
-                <template #title>
-                    {{ t('extensionOnboarding.example.title') }}
-                </template>
-
-                <template #body-content>
-                    <div :class="$style['extension-onboarding__example']">
-                        <p>{{ t('extensionOnboarding.example.description') }}</p>
-
-                        <code>{{ sandboxUrlTemplate }}</code>
-
-                        <dl :class="$style['extension-onboarding__placeholders']">
-                            <div>
-                                <dt><code>%sandbox-url%</code></dt>
-                                <dd>{{ t('extensionOnboarding.example.sandboxUrl') }}</dd>
-                            </div>
-
-                            <div>
-                                <dt><code>%extension-url%</code></dt>
-                                <dd>{{ t('extensionOnboarding.example.extensionUrl') }}</dd>
-                            </div>
-
-                            <div>
-                                <dt><code>%extension-id%</code></dt>
-                                <dd>{{ t('extensionOnboarding.example.extensionId') }}</dd>
-                            </div>
-                        </dl>
-
-                        <p>
-                            {{ t('extensionOnboarding.example.completeExtensionUrl') }}
-                            <code>{{ extensionUrlExample }}</code>
-                        </p>
-                    </div>
-                </template>
-            </UiCollapseBox>
-
             <UiButton
                 appearance="primary"
                 size="sm"
@@ -93,13 +48,10 @@
 </template>
 
 <script setup lang="ts">
-import { ref } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { useId } from 'vue'
 
-import { UiButton, UiCollapseBox } from '@retailcrm/embed-ui-v1-components/host'
-
-import IconSettingsOutlined from '@retailcrm/embed-ui-v1-components/assets/sprites/ui/settings-outlined.svg'
+import { UiButton } from '@retailcrm/embed-ui-v1-components/host'
 
 const props = defineProps<{
   openDevPanel(): void;
@@ -108,9 +60,14 @@ const props = defineProps<{
 const { t } = useI18n()
 
 const uid = useId()
-const isUrlTemplateExpanded = ref(false)
-const extensionUrlExample = 'http://127.0.0.1:4175/extension/<uuid>'
-const sandboxUrlTemplate = '%sandbox-url%/?manifestUrl=%extension-url%/extension/%extension-id%&targets=order/card:common.after&fixture=order-basic'
+const descriptorExample = JSON.stringify({
+  code: 'promoModule',
+  baseUrl: 'http://web-extensions-server.simla.local',
+  entrypoint: '/extension/8ebe1617-d609-43e4-b35a-fbfae011eee3/script',
+  stylesheet: '/extension/8ebe1617-d609-43e4-b35a-fbfae011eee3/stylesheet',
+  targets: [],
+  pages: ['settings'],
+}, null, 2)
 
 const openDevPanel = () => props.openDevPanel()
 </script>
@@ -119,26 +76,14 @@ const openDevPanel = () => props.openDevPanel()
 {
     "extensionOnboarding": {
         "actions": {
-            "openSandbox": "Open sandbox controls"
+            "openSandbox": "Open developer panel"
         },
-        "description": "Use the sandbox to check JS module pages and widgets locally before installing the module in RetailCRM.",
+        "description": "Use the sandbox to test JS module pages and widgets locally before installing the module in RetailCRM. Before adding the extension to the sandbox, make sure it is running.",
         "eyebrow": "Local development",
-        "example": {
-            "completeExtensionUrl": "Complete extension URL example:",
-            "description": "This is a template, not a ready-to-use link. Replace each placeholder with the value for your local environment.",
-            "extensionId": "The extension UUID.",
-            "extensionUrl": "The base URL of the extension server, for example http://127.0.0.1:4175.",
-            "sandboxUrl": "The sandbox URL, for example http://127.0.0.1:4173.",
-            "title": "Launch URL template"
-        },
-        "modeNote": "Then choose a mode: Widgets or Page.",
+        "modeNote": "When using the individual fields, then choose a mode: Widgets or Page.",
         "note": "Only two running processes are required: the extension server and the sandbox. You do not need to start an additional server.",
-        "steps": {
-            "extensionServer": "Start the extension server.",
-            "extensionUrl": "Open sandbox controls and enter the extension URL:",
-            "sandboxServer": "Start the sandbox."
-        },
-        "title": "Connect an external extension"
+        "title": "Connect an external extension",
+        "descriptor": "Runtime descriptor format"
     }
 }
 </i18n>
@@ -147,26 +92,14 @@ const openDevPanel = () => props.openDevPanel()
 {
     "extensionOnboarding": {
         "actions": {
-            "openSandbox": "Abrir controles de sandbox"
+            "openSandbox": "Abrir el panel de desarrollo"
         },
-        "description": "Utilice la sandbox para comprobar localmente las páginas y los widgets del módulo JS antes de instalarlo en RetailCRM.",
+        "description": "Utilice la sandbox para probar localmente las páginas y los widgets del módulo JS antes de instalarlo en RetailCRM. Antes de añadir la extensión a la sandbox, asegúrese de que esté en ejecución.",
         "eyebrow": "Desarrollo local",
-        "example": {
-            "completeExtensionUrl": "Ejemplo de URL completa de la extensión:",
-            "description": "Esta es una plantilla, no un enlace listo para usar. Sustituya cada placeholder por el valor de su entorno local.",
-            "extensionId": "El UUID de la extensión.",
-            "extensionUrl": "La URL base del servidor de la extensión, por ejemplo http://127.0.0.1:4175.",
-            "sandboxUrl": "La URL de la sandbox, por ejemplo http://127.0.0.1:4173.",
-            "title": "Plantilla de URL de inicio"
-        },
-        "modeNote": "Después elija un modo: Widgets o Página.",
+        "modeNote": "Si utiliza los campos individuales, elija después un modo: Widgets o Página.",
         "note": "Solo se necesitan dos procesos en ejecución: el servidor de la extensión y la sandbox. No hace falta iniciar un servidor adicional.",
-        "steps": {
-            "extensionServer": "Inicie el servidor de la extensión.",
-            "extensionUrl": "Abra los controles de sandbox e indique la URL de la extensión:",
-            "sandboxServer": "Inicie la sandbox."
-        },
-        "title": "Conectar una extensión externa"
+        "title": "Conectar una extensión externa",
+        "descriptor": "Formato del descriptor de ejecución"
     }
 }
 </i18n>
@@ -175,26 +108,14 @@ const openDevPanel = () => props.openDevPanel()
 {
     "extensionOnboarding": {
         "actions": {
-            "openSandbox": "Открыть песочницу"
+            "openSandbox": "Открыть дев-панель"
         },
-        "description": "Используйте песочницу, чтобы локально проверить страницы и виджеты JS-модуля до его установки в RetailCRM.",
+        "description": "Используйте песочницу, чтобы локально проверить страницы и виджеты JS-модуля до его установки в RetailCRM. Перед тем как добавлять расширение в песочницу, убедитесь, что расширение запущено",
         "eyebrow": "Локальная разработка",
-        "example": {
-            "completeExtensionUrl": "Пример полного URL расширения:",
-            "description": "Это шаблон, а не готовая ссылка. Замените каждое обозначение значением из своего локального окружения.",
-            "extensionId": "UUID расширения.",
-            "extensionUrl": "Базовый URL сервера расширения, например http://127.0.0.1:4175.",
-            "sandboxUrl": "URL песочницы, например http://127.0.0.1:4173.",
-            "title": "Шаблон URL запуска"
-        },
-        "modeNote": "Затем выберите режим: Виджеты или Страница.",
+        "modeNote": "При заполнении отдельных полей затем выберите режим: Виджеты или Страница.",
         "note": "Для работы нужны только два запущенных процесса: сервер расширения и песочница. Дополнительный сервер запускать не требуется.",
-        "steps": {
-            "extensionServer": "Запустите сервер расширения.",
-            "extensionUrl": "Откройте управление песочницей и укажите URL расширения:",
-            "sandboxServer": "Запустите песочницу."
-        },
-        "title": "Подключите внешнее расширение"
+        "title": "Подключите внешнее расширение",
+        "descriptor": "Формат передаваемого дескриптора"
     }
 }
 </i18n>
@@ -244,18 +165,19 @@ const openDevPanel = () => props.openDevPanel()
         margin: 0;
     }
 
-    &__steps {
-        color: @black-500;
-        display: grid;
-        font-size: 14px;
-        gap: @spacing-xs;
-        margin: 0;
-        padding-left: 18px;
+    &__descriptor {
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+    }
 
-        code {
-            color: @blue-500;
-            overflow-wrap: anywhere;
-        }
+    &__example {
+        background: @grey-400;
+        border-radius: @border-radius-md;
+        margin: 0;
+        overflow: auto;
+        padding: @spacing-s;
+        white-space: pre;
     }
 
     &__note,
diff --git a/packages/v1-sandbox/src/scenario/descriptor.ts b/packages/v1-sandbox/src/scenario/descriptor.ts
new file mode 100644
index 00000000..403e43b9
--- /dev/null
+++ b/packages/v1-sandbox/src/scenario/descriptor.ts
@@ -0,0 +1,98 @@
+import type { SandboxExtensionDescriptor } from '@/scenario/types'
+
+import { z } from 'zod'
+
+const nonEmptyString = z.string().transform(value => value.trim()).pipe(z.string().min(1))
+const absoluteHttpUrl = nonEmptyString.refine((value) => {
+  try {
+    const url = new URL(value)
+
+    return url.protocol === 'http:' || url.protocol === 'https:'
+  } catch {
+    return false
+  }
+})
+
+const sandboxExtensionDescriptorSchema = z.object({
+  code: nonEmptyString,
+  baseUrl: absoluteHttpUrl,
+  entrypoint: nonEmptyString,
+  stylesheet: z.union([nonEmptyString, z.null()]),
+  pages: z.array(nonEmptyString),
+  targets: z.array(nonEmptyString),
+}).strict().superRefine((descriptor, context) => {
+  validateResourceUrl(descriptor.entrypoint, descriptor.baseUrl, ['entrypoint'], context)
+
+  if (descriptor.stylesheet) {
+    validateResourceUrl(descriptor.stylesheet, descriptor.baseUrl, ['stylesheet'], context)
+  }
+})
+
+const validateResourceUrl = (
+  value: string,
+  baseUrl: string,
+  path: string[],
+  context: z.RefinementCtx
+): void => {
+  if (resolvesToHttpUrl(value, baseUrl)) return
+
+  context.addIssue({
+    code: z.ZodIssueCode.custom,
+    message: 'Resource URL must resolve to an absolute http/https URL.',
+    path,
+  })
+}
+
+const resolvesToHttpUrl = (value: string, baseUrl: string): boolean => {
+  try {
+    const url = new URL(value, normalizeSandboxExtensionBaseUrl(baseUrl))
+
+    return url.protocol === 'http:' || url.protocol === 'https:'
+  } catch {
+    return false
+  }
+}
+
+export const normalizeSandboxExtensionBaseUrl = (value: string): string => {
+  const url = new URL(value)
+
+  if (!url.pathname.endsWith('/')) url.pathname = `${url.pathname}/`
+
+  return url.href
+}
+
+export const resolveSandboxExtensionResourceUrl = (
+  value: string,
+  baseUrl: string
+): URL => new URL(value, normalizeSandboxExtensionBaseUrl(baseUrl))
+
+export const parseSandboxExtensionDescriptor = (
+  value: unknown
+): SandboxExtensionDescriptor => {
+  const result = sandboxExtensionDescriptorSchema.safeParse(value)
+
+  if (!result.success) {
+    throw new Error('[sandbox:descriptor] Invalid extension descriptor.')
+  }
+
+  return result.data as SandboxExtensionDescriptor
+}
+
+export const parseSandboxExtensionDescriptorJson = (
+  value: string
+): SandboxExtensionDescriptor => {
+  let parsed: unknown
+
+  try {
+    parsed = JSON.parse(value) as unknown
+  } catch {
+    throw new Error('[sandbox:descriptor] Invalid extension descriptor JSON.')
+  }
+
+  return parseSandboxExtensionDescriptor(parsed)
+}
+
+export const serializeSandboxExtensionDescriptor = (
+  descriptor: SandboxExtensionDescriptor,
+  space?: number
+): string => JSON.stringify(descriptor, null, space)
diff --git a/packages/v1-sandbox/src/scenario/index.ts b/packages/v1-sandbox/src/scenario/index.ts
index 983d8aee..3c3df270 100644
--- a/packages/v1-sandbox/src/scenario/index.ts
+++ b/packages/v1-sandbox/src/scenario/index.ts
@@ -1,4 +1,5 @@
 export type * from './types'
+export * from './descriptor'
 export * from './defaults'
 export * from './fixtures'
 export * from './http'
diff --git a/packages/v1-sandbox/src/scenario/launch.ts b/packages/v1-sandbox/src/scenario/launch.ts
index e8bed025..939cea4b 100644
--- a/packages/v1-sandbox/src/scenario/launch.ts
+++ b/packages/v1-sandbox/src/scenario/launch.ts
@@ -8,6 +8,10 @@ import type {
 import { DEFAULT_SANDBOX_TARGET } from '@/scenario/targets'
 import { DefaultSandbox } from '@/scenario/defaults'
 import { isSandboxOrderTarget } from '@/scenario/predicates'
+import {
+  parseSandboxExtensionDescriptorJson,
+  serializeSandboxExtensionDescriptor,
+} from '@/scenario/descriptor'
 
 export type {
   ParseSandboxLaunchConfigOptions,
@@ -21,12 +25,16 @@ export const parseSandboxLaunchConfig = (
   params: URLSearchParams,
   options: ParseSandboxLaunchConfigOptions = {}
 ): SandboxLaunchConfig => {
-  const target = params.get('target') ?? options.targets?.[0] ?? DEFAULT_SANDBOX_TARGET
-  const targets = parseTargetsParam(params.get('targets')) ?? options.targets ?? [
-    isSandboxOrderTarget(target) ? target : DEFAULT_SANDBOX_TARGET,
-  ]
+  const descriptor = parseDescriptorParam(params.get('descriptor')) ?? options.descriptor
+  const descriptorTargets = descriptor?.targets.filter(isSandboxOrderTarget) ?? []
+  const target = params.get('target') ?? options.targets?.[0]
+  const targets = parseTargetsParam(params.get('targets'))
+    ?? options.targets
+    ?? (target && isSandboxOrderTarget(target) ? [target] : null)
+    ?? (descriptorTargets.length > 0 ? descriptorTargets : [DEFAULT_SANDBOX_TARGET])
 
   return {
+    ...(descriptor ? { descriptor } : {}),
     extensionUrl: readStringParam(
       params,
       'extensionUrl',
@@ -63,9 +71,17 @@ export const updateSandboxLaunchQuery = (
 ): URL => {
   const url = new URL(base)
 
-  url.searchParams.set('extensionUrl', config.extensionUrl)
+  if (config.descriptor) {
+    url.searchParams.set('descriptor', serializeSandboxExtensionDescriptor(config.descriptor))
+    url.searchParams.delete('extensionUrl')
+    url.searchParams.delete('manifestUrl')
+  } else {
+    url.searchParams.delete('descriptor')
+    url.searchParams.set('extensionUrl', config.extensionUrl)
+  }
+
   url.searchParams.set('fixture', config.fixture)
-  url.searchParams.set('manifestUrl', config.manifestUrl)
+  if (!config.descriptor) url.searchParams.set('manifestUrl', config.manifestUrl)
   url.searchParams.set('mode', config.mode)
   url.searchParams.set('pageCode', config.pageCode)
   url.searchParams.set('target', config.targets[0] ?? DEFAULT_SANDBOX_TARGET)
@@ -75,6 +91,12 @@ export const updateSandboxLaunchQuery = (
   return url
 }
 
+const parseDescriptorParam = (
+  value: string | null
+): SandboxLaunchConfig['descriptor'] => value
+  ? parseSandboxExtensionDescriptorJson(value)
+  : undefined
+
 const readStringParam = (
   params: URLSearchParams,
   key: string,
diff --git a/packages/v1-sandbox/src/scenario/manifest.ts b/packages/v1-sandbox/src/scenario/manifest.ts
index 93b63736..457cb77d 100644
--- a/packages/v1-sandbox/src/scenario/manifest.ts
+++ b/packages/v1-sandbox/src/scenario/manifest.ts
@@ -7,12 +7,16 @@ import type {
 } from '@/scenario/types'
 
 import { isHtmlMimeType, isJavascriptMimeType } from '@/scenario/predicates'
+import {
+  normalizeSandboxExtensionBaseUrl,
+  parseSandboxExtensionDescriptor,
+  resolveSandboxExtensionResourceUrl,
+} from '@/scenario/descriptor'
 
 export type {
   FetchLike,
   ResolveSandboxExtensionSourceOptions,
   SandboxExtensionDescriptor,
-  SandboxExtensionRunner,
   SandboxExtensionSource,
 } from '@/scenario/types'
 
@@ -22,6 +26,27 @@ export const resolveSandboxExtensionSource = async (
 ): Promise<SandboxExtensionSource> => {
   const fetcher = options.fetch ?? fetch
 
+  if (config.descriptor) {
+    const inputDescriptor = parseSandboxExtensionDescriptor(config.descriptor)
+    const baseUrl = normalizeSandboxExtensionBaseUrl(inputDescriptor.baseUrl)
+    const entrypoint = resolveSandboxExtensionResourceUrl(inputDescriptor.entrypoint, baseUrl)
+    const descriptor = {
+      ...inputDescriptor,
+      baseUrl,
+      entrypoint: entrypoint.href,
+      stylesheet: inputDescriptor.stylesheet
+        ? resolveSandboxExtensionResourceUrl(inputDescriptor.stylesheet, baseUrl).href
+        : null,
+    }
+
+    return {
+      descriptor,
+      entrypoint,
+      httpBaseUrl: baseUrl,
+      manifestUrl: null,
+    }
+  }
+
   if (!config.manifestUrl) {
     const descriptor = createFallbackDescriptor(config)
 
@@ -58,12 +83,12 @@ export const resolveSandboxExtensionSource = async (
 }
 
 const createFallbackDescriptor = (config: SandboxLaunchConfig): SandboxExtensionDescriptor => ({
+  baseUrl: resolveDescriptorBaseUrl(config.extensionUrl),
+  code: config.widgetId,
   entrypoint: config.extensionUrl,
   pages: config.mode === 'page' ? [config.pageCode] : [],
-  runner: 'worker',
   stylesheet: null,
   targets: config.targets,
-  uuid: config.widgetId,
 })
 
 const createDescriptorFromEntrypoint = (
@@ -72,14 +97,20 @@ const createDescriptorFromEntrypoint = (
   stylesheet: string | null,
   pages = config.mode === 'page' ? [config.pageCode] : []
 ): SandboxExtensionDescriptor => ({
+  baseUrl: resolveDescriptorBaseUrl(responseUrl),
+  code: config.widgetId,
   entrypoint: responseUrl,
   pages,
-  runner: 'worker',
   stylesheet,
   targets: config.targets,
-  uuid: config.widgetId,
 })
 
+const resolveDescriptorBaseUrl = (entrypoint: string): string => {
+  const backendBaseUrl = resolveExtensionBackendBaseUrl(entrypoint)
+
+  return backendBaseUrl ?? `${resolveUrl(entrypoint, window.location.href).origin}/`
+}
+
 const resolveEntrypointSource = async (
   config: SandboxLaunchConfig,
   response: Response,
diff --git a/packages/v1-sandbox/src/scenario/types.d.ts b/packages/v1-sandbox/src/scenario/types.d.ts
index 0f9d2241..404b7858 100644
--- a/packages/v1-sandbox/src/scenario/types.d.ts
+++ b/packages/v1-sandbox/src/scenario/types.d.ts
@@ -11,6 +11,7 @@ export type SandboxSlotDefinition = {
 export type SandboxLaunchMode = 'page' | 'widget'
 
 export type SandboxLaunchConfig = {
+  descriptor?: SandboxExtensionDescriptor;
   extensionUrl: string;
   fixture: string;
   manifestUrl: string;
@@ -22,15 +23,13 @@ export type SandboxLaunchConfig = {
 
 export type ParseSandboxLaunchConfigOptions = Partial<SandboxLaunchConfig>
 
-export type SandboxExtensionRunner = 'worker'
-
 export type SandboxExtensionDescriptor = {
+  code: string;
+  baseUrl: string;
   entrypoint: string;
-  pages: string[];
-  runner: SandboxExtensionRunner;
   stylesheet: string | null;
+  pages: string[];
   targets: TargetName[];
-  uuid: string;
 }
 
 export type SandboxExtensionSource = {
diff --git a/packages/v1-sandbox/src/scenario/validation.ts b/packages/v1-sandbox/src/scenario/validation.ts
index a166c0e8..6a20c5a3 100644
--- a/packages/v1-sandbox/src/scenario/validation.ts
+++ b/packages/v1-sandbox/src/scenario/validation.ts
@@ -1,9 +1,14 @@
-import type { SandboxLaunchMode, SandboxOrderTarget } from '@/scenario/types'
+import type {
+  SandboxExtensionDescriptor,
+  SandboxLaunchMode,
+  SandboxOrderTarget,
+} from '@/scenario/types'
 
 import { z } from 'zod'
 
 import { isSandboxOrderTarget } from '@/scenario/predicates'
 import { orderSandboxFixtures } from '@/scenario/fixtures'
+import { parseSandboxExtensionDescriptorJson } from '@/scenario/descriptor'
 
 export type DevPanelField =
   | 'contextJson'
@@ -22,8 +27,7 @@ export type DevPanelValidationMessages = {
   contextJsonRootObject: string;
   contextJsonUnknownContext(context: string): string;
   fixture: string;
-  manifestUrlEndpoint: string;
-  manifestUrlFormat: string;
+  manifestUrlDescriptor: string;
   manifestUrlRequired: string;
   mode: string;
   pageCodeFormat: string;
@@ -46,6 +50,7 @@ export type LaunchConfigValidationInput = {
 }
 
 export type ValidatedLaunchConfigInput = {
+  descriptor?: SandboxExtensionDescriptor;
   fixture: string;
   manifestUrl: string;
   mode: SandboxLaunchMode;
@@ -76,9 +81,14 @@ export const validateLaunchConfigInput = (
     }
   }
 
+  const source = validateExtensionSourceInput(result.data.manifestUrl, messages)
+
+  if (!source.success) return source
+
   return {
     data: {
       ...result.data,
+      ...source.data,
       mode: result.data.mode as SandboxLaunchMode,
       targets: result.data.targets as SandboxOrderTarget[],
     },
@@ -130,45 +140,7 @@ const createLaunchConfigSchema = (messages: DevPanelValidationMessages) => z.obj
   ),
   manifestUrl: z.string()
     .transform(value => value.trim())
-    .superRefine((value, context) => {
-      if (!value) {
-        context.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: messages.manifestUrlRequired,
-        })
-
-        return
-      }
-
-      let url: URL
-
-      try {
-        url = new URL(value)
-      } catch {
-        context.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: messages.manifestUrlFormat,
-        })
-
-        return
-      }
-
-      if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-        context.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: messages.manifestUrlFormat,
-        })
-
-        return
-      }
-
-      if (!hasExtensionEndpoint(url)) {
-        context.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: messages.manifestUrlEndpoint,
-        })
-      }
-    }),
+    .refine(value => value.length > 0, messages.manifestUrlRequired),
   mode: z.enum(['page', 'widget'], {
     invalid_type_error: messages.mode,
     required_error: messages.mode,
@@ -209,6 +181,26 @@ const createLaunchConfigSchema = (messages: DevPanelValidationMessages) => z.obj
   }
 })
 
+const validateExtensionSourceInput = (
+  value: string,
+  messages: DevPanelValidationMessages
+): ValidationResult<Pick<ValidatedLaunchConfigInput, 'descriptor' | 'manifestUrl'>> => {
+  try {
+    return {
+      data: {
+        descriptor: parseSandboxExtensionDescriptorJson(value),
+        manifestUrl: '',
+      },
+      success: true,
+    }
+  } catch {
+    return {
+      errors: { manifestUrl: messages.manifestUrlDescriptor },
+      success: false,
+    }
+  }
+}
+
 const createContextJsonSchema = (
   contextNames: readonly string[],
   messages: DevPanelValidationMessages
@@ -271,13 +263,6 @@ const isDevPanelField = (value: unknown): value is DevPanelField =>
   || value === 'pageCode'
   || value === 'targets'
 
-const hasExtensionEndpoint = (url: URL): boolean => {
-  const parts = url.pathname.split('/').filter(Boolean)
-  const extensionIndex = parts.indexOf('extension')
-
-  return extensionIndex >= 0 && Boolean(parts[extensionIndex + 1])
-}
-
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null && !Array.isArray(value)
 
diff --git a/packages/v1-sandbox/tests/__utils__/extensions.ts b/packages/v1-sandbox/tests/__utils__/extensions.ts
index a83d208f..78d7f340 100644
--- a/packages/v1-sandbox/tests/__utils__/extensions.ts
+++ b/packages/v1-sandbox/tests/__utils__/extensions.ts
@@ -1,4 +1,4 @@
-import type { SandboxOrderTarget } from '@/scenario'
+import type { SandboxExtensionDescriptor, SandboxOrderTarget } from '@/scenario'
 
 import { fileURLToPath } from 'node:url'
 import fs from 'node:fs'
@@ -56,3 +56,31 @@ export const getExtensionTargets = (
   descriptor: SandboxExtensionFixtureDescriptor
 ): SandboxOrderTarget[] =>
   descriptor.targets?.filter(isSandboxOrderTarget) ?? []
+
+export const createRuntimeExtensionDescriptor = (
+  descriptor: SandboxExtensionFixtureDescriptor,
+  extensionBaseUrl = process.env.SANDBOX_RUNTIME_EXTENSION_URL
+    ?? process.env.SANDBOX_EXTENSION_URL
+): SandboxExtensionDescriptor => {
+  if (!extensionBaseUrl) {
+    throw new Error('[sandbox:test] SANDBOX_EXTENSION_URL is required for extension browser tests.')
+  }
+
+  if (!descriptor.fixtureName) {
+    throw new Error('[sandbox:test] Extension fixture name is required for runtime descriptor.')
+  }
+
+  const baseUrl = new URL(extensionBaseUrl)
+  const runtimeUrl = new URL(`/runtime/${descriptor.fixtureName}/`, baseUrl)
+
+  return {
+    baseUrl: runtimeUrl.href,
+    code: descriptor.code ?? descriptor.fixtureName,
+    entrypoint: 'entrypoint.js',
+    pages: getExtensionPageCodes(descriptor),
+    stylesheet: descriptor.stylesheet
+      ? 'stylesheet.css'
+      : null,
+    targets: getExtensionTargets(descriptor),
+  }
+}
diff --git a/packages/v1-sandbox/tests/__utils__/sandbox.ts b/packages/v1-sandbox/tests/__utils__/sandbox.ts
index 5fc688ce..68b849ae 100644
--- a/packages/v1-sandbox/tests/__utils__/sandbox.ts
+++ b/packages/v1-sandbox/tests/__utils__/sandbox.ts
@@ -15,7 +15,11 @@ import {
   readSandboxSnapshot,
 } from '@/automation/playwright'
 
-import { getExtensionPageCodes, getExtensionTargets } from './extensions'
+import {
+  createRuntimeExtensionDescriptor,
+  getExtensionPageCodes,
+  getExtensionTargets,
+} from './extensions'
 
 export {
   getSandboxExtensionBaseUrl,
@@ -71,6 +75,16 @@ export const createSandboxPagePath = (
     sandboxPath: '/tests/__bootstrap__/index.html',
   })
 
+export const createSandboxDescriptorPagePath = (
+  descriptor: SandboxExtensionFixtureDescriptor,
+  pageCode = getExtensionPageCodes(descriptor)[0]
+): string =>
+  createPublicSandboxPagePath({
+    descriptor: createRuntimeExtensionDescriptor(descriptor),
+    pageCode: pageCode ?? DefaultSandbox.PageCode,
+    sandboxPath: '/tests/__bootstrap__/index.html',
+  })
+
 export const createSandboxWidgetPath = (
   descriptor: SandboxExtensionFixtureDescriptor,
   target?: SandboxOrderTarget
diff --git a/packages/v1-sandbox/tests/e2e/returnsModule.e2e.ts b/packages/v1-sandbox/tests/e2e/returnsModule.e2e.ts
index 714c5e9a..6ba47d5d 100644
--- a/packages/v1-sandbox/tests/e2e/returnsModule.e2e.ts
+++ b/packages/v1-sandbox/tests/e2e/returnsModule.e2e.ts
@@ -1,6 +1,6 @@
 import { expect, test } from '@playwright/test'
 
-import { createSandboxPagePath } from '../__utils__/sandbox'
+import { createSandboxDescriptorPagePath } from '../__utils__/sandbox'
 import { getExtensionPageCodes } from '../__utils__/extensions'
 import { readExtensionFixture } from '../__utils__/extensions'
 import { readSandboxSnapshot } from '../__utils__/sandbox'
@@ -11,13 +11,30 @@ const [pageCode] = getExtensionPageCodes(extension)
 if (!pageCode) throw new Error('returnsModule fixture has no page descriptor.')
 
 test('loads returns page extension, filters, opens and saves return', async ({ page }) => {
-  await page.goto(createSandboxPagePath(extension, pageCode))
+  const entrypointResponse = page.waitForResponse(
+    response => response.url().endsWith('/runtime/returnsModule/entrypoint.js')
+  )
+  const stylesheetResponse = page.waitForResponse(
+    response => response.url().endsWith('/runtime/returnsModule/stylesheet.css')
+  )
+
+  await page.goto(createSandboxDescriptorPagePath(extension, pageCode))
 
   await expect(page).toHaveURL(/mode=page/u)
   await expect(page).toHaveURL(new RegExp(`pageCode=${pageCode}`, 'u'))
+  await expect(page).toHaveURL(/descriptor=/u)
+  expect((await entrypointResponse).status()).toBe(200)
+  expect((await stylesheetResponse).status()).toBe(200)
   await expect(page.getByRole('button', { name: 'Возвраты' })).toBeVisible()
   await expect(page.getByRole('button', { name: 'Создать возврат' })).toBeVisible()
   await expect(page.getByRole('heading', { name: 'Список возвратов' })).toBeVisible()
+  await expect.poll(() => page.getByRole('heading', {
+    name: 'Список возвратов',
+  }).evaluate((heading) => {
+    const pageSection = heading.closest('section')
+
+    return pageSection ? getComputedStyle(pageSection).display : null
+  })).toBe('flex')
   await expect.poll(async () => {
     const snapshot = await readSandboxSnapshot(page)
 
diff --git a/packages/v1-sandbox/tests/sdk/automation/browser.test.ts b/packages/v1-sandbox/tests/sdk/automation/browser.test.ts
index ae882fa3..4e5a36ae 100644
--- a/packages/v1-sandbox/tests/sdk/automation/browser.test.ts
+++ b/packages/v1-sandbox/tests/sdk/automation/browser.test.ts
@@ -190,6 +190,43 @@ describe('browser sandbox mounting', () => {
     expect(document.querySelector('#app')).toBeNull()
   })
 
+  test('launches extension from a runtime descriptor object', async () => {
+    const descriptor = {
+      baseUrl: 'http://extension.test/runtime/',
+      code: 'returns-extension',
+      entrypoint: 'worker.js',
+      pages: ['returns'],
+      stylesheet: null,
+      targets: [],
+    }
+    const bridge = createLaunchBridge()
+    const createLaunchUrl = vi.fn((config) => {
+      const params = new URLSearchParams({
+        descriptor: JSON.stringify(config.descriptor),
+        mode: config.mode ?? 'widget',
+      })
+
+      return `/?${params.toString()}`
+    })
+
+    bridge.createLaunchUrl = createLaunchUrl
+    installSandboxAppMock(bridge)
+
+    const sandbox = await launchSandboxExtension({
+      descriptor,
+      mode: 'page',
+    })
+
+    expect(createLaunchUrl).toHaveBeenCalledWith({
+      descriptor,
+      mode: 'page',
+    })
+    expect(JSON.parse(new URLSearchParams(window.location.search).get('descriptor') ?? ''))
+      .toEqual(descriptor)
+
+    sandbox.unmount()
+  })
+
   test('waits for bridge and reports timeout', async () => {
     const bridge = createLaunchBridge()
 
diff --git a/packages/v1-sandbox/tests/sdk/automation/playwright.test.ts b/packages/v1-sandbox/tests/sdk/automation/playwright.test.ts
index e67577d3..c27344b9 100644
--- a/packages/v1-sandbox/tests/sdk/automation/playwright.test.ts
+++ b/packages/v1-sandbox/tests/sdk/automation/playwright.test.ts
@@ -26,6 +26,27 @@ import {
 } from '@/automation/playwright'
 
 describe('playwright automation helpers', () => {
+  test('creates sandbox path from runtime descriptor', () => {
+    const descriptor = {
+      baseUrl: 'https://extension.test/runtime/',
+      code: 'settings-extension',
+      entrypoint: 'worker.js',
+      pages: ['settings'],
+      stylesheet: null,
+      targets: ['order/card:common.after' as const],
+    }
+    const path = createSandboxPagePath({
+      descriptor,
+      pageCode: 'settings',
+      sandboxBaseUrl: 'http://127.0.0.1:4173',
+    })
+    const url = new URL(path, 'http://127.0.0.1:4173')
+
+    expect(JSON.parse(url.searchParams.get('descriptor') ?? '')).toEqual(descriptor)
+    expect(url.searchParams.has('manifestUrl')).toBe(false)
+    expect(url.searchParams.has('extensionUrl')).toBe(false)
+  })
+
   test('creates page sandbox path from direct extension entrypoint', () => {
     const path = createSandboxPagePath({
       extensionUrl: 'http://127.0.0.1:5173/web/endpoint/endpoint.worker.ts',
@@ -228,6 +249,35 @@ describe('playwright automation helpers', () => {
     expect(page.waitForURL).not.toHaveBeenCalled()
   })
 
+  test('waits for a serialized runtime descriptor', async () => {
+    const descriptor = {
+      baseUrl: 'https://extension.test/runtime/',
+      code: 'returns-extension',
+      entrypoint: 'worker.js',
+      pages: ['returns'],
+      stylesheet: null,
+      targets: [],
+    }
+    const page = {
+      evaluate: vi.fn(async () => undefined),
+      waitForFunction: vi.fn(async () => undefined),
+      waitForURL: vi.fn(async (matcher: (url: URL) => boolean) => {
+        const url = new URL('http://sandbox.test/')
+
+        url.searchParams.set('descriptor', JSON.stringify(descriptor))
+        url.searchParams.set('mode', 'page')
+        expect(matcher(url)).toBe(true)
+      }),
+    } as unknown as SandboxPlaywrightPage
+
+    await launchSandboxExtension(page, {
+      descriptor,
+      mode: 'page',
+    })
+
+    expect(page.waitForURL).toHaveBeenCalledOnce()
+  })
+
   test('reads sandbox snapshot from page global', async () => {
     const snapshot = {
       host: {
diff --git a/packages/v1-sandbox/tests/sdk/sandbox-ui/App.test.ts b/packages/v1-sandbox/tests/sdk/sandbox-ui/App.test.ts
index 179cc51b..412924ee 100644
--- a/packages/v1-sandbox/tests/sdk/sandbox-ui/App.test.ts
+++ b/packages/v1-sandbox/tests/sdk/sandbox-ui/App.test.ts
@@ -292,12 +292,15 @@ const createExtensionSource = (
   descriptor: Partial<SandboxExtensionSource['descriptor']> = {}
 ): SandboxExtensionSource => ({
   descriptor: {
+    baseUrl: 'http://extension.test/',
+    code: 'demo-extension',
     entrypoint: 'http://extension.test/extension/demo/script',
     pages: [],
-    runner: 'worker',
     stylesheet: null,
-    targets: ['order/card:common.before'],
-    uuid: 'demo-extension',
+    targets: [
+      'order/card:common.before',
+      'order/card:common.after',
+    ],
     ...descriptor,
   },
   entrypoint: new URL('http://extension.test/extension/demo/script'),
@@ -381,14 +384,43 @@ const selectOption = async (
   await fireEvent.click(screen.getByRole('option', { name: option }))
 }
 
+const openDescriptorJsonEditor = async (
+  dialog: HTMLElement
+): Promise<HTMLTextAreaElement> => {
+  const toggle = within(dialog).getByRole('button', { name: 'JSON' })
+
+  if (toggle.getAttribute('aria-pressed') !== 'true') {
+    await fireEvent.click(toggle)
+  }
+
+  return within(dialog).getByRole('textbox', {
+    name: 'JSON дескриптора',
+  }) as HTMLTextAreaElement
+}
+
 const configurePageLaunch = async (
   dialog: HTMLElement,
-  manifestUrl: string,
+  baseUrl: string,
   pageCode: string
 ) => {
+  const descriptor = {
+    baseUrl,
+    code: 'demo-extension',
+    entrypoint: '/extension/demo/script',
+    pages: [pageCode],
+    stylesheet: null,
+    targets: [],
+  }
+
+  await fireEvent.update(within(dialog).getByRole('textbox', {
+    name: 'Код модуля',
+  }), descriptor.code)
   await fireEvent.update(within(dialog).getByRole('textbox', {
-    name: 'Манифест / URL расширения',
-  }), manifestUrl)
+    name: 'Базовый URL',
+  }), descriptor.baseUrl)
+  await fireEvent.update(within(dialog).getByRole('textbox', {
+    name: 'Entrypoint',
+  }), descriptor.entrypoint)
   await selectOption(dialog, 'Режим', 'Страница')
   await fireEvent.update(within(dialog).getByRole('textbox', {
     name: 'Код страницы',
@@ -458,6 +490,110 @@ test('does not show the widget run summary on onboarding', async () => {
   })).toBeNull()
 })
 
+test('reports an invalid descriptor without falling back to legacy urls', async () => {
+  const alertSpy = vi.spyOn(window, 'alert').mockImplementation(() => {})
+  const descriptor = encodeURIComponent(JSON.stringify({
+    baseUrl: 'http://extension.test/',
+    code: 'demo-extension',
+    entrypoint: 'http://extension.test/runtime/worker.js',
+    pages: [],
+    runner: 'worker',
+    stylesheet: null,
+    targets: ['order/card:common.before'],
+  }))
+
+  await renderAppWithRuntime(
+    `/?descriptor=${descriptor}`
+    + '&manifestUrl=http%3A%2F%2Fextension.test%2Fextension%2Flegacy'
+    + '&mode=widget'
+  )
+
+  expect(alertSpy).toHaveBeenCalledWith(
+    'Не удалось запустить расширение\n\n[sandbox:descriptor] Invalid extension descriptor.'
+  )
+  expect(resolveSandboxExtensionSourceMock).not.toHaveBeenCalled()
+  expect(fakeWorkers).toHaveLength(0)
+})
+
+test('loads and preserves a formatted runtime descriptor', async () => {
+  const descriptor = {
+    baseUrl: 'http://extension.test/',
+    code: 'descriptor-extension',
+    entrypoint: 'http://extension.test/runtime/worker.js',
+    pages: ['settings'],
+    stylesheet: 'http://cdn.extension.test/runtime/extension.css',
+    targets: ['order/card:common.after' as const],
+  }
+  const source = createExtensionSource({
+    ...descriptor,
+  })
+
+  source.entrypoint = new URL(descriptor.entrypoint)
+  source.httpBaseUrl = 'http://extension.test/'
+  source.manifestUrl = null
+  resolveSandboxExtensionSourceMock.mockResolvedValue(source)
+
+  const { endpoint } = await renderAppWithRuntime(
+    `/?descriptor=${encodeURIComponent(JSON.stringify(descriptor))}`
+    + '&manifestUrl=http%3A%2F%2Fextension.test%2Fextension%2Flegacy'
+    + '&mode=page&pageCode=settings'
+  )
+
+  await waitFor(() => {
+    expect(endpoint.call.run).toHaveBeenCalledOnce()
+  })
+  expect(resolveSandboxExtensionSourceMock).toHaveBeenCalledWith(expect.objectContaining({
+    descriptor,
+  }))
+  expect(fakeWorkers[0]?.postMessage).toHaveBeenCalledWith(expect.objectContaining({
+    extensionUrl: descriptor.entrypoint,
+  }), expect.any(Array))
+
+  const dialog = await openDevPanel()
+  const descriptorInput = await openDescriptorJsonEditor(dialog)
+
+  expect(JSON.parse(descriptorInput.value)).toEqual(descriptor)
+  await selectOption(dialog, 'Выбранная фикстура', 'Заказ с доставкой')
+  expect(JSON.parse(descriptorInput.value)).toEqual(descriptor)
+
+  const launchUrl = new URL(
+    window[SANDBOX_LAUNCH_BRIDGE_GLOBAL_KEY]?.createLaunchUrl({
+      fixture: 'order-with-delivery',
+    }) ?? ''
+  )
+
+  expect(JSON.parse(launchUrl.searchParams.get('descriptor') ?? '')).toEqual(descriptor)
+  expect(launchUrl.searchParams.has('manifestUrl')).toBe(false)
+  expect(launchUrl.searchParams.has('extensionUrl')).toBe(false)
+})
+
+test('uses descriptor widget targets when the dev panel targets were not changed', async () => {
+  await renderAppWithRuntime('/?manifestUrl=&mode=widget')
+
+  const dialog = await openDevPanel()
+  const descriptor = {
+    baseUrl: 'http://extension.test/',
+    code: 'descriptor-widget',
+    entrypoint: 'http://extension.test/runtime/worker.js',
+    pages: [],
+    stylesheet: null,
+    targets: ['order/card:common.after'],
+  }
+
+  const descriptorInput = await openDescriptorJsonEditor(dialog)
+
+  await fireEvent.update(descriptorInput, JSON.stringify(descriptor))
+  expect(within(dialog).queryByPlaceholderText('Выберите места встраивания')).toBeNull()
+
+  await fireEvent.click(within(dialog).getByRole('button', { name: 'JSON' }))
+
+  const targets = within(dialog).getByPlaceholderText(
+    'Выберите места встраивания'
+  ) as HTMLInputElement
+
+  expect(targets.value).toBe('order/card:common.after')
+})
+
 test('does not show the widget run summary in page mode', async () => {
   resolveSandboxExtensionSourceMock.mockResolvedValue(createExtensionSource({
     pages: ['settings'],
@@ -498,7 +634,7 @@ test('blocks page extension with unknown page code', async () => {
   expect(endpoint.call.run).not.toHaveBeenCalled()
 })
 
-test('warns about page-only descriptor in explicit widget mode and continues mounting', async () => {
+test('blocks page-only descriptor in explicit widget mode', async () => {
   const alertSpy = vi.spyOn(window, 'alert').mockImplementation(() => {})
 
   resolveSandboxExtensionSourceMock.mockResolvedValue(createExtensionSource({
@@ -512,10 +648,10 @@ test('warns about page-only descriptor in explicit widget mode and continues mou
 
   await waitFor(() => {
     expect(alertSpy).toHaveBeenCalledWith(
-      'Проверьте режим запуска\n\nРасширение содержит страницы: settings. Сейчас выбран режим «Виджеты»; если ожидается страница, выберите режим «Страница».'
+      'Место встраивания расширения не найдено\n\nРасширение не поддерживает выбранные места встраивания: order/card:common.before, order/card:common.after.'
     )
-    expect(endpoint.call.run).toHaveBeenCalled()
   })
+  expect(endpoint.call.run).not.toHaveBeenCalled()
 })
 
 test('shows runtime error when worker bootstrap reports failure', async () => {
@@ -867,13 +1003,18 @@ test('updates dev panel launch fields and reports validation errors', async () =
   const applyButton = within(dialog).getByRole('button', {
     name: 'Применить',
   }) as HTMLButtonElement
-  const manifestInput = within(dialog).getByRole('textbox', {
-    name: 'Манифест / URL расширения',
-  })
 
   expect(applyButton.disabled).toBe(true)
 
-  await fireEvent.update(manifestInput, 'http://extension.test/extension/demo')
+  await fireEvent.update(within(dialog).getByRole('textbox', {
+    name: 'Код модуля',
+  }), 'demo-extension')
+  await fireEvent.update(within(dialog).getByRole('textbox', {
+    name: 'Базовый URL',
+  }), 'http://extension.test/extension/demo')
+  await fireEvent.update(within(dialog).getByRole('textbox', {
+    name: 'Entrypoint',
+  }), '/extension/demo/script')
   await selectOption(dialog, 'Режим', 'Страница')
 
   const pageCodeInput = within(dialog).getByRole('textbox', {
@@ -1005,7 +1146,11 @@ test('keeps dev panel open and shows available pages when page code is missing',
 
   expect(resolveSandboxExtensionSourceMock).toHaveBeenCalledOnce()
   expect(resolveSandboxExtensionSourceMock).toHaveBeenCalledWith(expect.objectContaining({
-    manifestUrl: 'http://extension.test/extension/demo',
+    descriptor: expect.objectContaining({
+      baseUrl: 'http://extension.test/extension/demo',
+      code: 'demo-extension',
+    }),
+    manifestUrl: '',
     mode: 'page',
     pageCode: 'returns',
   }))
@@ -1031,12 +1176,20 @@ test('keeps dev panel open and shows available pages when page code is missing',
     name: 'Применить',
   }))
   await within(dialog).findByRole('alert')
-  await fireEvent.update(within(dialog).getByRole('textbox', {
-    name: 'Манифест / URL расширения',
-  }), 'http://extension.test/extension/changed')
+  const descriptorInput = await openDescriptorJsonEditor(dialog)
+
+  await fireEvent.update(descriptorInput, JSON.stringify({
+    baseUrl: 'http://extension.test/extension/changed',
+    code: 'changed-extension',
+    entrypoint: '/extension/changed/script',
+    pages: ['returns'],
+    stylesheet: null,
+    targets: [],
+  }))
 
   expect(within(dialog).queryByRole('alert')).toBeNull()
 
+  await fireEvent.click(within(dialog).getByRole('button', { name: 'JSON' }))
   await fireEvent.click(within(dialog).getByRole('combobox', { name: 'Режим' }))
   await fireEvent.click(screen.getByRole('option', { name: 'Виджеты' }))
 
diff --git a/packages/v1-sandbox/tests/sdk/sandbox-ui/DevPanel.test.ts b/packages/v1-sandbox/tests/sdk/sandbox-ui/DevPanel.test.ts
index f52ce0f6..0e2e8688 100644
--- a/packages/v1-sandbox/tests/sdk/sandbox-ui/DevPanel.test.ts
+++ b/packages/v1-sandbox/tests/sdk/sandbox-ui/DevPanel.test.ts
@@ -33,6 +33,14 @@ afterEach(() => {
 })
 
 test('dev panel updates launch fields and context', async () => {
+  const descriptor = {
+    baseUrl: 'http://extension.test/',
+    code: 'returnsModule',
+    entrypoint: '/extension/id/script',
+    pages: ['returns'],
+    stylesheet: null,
+    targets: [ORDER_SANDBOX_SLOTS[0].target],
+  }
   const props = {
     activeFixture: 'order-basic',
     applyContextJson: vi.fn(async () => undefined),
@@ -48,7 +56,7 @@ test('dev panel updates launch fields and context', async () => {
     fixture: 'order-basic',
     formatContextJson: vi.fn(),
     launchConfigChanged: false,
-    manifestUrl: 'http://extension.test/extension/id',
+    manifestUrl: JSON.stringify(descriptor),
     mode: 'widget' as SandboxLaunchMode,
     pageCode: 'returns',
     resetContextJson: vi.fn(),
@@ -74,16 +82,92 @@ test('dev panel updates launch fields and context', async () => {
     },
   })
 
+  const descriptorViewToggle = screen.getByRole('button', { name: 'JSON' })
+
+  expect(descriptorViewToggle.getAttribute('aria-pressed')).toBe('false')
+  expect(screen.queryByLabelText('JSON дескриптора')).toBeNull()
+  expect(screen.getByText(
+    'Заполните поля дескриптора или переключитесь на JSON. Оба представления синхронизированы.'
+  )).toBeInstanceOf(HTMLSpanElement)
+  const codeInput = screen.getByLabelText('Код модуля') as HTMLInputElement
+  const baseUrlInput = screen.getByLabelText('Базовый URL') as HTMLInputElement
+  const entrypointInput = screen.getByLabelText('Entrypoint') as HTMLInputElement
+
+  expect(codeInput.value).toBe('returnsModule')
+  expect(codeInput.placeholder).toBe('Введите код модуля')
+  expect(baseUrlInput.value).toBe('http://extension.test/')
+  expect(baseUrlInput.placeholder).toBe('Введите URL расширения')
+  expect(entrypointInput.value).toBe('/extension/id/script')
+  expect(entrypointInput.placeholder).toBe('Введите entrypoint')
+  await fireEvent.update(screen.getByLabelText('Код модуля'), 'returnsModuleV2')
+  expect(props.setManifestUrl).toHaveBeenCalledWith(JSON.stringify({
+    ...descriptor,
+    code: 'returnsModuleV2',
+  }, null, 2))
+  await fireEvent.update(screen.getByLabelText('Базовый URL'), 'https://cdn.extension.test/')
+  expect(props.setManifestUrl).toHaveBeenCalledWith(JSON.stringify({
+    ...descriptor,
+    baseUrl: 'https://cdn.extension.test/',
+  }, null, 2))
+  await fireEvent.update(screen.getByLabelText('Entrypoint'), 'build/worker.js')
+  expect(props.setManifestUrl).toHaveBeenCalledWith(JSON.stringify({
+    ...descriptor,
+    entrypoint: 'build/worker.js',
+  }, null, 2))
+  const stylesheetInput = screen.getByLabelText('Stylesheet') as HTMLInputElement
+
+  expect(stylesheetInput.value).toBe('')
+  expect(stylesheetInput.placeholder).toBe('Введите stylesheet')
   expect(screen.getByRole('button', {
-    name: 'URL расширения может указывать на любое стороннее приложение, которое отдаёт расширение, например http://web-extensions-server.simla.local/extension/.',
+    name: 'Оставьте поле пустым, если у расширения нет CSS. Если стили есть, укажите путь к stylesheet.',
+  })).toBeInstanceOf(HTMLButtonElement)
+  await fireEvent.update(stylesheetInput, '/extension/id/stylesheet')
+  expect(props.setManifestUrl).toHaveBeenCalledWith(JSON.stringify({
+    ...descriptor,
+    stylesheet: '/extension/id/stylesheet',
+  }, null, 2))
+
+  await fireEvent.click(descriptorViewToggle)
+  expect(descriptorViewToggle.getAttribute('aria-pressed')).toBe('true')
+  expect(screen.queryByLabelText('Код модуля')).toBeNull()
+  expect(screen.queryByRole('combobox', { name: 'Режим' })).toBeNull()
+  expect(screen.queryByText('Места встраивания виджетов', { exact: true })).toBeNull()
+  expect(screen.getByRole('button', {
+    name: 'Дескриптор содержит code, baseUrl, entrypoint, stylesheet, pages и targets. Entrypoint и stylesheet могут быть относительными к baseUrl.',
   })).toBeInstanceOf(HTMLButtonElement)
   expect(screen.getByText(
-    'Укажите полный URL расширения по примеру в поле. Замените UUID на значение из extensionrc.json и убедитесь, что получившаяся страница открывается в браузере.'
+    'Вставьте конфигурацию дескриптора целиком в формате JSON.'
   )).toBeInstanceOf(HTMLSpanElement)
 
-  const manifestUrlInput = screen.getByLabelText('Манифест / URL расширения') as HTMLInputElement
+  const descriptorJsonInput = screen.getByLabelText('JSON дескриптора') as HTMLTextAreaElement
+
+  expect(descriptorJsonInput.value).toBe(JSON.stringify(descriptor))
+  expect(JSON.parse(descriptorJsonInput.placeholder)).toEqual({
+    code: 'promoModule',
+    baseUrl: 'http://web-extensions-server.simla.local',
+    entrypoint: '/extension/8ebe1617-d609-43e4-b35a-fbfae011eee3/script',
+    stylesheet: '/extension/8ebe1617-d609-43e4-b35a-fbfae011eee3/stylesheet',
+    targets: [],
+    pages: ['settings'],
+  })
+
+  await rerender({
+    validationErrors: {
+      manifestUrl: 'Invalid descriptor',
+    },
+  })
+  const descriptorAlert = screen.getByRole('alert')
+
+  expect(descriptorAlert.textContent).toBe('Invalid descriptor')
+  expect(descriptorAlert.getAttribute('aria-live')).toBe('assertive')
+  await rerender({ validationErrors: {} })
+
+  await fireEvent.click(descriptorViewToggle)
+  expect(descriptorViewToggle.getAttribute('aria-pressed')).toBe('false')
+  expect(screen.queryByLabelText('JSON дескриптора')).toBeNull()
+  expect(screen.getByLabelText('Код модуля')).toBeInstanceOf(HTMLInputElement)
+  expect(screen.getByRole('combobox', { name: 'Режим' })).toBeInstanceOf(HTMLInputElement)
 
-  expect(manifestUrlInput.placeholder).toContain('http://127.0.0.1:4175/extension/<uuid>')
   expect(screen.getByRole('button', {
     name: 'В режиме «Виджеты» виджеты добавляются в выбранные места встраивания. В режиме «Страница» запускается страница по её коду.',
   })).toBeInstanceOf(HTMLButtonElement)
@@ -156,14 +240,25 @@ test('dev panel updates launch fields and context', async () => {
   expect(props.setFixture).toHaveBeenCalledWith('order-with-delivery')
   expect(props.setTargetSelected).toHaveBeenCalledWith(ORDER_SANDBOX_SLOTS[0].target, false)
 
-  await fireEvent.update(manifestUrlInput, 'http://extension.test/extension/changed')
+  await fireEvent.click(descriptorViewToggle)
+  const manifestUrlInput = screen.getByLabelText('JSON дескриптора') as HTMLTextAreaElement
+  const changedDescriptor = JSON.stringify({
+    ...descriptor,
+    entrypoint: '/extension/changed/script',
+    pages: ['settings'],
+    targets: [],
+  })
+
+  await fireEvent.update(manifestUrlInput, changedDescriptor)
+  expect(props.setMode).toHaveBeenCalledWith('page')
+  expect(props.setPageCode).toHaveBeenCalledWith('settings')
   await fireEvent.update(contextJsonEditor, '{"order/card":{"number":"999C"}}')
   await fireEvent.click(screen.getByRole('button', { name: 'Форматировать' }))
   await fireEvent.click(screen.getByRole('button', { name: 'Отменить изменения' }))
   await fireEvent.click(screen.getByRole('button', { name: 'Скачать JSON' }))
   await fireEvent.click(screen.getByRole('button', { name: 'Применить' }))
 
-  expect(props.setManifestUrl).toHaveBeenCalledWith('http://extension.test/extension/changed')
+  expect(props.setManifestUrl).toHaveBeenCalledWith(changedDescriptor)
   expect(props.setContextJson).toHaveBeenCalledWith('{"order/card":{"number":"999C"}}')
   expect(props.formatContextJson).toHaveBeenCalledOnce()
   expect(props.resetContextJson).toHaveBeenCalledOnce()
@@ -175,6 +270,8 @@ test('dev panel updates launch fields and context', async () => {
   })
   expect((screen.getByRole('button', { name: 'Применить' }) as HTMLButtonElement).disabled).toBe(true)
 
+  await fireEvent.click(descriptorViewToggle)
+
   await rerender({
     applyingLaunchConfig: false,
     contextJsonChanged: true,
diff --git a/packages/v1-sandbox/tests/sdk/sandbox-ui/ExtensionOnboarding.test.ts b/packages/v1-sandbox/tests/sdk/sandbox-ui/ExtensionOnboarding.test.ts
index 9be48085..8b7d42df 100644
--- a/packages/v1-sandbox/tests/sdk/sandbox-ui/ExtensionOnboarding.test.ts
+++ b/packages/v1-sandbox/tests/sdk/sandbox-ui/ExtensionOnboarding.test.ts
@@ -50,35 +50,20 @@ test('extension onboarding opens sandbox controls', async () => {
   expect(within(onboarding).getByRole('heading', {
     name: 'Подключите внешнее расширение',
   })).toBeInstanceOf(HTMLHeadingElement)
-  expect(within(onboarding).getAllByRole('listitem')).toHaveLength(3)
-  expect(within(onboarding).getByText('Запустите сервер расширения.')).toBeInstanceOf(HTMLLIElement)
-  expect(within(onboarding).getByText('Запустите песочницу.')).toBeInstanceOf(HTMLLIElement)
-  expect(within(within(onboarding).getAllByRole('listitem')[2]).getByText(
-    'http://127.0.0.1:4175/extension/<uuid>'
-  )).toBeInstanceOf(HTMLElement)
+  expect(within(onboarding).getByText(/"code": "promoModule"/u)).toBeInstanceOf(HTMLElement)
+  expect(within(onboarding).getByText(/"baseUrl": "http:\/\/web-extensions-server\.simla\.local"/u)).toBeInstanceOf(HTMLElement)
+  expect(within(onboarding).getByText(/"entrypoint": "\/extension\/8ebe1617-d609-43e4-b35a-fbfae011eee3\/script"/u)).toBeInstanceOf(HTMLElement)
+  expect(within(onboarding).getByText(/"stylesheet": "\/extension\/8ebe1617-d609-43e4-b35a-fbfae011eee3\/stylesheet"/u)).toBeInstanceOf(HTMLElement)
+  expect(within(onboarding).getByText(/"pages": \[/u)).toBeInstanceOf(HTMLElement)
   expect(within(onboarding).getByText(/Дополнительный сервер запускать не требуется\./u)).toBeInstanceOf(HTMLElement)
-  expect(within(onboarding).getByText('Затем выберите режим: Виджеты или Страница.')).toBeInstanceOf(HTMLElement)
-
-  const collapseButton = within(onboarding).getByRole('button', {
-    name: 'Шаблон URL запуска',
-  })
-
-  expect(collapseButton.getAttribute('aria-expanded')).toBe('false')
-
-  await fireEvent.click(collapseButton)
+  expect(within(onboarding).getByText(
+    'При заполнении отдельных полей затем выберите режим: Виджеты или Страница.'
+  )).toBeInstanceOf(HTMLElement)
 
-  expect(collapseButton.getAttribute('aria-expanded')).toBe('true')
-  expect(within(onboarding).getByText('Это шаблон, а не готовая ссылка.', {
-    exact: false,
-  })).toBeInstanceOf(HTMLElement)
-  expect(within(onboarding).getByText('%sandbox-url%')).toBeInstanceOf(HTMLElement)
-  expect(within(onboarding).getByText('%extension-url%')).toBeInstanceOf(HTMLElement)
-  expect(within(onboarding).getByText('%extension-id%')).toBeInstanceOf(HTMLElement)
-  expect(within(onboarding).getByText('UUID расширения.')).toBeInstanceOf(HTMLElement)
-  expect(within(onboarding).getByText('Пример полного URL расширения:')).toBeInstanceOf(HTMLElement)
+  expect(within(onboarding).queryByText('Легаси-шаблон URL запуска')).toBeNull()
 
   await fireEvent.click(within(onboarding).getByRole('button', {
-    name: 'Открыть песочницу',
+    name: 'Открыть дев-панель',
   }))
 
   expect(openDevPanel).toHaveBeenCalledOnce()
diff --git a/packages/v1-sandbox/tests/sdk/sandbox-ui/createSandbox.test.ts b/packages/v1-sandbox/tests/sdk/sandbox-ui/createSandbox.test.ts
index cab9dd68..7604571f 100644
--- a/packages/v1-sandbox/tests/sdk/sandbox-ui/createSandbox.test.ts
+++ b/packages/v1-sandbox/tests/sdk/sandbox-ui/createSandbox.test.ts
@@ -98,7 +98,8 @@ test('opens dev panel and validates launch config input', async () => {
 
   expect(applyButton.disabled).toBe(true)
 
-  const manifestInput = within(dialog).getByLabelText('Манифест / URL расширения') as HTMLInputElement
+  await fireEvent.click(within(dialog).getByRole('button', { name: 'JSON' }))
+  const manifestInput = within(dialog).getByLabelText('JSON дескриптора') as HTMLTextAreaElement
 
   await fireEvent.update(manifestInput, 'http://extension.test/not-extension/id')
   await nextTick()
@@ -108,7 +109,7 @@ test('opens dev panel and validates launch config input', async () => {
   await fireEvent.click(applyButton)
 
   expect((await within(dialog).findByRole('alert')).textContent?.trim())
-    .toBe('URL должен быть вида %extension-url%/extension/%extension-id%.')
+    .toBe('Введите валидный дескриптор с полями code, baseUrl, entrypoint, stylesheet, pages и targets. Адреса ресурсов могут быть относительными к абсолютному http/https baseUrl.')
 })
 
 test('installs launch bridge and creates launch urls from current config', () => {
diff --git a/packages/v1-sandbox/tests/sdk/scenario/descriptor.test.ts b/packages/v1-sandbox/tests/sdk/scenario/descriptor.test.ts
new file mode 100644
index 00000000..ded612af
--- /dev/null
+++ b/packages/v1-sandbox/tests/sdk/scenario/descriptor.test.ts
@@ -0,0 +1,54 @@
+import { describe, expect, test } from 'vitest'
+
+import {
+  parseSandboxExtensionDescriptor,
+  parseSandboxExtensionDescriptorJson,
+} from '@/scenario'
+
+const descriptor = {
+  baseUrl: 'https://extension.test/runtime/',
+  code: 'returns-module',
+  entrypoint: 'worker.js',
+  pages: ['returns'],
+  stylesheet: 'styles.css',
+  targets: ['order/card:common.after'],
+}
+
+describe('sandbox extension descriptor', () => {
+  test('parses a strict runtime descriptor', () => {
+    expect(parseSandboxExtensionDescriptor(descriptor)).toEqual(descriptor)
+    expect(parseSandboxExtensionDescriptorJson(JSON.stringify(descriptor))).toEqual(descriptor)
+  })
+
+  test('rejects runner and other fields', () => {
+    expect(() => parseSandboxExtensionDescriptor({
+      ...descriptor,
+      runner: 'worker',
+    })).toThrow('Invalid extension descriptor')
+  })
+
+  test('requires an absolute http/https base url and resolvable resource paths', () => {
+    expect(() => parseSandboxExtensionDescriptor({
+      ...descriptor,
+      baseUrl: '/runtime/',
+    })).toThrow('Invalid extension descriptor')
+    expect(() => parseSandboxExtensionDescriptor({
+      ...descriptor,
+      stylesheet: 'ftp://extension.test/styles.css',
+    })).toThrow('Invalid extension descriptor')
+    expect(() => parseSandboxExtensionDescriptor({
+      ...descriptor,
+      entrypoint: 'http://[invalid',
+    })).toThrow('Invalid extension descriptor')
+    expect(() => parseSandboxExtensionDescriptor({
+      ...descriptor,
+      pages: [''],
+    })).toThrow('Invalid extension descriptor')
+  })
+
+  test('rejects malformed descriptor json', () => {
+    expect(() => parseSandboxExtensionDescriptorJson('{')).toThrow(
+      'Invalid extension descriptor JSON'
+    )
+  })
+})
diff --git a/packages/v1-sandbox/tests/sdk/scenario/launch.test.ts b/packages/v1-sandbox/tests/sdk/scenario/launch.test.ts
index 3df959b5..a28bdcc4 100644
--- a/packages/v1-sandbox/tests/sdk/scenario/launch.test.ts
+++ b/packages/v1-sandbox/tests/sdk/scenario/launch.test.ts
@@ -58,6 +58,63 @@ test('parses multiple widget targets and page mode', () => {
   })
 })
 
+test('round-trips descriptor and uses its widget targets by default', () => {
+  const descriptor = {
+    baseUrl: 'https://extension.test/runtime/',
+    code: 'descriptor-widget',
+    entrypoint: 'worker.js',
+    pages: [],
+    stylesheet: null,
+    targets: ['order/card:common.after' as const],
+  }
+  const url = updateSandboxLaunchQuery({
+    descriptor,
+    extensionUrl: 'http://legacy.test/extension/demo',
+    fixture: 'order-basic',
+    manifestUrl: 'http://legacy.test/extension/demo',
+    mode: 'widget',
+    pageCode: 'orders-dashboard',
+    targets: descriptor.targets,
+    widgetId: 'sandbox-widget',
+  }, 'http://sandbox.test/')
+  const parsed = parseSandboxLaunchConfig(new URLSearchParams({
+    descriptor: url.searchParams.get('descriptor') ?? '',
+  }))
+
+  expect(url.searchParams.has('extensionUrl')).toBe(false)
+  expect(url.searchParams.has('manifestUrl')).toBe(false)
+  expect(parsed.descriptor).toEqual(descriptor)
+  expect(parsed.targets).toEqual(['order/card:common.after'])
+})
+
+test('rejects invalid descriptors without falling back to legacy url', () => {
+  expect(() => parseSandboxLaunchConfig(new URLSearchParams({
+    descriptor: JSON.stringify({
+      entrypoint: '/relative.js',
+      pages: [],
+      stylesheet: null,
+      targets: [],
+      uuid: 'demo',
+    }),
+    manifestUrl: 'http://extension.test/extension/demo',
+  }))).toThrow('Invalid extension descriptor')
+})
+
+test('removes stale descriptor when serializing legacy config', () => {
+  const url = updateSandboxLaunchQuery({
+    extensionUrl: '',
+    fixture: 'order-basic',
+    manifestUrl: 'http://extension.test/extension/demo',
+    mode: 'widget',
+    pageCode: 'orders-dashboard',
+    targets: ['order/card:common.after'],
+    widgetId: 'sandbox-widget',
+  }, `http://sandbox.test/?descriptor=${encodeURIComponent('{}')}`)
+
+  expect(url.searchParams.has('descriptor')).toBe(false)
+  expect(url.searchParams.get('manifestUrl')).toBe('http://extension.test/extension/demo')
+})
+
 test('falls back to safe defaults for empty and unsupported values', () => {
   const config = parseSandboxLaunchConfig(new URLSearchParams({
     extensionUrl: '',
diff --git a/packages/v1-sandbox/tests/sdk/scenario/manifest.test.ts b/packages/v1-sandbox/tests/sdk/scenario/manifest.test.ts
index 26ccda7a..f7a02106 100644
--- a/packages/v1-sandbox/tests/sdk/scenario/manifest.test.ts
+++ b/packages/v1-sandbox/tests/sdk/scenario/manifest.test.ts
@@ -40,6 +40,35 @@ const response = (
 } as Response)
 
 describe('resolveSandboxExtensionSource', () => {
+  test('uses descriptor resources directly without fetching legacy manifest', async () => {
+    const fetcher = vi.fn()
+    const descriptor = {
+      baseUrl: 'https://extension.test/runtime/',
+      code: 'returns-module',
+      entrypoint: 'worker.js',
+      pages: ['returns'],
+      stylesheet: 'styles.css',
+      targets: ['order/card:common.after' as const],
+    }
+
+    const source = await resolveSandboxExtensionSource(config({
+      descriptor,
+      manifestUrl: 'http://legacy.test/extension/demo',
+    }), { fetch: fetcher as typeof fetch })
+
+    expect(source).toEqual({
+      descriptor: {
+        ...descriptor,
+        entrypoint: 'https://extension.test/runtime/worker.js',
+        stylesheet: 'https://extension.test/runtime/styles.css',
+      },
+      entrypoint: new URL('https://extension.test/runtime/worker.js'),
+      httpBaseUrl: 'https://extension.test/runtime/',
+      manifestUrl: null,
+    })
+    expect(fetcher).not.toHaveBeenCalled()
+  })
+
   test('rejects failed manifest response', async () => {
     const fetcher = vi.fn(async () => response('', {
       contentType: 'text/plain',
@@ -123,8 +152,7 @@ describe('resolveSandboxExtensionSource', () => {
 
     expect(source.entrypoint.href).toBe('http://sandbox.test/extensions/html/assets/entry.js')
     expect(source.httpBaseUrl).toBe('http://sandbox.test/')
-    expect(source.descriptor.runner).toBe('worker')
-    expect(source.descriptor.uuid).toBe('sandbox-widget')
+    expect(source.descriptor.code).toBe('sandbox-widget')
     expect(fetcher).toHaveBeenCalledTimes(2)
   })
 
@@ -160,7 +188,6 @@ describe('resolveSandboxExtensionSource', () => {
     }), { fetch: fetcher as typeof fetch })
 
     expect(source.descriptor.pages).toEqual(['returns'])
-    expect(source.descriptor.runner).toBe('worker')
     expect(source.descriptor.stylesheet).toBe(
       'http://extension-host.test/extension/module-id/stylesheet'
     )
@@ -221,7 +248,7 @@ describe('resolveSandboxExtensionSource', () => {
     })
 
     expect(source.descriptor.entrypoint).toBe('/src/direct-extension.js')
-    expect(source.descriptor.uuid).toBe('sandbox-widget')
+    expect(source.descriptor.code).toBe('sandbox-widget')
     expect(source.entrypoint.href).toBe('http://localhost/src/direct-extension.js')
     expect(source.httpBaseUrl).toBeNull()
   })
diff --git a/packages/v1-sandbox/tests/sdk/scenario/validation.test.ts b/packages/v1-sandbox/tests/sdk/scenario/validation.test.ts
index a20b8c5f..f8f170c8 100644
--- a/packages/v1-sandbox/tests/sdk/scenario/validation.test.ts
+++ b/packages/v1-sandbox/tests/sdk/scenario/validation.test.ts
@@ -11,9 +11,8 @@ const messages: DevPanelValidationMessages = {
   contextJsonRootObject: 'Context JSON must be an object.',
   contextJsonUnknownContext: context => `Unknown context "${context}".`,
   fixture: 'Unknown fixture.',
-  manifestUrlEndpoint: 'Manifest URL must include /extension/%extension-id%.',
-  manifestUrlFormat: 'Manifest URL must be an absolute http/https URL.',
-  manifestUrlRequired: 'Manifest URL is required.',
+  manifestUrlDescriptor: 'Extension descriptor is invalid.',
+  manifestUrlRequired: 'Extension descriptor is required.',
   mode: 'Unknown mode.',
   pageCodeFormat: 'Page code has an invalid format.',
   pageCodeRequired: 'Page code is required.',
@@ -21,9 +20,18 @@ const messages: DevPanelValidationMessages = {
   targetUnknown: target => `Unknown target "${target}".`,
 }
 
+const descriptor = {
+  baseUrl: 'https://extension.test/runtime/',
+  code: 'returns-module',
+  entrypoint: 'worker.js',
+  pages: ['returns'],
+  stylesheet: null,
+  targets: ['order/card:common.after'],
+}
+
 const validLaunchInput = {
   fixture: 'order-basic',
-  manifestUrl: 'http://extension.test/extension/module-id',
+  manifestUrl: JSON.stringify(descriptor),
   mode: 'widget',
   pageCode: 'returns',
   targets: ['order/card:common.after'],
@@ -37,37 +45,64 @@ test('rejects empty manifest urls', () => {
 
   expect(result).toEqual({
     errors: {
-      manifestUrl: 'Manifest URL is required.',
+      manifestUrl: 'Extension descriptor is required.',
     },
     success: false,
   })
 })
 
-test('rejects malformed manifest urls', () => {
+test('rejects direct extension urls', () => {
   const invalidUrl = validateLaunchConfigInput({
     ...validLaunchInput,
     manifestUrl: 'extension.test/module-id',
   }, messages)
-  const missingEndpoint = validateLaunchConfigInput({
-    ...validLaunchInput,
-    manifestUrl: 'http://extension.test/module-id',
-  }, messages)
-
   expect(invalidUrl).toEqual({
     errors: {
-      manifestUrl: 'Manifest URL must be an absolute http/https URL.',
+      manifestUrl: 'Extension descriptor is invalid.',
     },
     success: false,
   })
-  expect(missingEndpoint).toEqual({
+})
+
+test('accepts a strict extension descriptor', () => {
+  const result = validateLaunchConfigInput({
+    ...validLaunchInput,
+    manifestUrl: JSON.stringify(descriptor),
+  }, messages)
+
+  expect(result).toEqual({
+    data: {
+      ...validLaunchInput,
+      descriptor,
+      manifestUrl: '',
+    },
+    success: true,
+  })
+})
+
+test('rejects malformed or non-strict extension descriptors', () => {
+  const result = validateLaunchConfigInput({
+    ...validLaunchInput,
+    manifestUrl: JSON.stringify({
+      entrypoint: 'https://extension.test/runtime/worker.js',
+      baseUrl: 'https://extension.test/',
+      code: 'returns-module',
+      pages: [],
+      runner: 'worker',
+      stylesheet: null,
+      targets: [],
+    }),
+  }, messages)
+
+  expect(result).toEqual({
     errors: {
-      manifestUrl: 'Manifest URL must include /extension/%extension-id%.',
+      manifestUrl: 'Extension descriptor is invalid.',
     },
     success: false,
   })
 })
 
-test('rejects manifest urls with unsupported protocols', () => {
+test('rejects non-json direct urls with unsupported protocols', () => {
   const result = validateLaunchConfigInput({
     ...validLaunchInput,
     manifestUrl: 'ftp://extension.test/extension/module-id',
@@ -75,7 +110,7 @@ test('rejects manifest urls with unsupported protocols', () => {
 
   expect(result).toEqual({
     errors: {
-      manifestUrl: 'Manifest URL must be an absolute http/https URL.',
+      manifestUrl: 'Extension descriptor is invalid.',
     },
     success: false,
   })
diff --git a/packages/v1-sandbox/vite.config.e2e-extension.ts b/packages/v1-sandbox/vite.config.e2e-extension.ts
index c1c067e5..42d01a8c 100644
--- a/packages/v1-sandbox/vite.config.e2e-extension.ts
+++ b/packages/v1-sandbox/vite.config.e2e-extension.ts
@@ -41,22 +41,78 @@ const extensionFixtureServer = (): Plugin => ({
       }
 
       const url = new URL(request.url, 'http://extension.test')
+      const returnsRuntimePath = '/runtime/returnsModule'
+      const returnsAction = url.pathname.startsWith(`${returnsRuntimePath}/`)
+        ? url.pathname.slice(returnsRuntimePath.length)
+        : url.pathname
       const isReturnsAction = [
         '/return',
         '/returns',
         '/returns/save',
-      ].includes(url.pathname)
+      ].includes(returnsAction)
 
       if (request.method === 'POST' && isReturnsAction) {
         setCorsHeaders(request.headers.origin, response)
         readPayload(request).then(payload => {
-          const result = resolveReturnsBackendRequest(url.pathname, payload)
+          const result = resolveReturnsBackendRequest(returnsAction, payload)
 
           send(response, result.status, JSON.stringify(result.body), 'application/json; charset=utf-8')
         }).catch(next)
         return
       }
 
+      const runtimeMatch = url.pathname.match(
+        /^\/runtime\/([^/]+)\/(entrypoint\.js|stylesheet\.css|assets\/.*)$/u
+      )
+
+      if (runtimeMatch) {
+        const fixture = runtimeMatch[1]
+        const action = runtimeMatch[2]
+        const entry = entries.get(fixture)
+
+        if (!entry) {
+          send(response, 404, 'Not found', 'text/plain; charset=utf-8')
+          return
+        }
+
+        setCorsHeaders(request.headers.origin, response)
+
+        if (request.method === 'OPTIONS') {
+          response.writeHead(204)
+          response.end()
+          return
+        }
+
+        if (request.method !== 'GET' && request.method !== 'HEAD') {
+          send(response, 405, 'Method not allowed', 'text/plain; charset=utf-8')
+          return
+        }
+
+        if (action === 'entrypoint.js') {
+          sendFile(response, path.resolve(outputRoot, entry.file), request.method === 'HEAD')
+          return
+        }
+
+        if (action === 'stylesheet.css') {
+          const stylesheet = entry.css?.[0]
+
+          if (!stylesheet) {
+            send(response, 404, 'Not found', 'text/plain; charset=utf-8')
+            return
+          }
+
+          sendFile(response, path.resolve(outputRoot, stylesheet), request.method === 'HEAD')
+          return
+        }
+
+        sendFile(
+          response,
+          path.resolve(outputRoot, action),
+          request.method === 'HEAD'
+        )
+        return
+      }
+
       const match = url.pathname.match(/^\/extension\/([^/]+)(\/.*)?$/u)
 
       if (!match) {
@@ -83,6 +139,10 @@ const extensionFixtureServer = (): Plugin => ({
       const action = match[2] ?? ''
       const entry = entries.get(fixture)
 
+      if (!entry) {
+        throw new Error(`E2E extension build not found ${fixture}`)
+      }
+
       if ((request.method === 'GET' || request.method === 'HEAD') && action === '') {
         const manifest = [
           '<!doctype html>',
diff --git a/packages/v1-sandbox/vitest.config.playwright.ts b/packages/v1-sandbox/vitest.config.playwright.ts
index 63f3a8fc..6534ba0f 100644
--- a/packages/v1-sandbox/vitest.config.playwright.ts
+++ b/packages/v1-sandbox/vitest.config.playwright.ts
@@ -20,12 +20,14 @@ const sandboxBaseURL = process.env.SANDBOX_BASE_URL
 const baseURL = sandboxBaseURL || 'http://127.0.0.1:4173'
 const configuredExtensionBaseURL = process.env.SANDBOX_EXTENSION_URL
 const extensionBaseURL = configuredExtensionBaseURL || 'http://127.0.0.1:4175/extension/'
+const runtimeExtensionBaseURL = 'http://127.0.0.1:4175/'
 const promoModule = JSON.parse(fs.readFileSync(
   path.resolve(__dirname, 'tests/__fixtures__/extensions/promoModule/extensionrc.json'),
   'utf8'
 )) as { uuid: string }
 
 process.env.SANDBOX_EXTENSION_URL = extensionBaseURL
+process.env.SANDBOX_RUNTIME_EXTENSION_URL = runtimeExtensionBaseURL
 
 const webServer = [
   ...(sandboxBaseURL ? [] : [{
@@ -33,11 +35,11 @@ const webServer = [
     url: baseURL,
     reuseExistingServer: !process.env.CI,
   }]),
-  ...(configuredExtensionBaseURL ? [] : [{
+  {
     command: 'yarn build:e2e-extensions && yarn serve:e2e-extensions',
-    url: new URL(promoModule.uuid, extensionBaseURL).href,
+    url: new URL(`extension/${promoModule.uuid}`, runtimeExtensionBaseURL).href,
     reuseExistingServer: !process.env.CI,
-  }]),
+  },
 ]
 
 export default defineConfig({
diff --git a/packages/v1-sandbox/vitest.config.ts b/packages/v1-sandbox/vitest.config.ts
index 0124fbcb..fd945592 100644
--- a/packages/v1-sandbox/vitest.config.ts
+++ b/packages/v1-sandbox/vitest.config.ts
@@ -11,6 +11,7 @@ export default mergeConfig(basic as ViteUserConfig, defineConfig({
     exclude: ['tests/**/*.test.browser.ts'],
     include: ['tests/**/*.test.ts'],
     reporters: ['dot'],
+    setupFiles: ['./vitest.setup.ts'],
     coverage: {
       provider: 'istanbul',
       include: ['src/**/*.{ts,tsx,vue}'],
diff --git a/packages/v1-sandbox/vitest.setup.ts b/packages/v1-sandbox/vitest.setup.ts
new file mode 100644
index 00000000..84dd5e10
--- /dev/null
+++ b/packages/v1-sandbox/vitest.setup.ts
@@ -0,0 +1,2 @@
+// https://github.com/jsdom/jsdom/issues/1695
+window.HTMLElement.prototype.scrollIntoView = () => { }
\ No newline at end of file
diff --git a/yarn.lock b/yarn.lock
index 296bf7a1..94417214 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2078,6 +2078,7 @@ __metadata:
     less: "npm:^4.4.2"
     nyc: "npm:^18.0.0"
     playwright: "npm:1.58.2"
+    tslib: "npm:^2.8.1"
     typescript: "npm:^5.9.3"
     vite: "npm:^7.3.5"
     vite-plugin-dts: "npm:^4.5.4"
@@ -11171,7 +11172,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tslib@npm:^2.0.1":
+"tslib@npm:^2.0.1, tslib@npm:^2.8.1":
   version: 2.8.1
   resolution: "tslib@npm:2.8.1"
   checksum: 10/3e2e043d5c2316461cb54e5c7fe02c30ef6dccb3384717ca22ae5c6b5bc95232a6241df19c622d9c73b809bea33b187f6dbc73030963e29950c2141bc32a79f7