@wix/zero-config-implementation 1.86.0 → 1.87.0

package/package.json

@@ -4,7 +4,7 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "version": "1.86.0",
+  "version": "1.87.0",
   "description": "Core library for extracting component manifests from JS and CSS files",
   "type": "module",
   "main": "dist/index.js",
@@ -39,8 +39,32 @@
     }
   },
   "dependencies": {
-    "@wix/builder-services-wrapper": "^1.56.0",
-    "@wix/react-component-schema": "1.8.0"
+    "@wix/react-component-schema": "1.8.0",
+    "@wix/seo-service": "^1.9.0",
+    "@wix/services-manager": "^1.0.7",
+    "@wix/services-manager-react": "^1.0.8",
+    "@wix/site-service-configuration": "^1.0.1",
+    "@wix/site-service-device-info": "^1.0.2",
+    "@wix/site-service-editor-context": "^1.0.1",
+    "@wix/site-service-experiments": "^1.0.3",
+    "@wix/site-service-locale": "^1.0.2",
+    "@wix/site-service-pages": "^1.0.2",
+    "@wix/site-service-provide-css": "^1.0.1",
+    "@wix/site-service-rendering-context": "^1.0.1",
+    "@wix/site-service-url": "^1.0.1",
+    "@wix/viewer-service-anchors": "^1.0.40",
+    "@wix/viewer-service-consent-policy": "^1.0.100",
+    "@wix/viewer-service-environment": "^1.0.47",
+    "@wix/viewer-service-link-utils": "^1.0.62",
+    "@wix/viewer-service-named-signals": "^1.0.16",
+    "@wix/viewer-service-pages": "^1.0.9",
+    "@wix/viewer-service-provide-css": "^1.0.31",
+    "@wix/viewer-service-renderer-configuration": "^1.0.7",
+    "@wix/viewer-service-sdk-state": "^1.0.28",
+    "@wix/viewer-service-site-scroll-blocker": "^1.0.63",
+    "@wix/viewer-service-topology": "^1.0.26",
+    "@wix/viewer-service-translations": "^1.0.15",
+    "@wix/viewer-service-url": "^1.0.69"
   },
   "devDependencies": {
     "@faker-js/faker": "^10.2.0",
@@ -82,5 +106,5 @@
       ]
     }
   },
-  "falconPackageHash": "88fd007d78421c0861fdf823019f98813fd8a82582461e104c5ee2ef"
+  "falconPackageHash": "1db79cb96c2d3ad1aa00f8c608385635757b7899b0f11f7a74f228e4"
 }

package/src/extensions/wix-services/service-stub.test.ts

@@ -0,0 +1,149 @@
+import { createServicesManager, createServicesMap } from '@wix/services-manager'
+import type { ServiceDefinition } from '@wix/services-manager/types'
+import React from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it, vi } from 'vitest'
+import { createAutoStubFallbackManager } from './service-stub'
+
+// Definitions are plain strings at runtime, so a cast string is a faithful stand-in.
+function defineTestService(serviceId: string): ServiceDefinition<never, never> {
+  return serviceId as unknown as ServiceDefinition<never, never>
+}
+
+const UnregisteredDefinition = defineTestService('@wix/viewer-service-topology')
+
+// biome-ignore lint/suspicious/noExplicitAny: stubs are intentionally untyped at the call site
+function stubFor(serviceId: string): any {
+  return createAutoStubFallbackManager().getService(defineTestService(serviceId))
+}
+
+describe('createAutoStubFallbackManager', () => {
+  it('returns a referentially stable stub across repeated lookups', () => {
+    const fallbackManager = createAutoStubFallbackManager()
+
+    expect(fallbackManager.getService(UnregisteredDefinition)).toBe(fallbackManager.getService(UnregisteredDefinition))
+  })
+
+  it('notifies once per distinct service id', () => {
+    const onServiceStubbed = vi.fn()
+    const fallbackManager = createAutoStubFallbackManager({ onServiceStubbed })
+
+    fallbackManager.getService(UnregisteredDefinition)
+    fallbackManager.getService(UnregisteredDefinition)
+    fallbackManager.getService(defineTestService('@wix/seo-service'))
+
+    expect(onServiceStubbed.mock.calls).toEqual([['@wix/viewer-service-topology'], ['@wix/seo-service']])
+  })
+})
+
+describe('service stub value semantics', () => {
+  it('resolves nested reads and curried calls to memoized stubs', () => {
+    const pagesStub = stubFor('@wix/site-service-pages')
+    expect(pagesStub.currentPage.title).toBe(pagesStub.currentPage.title)
+
+    const translationsStub = stubFor('@wix/viewer-service-translations')
+    expect(translationsStub.translate('app')('greeting')).toBe(translationsStub.translate('app')('greeting'))
+  })
+
+  it('keeps well-known symbol handlers referentially stable', () => {
+    const stub = stubFor('@wix/viewer-service-topology')
+
+    expect(stub.toString).toBe(stub.toString)
+    expect(stub[Symbol.iterator]).toBe(stub[Symbol.iterator])
+  })
+
+  it('agrees between `in` and reads for symbols', () => {
+    const stub = stubFor('@wix/viewer-service-topology')
+    const unhandledSymbol = Symbol.for('some-library-symbol')
+
+    // Reporting a symbol as present while reading undefined would break
+    // `if (sym in service) service[sym]()`.
+    expect(unhandledSymbol in stub).toBe(false)
+    expect(stub[unhandledSymbol]).toBeUndefined()
+
+    expect(Symbol.iterator in stub).toBe(true)
+    expect(stub[Symbol.iterator]).toBeDefined()
+  })
+
+  it('is not thenable, so awaiting it cannot hang', async () => {
+    const stub = stubFor('@wix/seo-service')
+
+    expect(stub.then).toBeUndefined()
+    expect('then' in stub).toBe(false)
+    await expect(Promise.resolve(stub)).resolves.toBe(stub)
+  })
+
+  it('terminates on spread and key enumeration instead of recursing', () => {
+    const stub = stubFor('@wix/viewer-service-sdk-state')
+
+    expect(Object.keys(stub)).toEqual([])
+    expect({ ...stub }).toEqual({})
+  })
+
+  it('reads as an empty string and iterates as empty', () => {
+    const stub = stubFor('@wix/viewer-service-topology')
+
+    expect(`${stub}`).toBe('')
+    expect([...stub]).toEqual([])
+  })
+
+  it('does not crash React when handed to JSX as a child', () => {
+    // Unconverted, so React sees the Proxy itself — and throws on plain-object children.
+    const reactWarning = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const stub = stubFor('@wix/viewer-service-topology')
+
+    expect(() => renderToStaticMarkup(React.createElement('span', null, stub))).not.toThrow()
+
+    reactWarning.mockRestore()
+  })
+})
+
+describe('used as a services-manager fallback', () => {
+  const RegisteredDefinition = defineTestService('@wix/registered-test-service')
+
+  function createManagerWithFallback(onServiceStubbed?: (serviceId: string) => void) {
+    return createServicesManager(
+      createServicesMap([
+        {
+          definition: RegisteredDefinition,
+          impl: (() => ({ realValue: 'from-real-service' })) as never,
+          config: {} as never,
+        },
+      ]),
+      createAutoStubFallbackManager({ onServiceStubbed }),
+    )
+  }
+
+  it('keeps extended bindings real and still stubs the rest', () => {
+    const ExtendedDefinition = defineTestService('@wix/extended-test-service')
+    const extended = createAutoStubFallbackManager().extend(
+      createServicesMap([
+        {
+          definition: ExtendedDefinition,
+          impl: (() => ({ realValue: 'from-extension' })) as never,
+          config: {} as never,
+        },
+      ]),
+    )
+
+    expect(extended.getService(ExtendedDefinition)).toEqual({ realValue: 'from-extension' })
+    expect(() => extended.getService(UnregisteredDefinition)).not.toThrow()
+  })
+
+  it('leaves registered services untouched', () => {
+    const servicesManager = createManagerWithFallback()
+
+    expect(servicesManager.getService(RegisteredDefinition)).toEqual({ realValue: 'from-real-service' })
+  })
+
+  it('substitutes a stub where an unregistered service would otherwise throw', () => {
+    const onServiceStubbed = vi.fn()
+
+    expect(() => createServicesManager(createServicesMap([])).getService(UnregisteredDefinition)).toThrow(
+      /is not provided/,
+    )
+
+    expect(() => createManagerWithFallback(onServiceStubbed).getService(UnregisteredDefinition)).not.toThrow()
+    expect(onServiceStubbed).toHaveBeenCalledWith('@wix/viewer-service-topology')
+  })
+})

package/src/extensions/wix-services/service-stub.ts

@@ -0,0 +1,126 @@
+import { createServicesManager } from '@wix/services-manager'
+import type { ServicesManager, ServicesRegistrar } from '@wix/services-manager/types'
+
+/** Definitions are plain strings at runtime, so one doubles as both registry key and service id. */
+type ServiceDefinitionLike = { toString(): string }
+
+/** A thenable stub would hang `await`; a stub with `$$typeof` would be read as a React element. */
+const NEVER_STUBBED_PROPERTIES: ReadonlySet<PropertyKey> = new Set([
+  'then',
+  'catch',
+  'finally',
+  '$$typeof',
+  'toJSON',
+  'nodeType',
+])
+
+const HANDLED_SYMBOLS: ReadonlySet<symbol> = new Set([Symbol.toPrimitive, Symbol.toStringTag, Symbol.iterator])
+
+// Shared, so `stub.toString === stub.toString` holds.
+const readAsEmptyString = (): string => ''
+function* iterateAsEmpty(): Generator<never> {}
+
+// Not `Symbol.for`, whose key is global and could collide with another library's.
+const CALL_RESULT_KEY = Symbol('call-result')
+
+/**
+ * Inert but still truthy — a component branching on a stubbed flag takes the truthy path, which
+ * is why stubbed services are reported to the caller.
+ */
+function createServiceStub(servicePath: string): unknown {
+  const childStubs = new Map<PropertyKey, unknown>()
+
+  // Arrow function: callable, and owns no non-configurable props that would make the
+  // `ownKeys`/`getOwnPropertyDescriptor` traps below violate the Proxy invariants.
+  const callableTarget = (): void => {}
+
+  return new Proxy(callableTarget, {
+    get(_target, property) {
+      if (NEVER_STUBBED_PROPERTIES.has(property)) {
+        return undefined
+      }
+      if (property === Symbol.toPrimitive || property === 'valueOf' || property === 'toString') {
+        return readAsEmptyString
+      }
+      if (property === Symbol.toStringTag) {
+        return 'WixServiceStub'
+      }
+      if (property === Symbol.iterator) {
+        return iterateAsEmpty
+      }
+      if (typeof property === 'symbol') {
+        return undefined
+      }
+
+      const existingChildStub = childStubs.get(property)
+      if (existingChildStub !== undefined) {
+        return existingChildStub
+      }
+
+      const childStub = createServiceStub(`${servicePath}.${property}`)
+      childStubs.set(property, childStub)
+      return childStub
+    },
+
+    apply() {
+      const existingCallResult = childStubs.get(CALL_RESULT_KEY)
+      if (existingCallResult !== undefined) {
+        return existingCallResult
+      }
+
+      const callResult = createServiceStub(`${servicePath}()`)
+      childStubs.set(CALL_RESULT_KEY, callResult)
+      return callResult
+    },
+
+    // Mirrors `get`, so `in` never reports a property that reads back as undefined.
+    has: (_target, property) => {
+      if (NEVER_STUBBED_PROPERTIES.has(property)) {
+        return false
+      }
+      return typeof property === 'symbol' ? HANDLED_SYMBOLS.has(property) : true
+    },
+    set: () => true,
+    // No own keys, so spreading terminates instead of recursing forever.
+    ownKeys: () => [],
+    getOwnPropertyDescriptor: () => undefined,
+  })
+}
+
+export interface AutoStubFallbackOptions {
+  /** Invoked once per distinct service id. */
+  onServiceStubbed?: (serviceId: string) => void
+}
+
+/**
+ * `createServicesManager` delegates to its `parentServicesManager` for unbound definitions, so
+ * passing this as the parent turns a "Service X is not provided" throw into an inert stub.
+ */
+export function createAutoStubFallbackManager(options: AutoStubFallbackOptions = {}): ServicesManager {
+  const stubsByServiceId = new Map<string, unknown>()
+
+  const getService = (definition: ServiceDefinitionLike): never => {
+    const serviceId = definition.toString()
+
+    const existingStub = stubsByServiceId.get(serviceId)
+    if (existingStub !== undefined) {
+      return existingStub as never
+    }
+
+    const stub = createServiceStub(serviceId)
+    stubsByServiceId.set(serviceId, stub)
+    options.onServiceStubbed?.(serviceId)
+    return stub as never
+  }
+
+  const fallbackManager: ServicesManager = {
+    getService: getService as ServicesManager['getService'],
+    hasService: () => true,
+    addService: () => {},
+    addServices: () => {},
+    dispose: () => {},
+    extend: (servicesMap: ServicesRegistrar) => createServicesManager(servicesMap, fallbackManager),
+  }
+
+  return fallbackManager
+}

package/src/extensions/wix-services/wrapper.test.ts

@@ -0,0 +1,63 @@
+import { useService } from '@wix/services-manager-react'
+import type { ServiceDefinition } from '@wix/services-manager/types'
+import { TranslationsDefinition } from '@wix/viewer-service-translations/definition'
+import React, { type ComponentType } from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
+import { describe, expect, it, vi } from 'vitest'
+import { wrapWithWixServices } from './wrapper'
+
+const UnregisteredDefinition = '@wix/example-unregistered-analytics' as unknown as ServiceDefinition<
+  { trackingId: string },
+  never
+>
+
+function renderThroughWrapper(Component: ComponentType<unknown>): string {
+  return renderToStaticMarkup(React.createElement(wrapWithWixServices(Component), {}))
+}
+
+describe('wrapWithWixServices', () => {
+  it('resolves a registered service to its real implementation, stubbing nothing', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    const TranslatingComponent: ComponentType<unknown> = () => {
+      const translations = useService(TranslationsDefinition)
+      return React.createElement('span', null, translations.translate('app')('greeting') ?? 'fallback-text')
+    }
+
+    // The real service echoes the key back; a stub would have produced an empty string.
+    expect(renderThroughWrapper(TranslatingComponent)).toContain('<span>greeting</span>')
+    expect(warn).not.toHaveBeenCalled()
+
+    warn.mockRestore()
+  })
+
+  it('warns per extraction', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    const AnalyticsComponent: ComponentType<unknown> = () => {
+      useService(UnregisteredDefinition)
+      return null
+    }
+
+    // A module-level dedupe would leave every component after the first silently degraded.
+    renderThroughWrapper(AnalyticsComponent)
+    renderThroughWrapper(AnalyticsComponent)
+
+    expect(warn).toHaveBeenCalledTimes(2)
+
+    warn.mockRestore()
+  })
+
+  it('renders a component that reads an unregistered service instead of throwing', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    const AnalyticsComponent: ComponentType<unknown> = () => {
+      const analytics = useService(UnregisteredDefinition)
+      return React.createElement('div', { 'data-tracking-id': String(analytics.trackingId) }, 'rendered')
+    }
+
+    expect(renderThroughWrapper(AnalyticsComponent)).toContain('<div data-tracking-id="">rendered</div>')
+
+    warn.mockRestore()
+  })
+})

package/src/extensions/wix-services/wrapper.ts

@@ -0,0 +1,204 @@
+import { SeoServiceDefinition } from '@wix/seo-service/definition'
+import { createSeoService } from '@wix/seo-service/implementations'
+import { createServicesManager, createServicesMap } from '@wix/services-manager'
+import { ServicesManagerProvider } from '@wix/services-manager-react'
+import {
+  ProvideComponentServiceDefinition,
+  ProvideComponentServiceFactory,
+} from '@wix/services-manager-react/core-services/provide-component'
+import type { ServiceBinding } from '@wix/services-manager/types'
+import { ConfigurationDefinition } from '@wix/site-service-configuration/definition'
+import { ConfigurationService } from '@wix/site-service-configuration/implementations'
+import { DeviceInfoDefinition } from '@wix/site-service-device-info/definition'
+import { DeviceInfoService } from '@wix/site-service-device-info/implementations'
+import { EditorContextDefinition } from '@wix/site-service-editor-context/definition'
+import { EditorContextService } from '@wix/site-service-editor-context/implementations'
+import { ExperimentsDefinition } from '@wix/site-service-experiments/definition'
+import { ExperimentsService } from '@wix/site-service-experiments/implementations'
+import { LocaleDefinition } from '@wix/site-service-locale/definition'
+import { LocaleService } from '@wix/site-service-locale/implementations'
+import type { IPagesServiceConfig, Page } from '@wix/site-service-pages/definition'
+import { PagesDefinition } from '@wix/site-service-pages/definition'
+import { PagesService } from '@wix/site-service-pages/implementations'
+import { ProvideCssDefinition as SiteProvideCssDefinition } from '@wix/site-service-provide-css/definition'
+import { ProvideCssService as SiteProvideCssService } from '@wix/site-service-provide-css/implementations'
+import { RenderingContextDefinition } from '@wix/site-service-rendering-context/definition'
+import { RenderingContextService } from '@wix/site-service-rendering-context/implementations'
+import { UrlDefinition as SiteUrlDefinition } from '@wix/site-service-url/definition'
+import { UrlService as SiteUrlService } from '@wix/site-service-url/implementations'
+import { AnchorsDefinition } from '@wix/viewer-service-anchors/definition'
+import { AnchorsService } from '@wix/viewer-service-anchors/implementations'
+import { ConsentPolicyDefinition } from '@wix/viewer-service-consent-policy/definition'
+import { ConsentPolicyService } from '@wix/viewer-service-consent-policy/implementations'
+import { EnvironmentDefinition } from '@wix/viewer-service-environment/definition'
+import { EnvironmentService } from '@wix/viewer-service-environment/implementations'
+import { LinkUtilsDefinition } from '@wix/viewer-service-link-utils/definition'
+import { LinkUtilsService } from '@wix/viewer-service-link-utils/implementations'
+import { NamedSignalsDefinition } from '@wix/viewer-service-named-signals/definition'
+import { NamedSignalsService } from '@wix/viewer-service-named-signals/implementations'
+import type { IPagesServiceConfig as IViewerPagesServiceConfig } from '@wix/viewer-service-pages/definition'
+import { PagesDefinition as ViewerPagesDefinition } from '@wix/viewer-service-pages/definition'
+import { PagesService as ViewerPagesService } from '@wix/viewer-service-pages/implementations'
+import { ProvideCssDefinition } from '@wix/viewer-service-provide-css/definition'
+import { ProvideCssService } from '@wix/viewer-service-provide-css/implementations'
+import { RendererConfigurationDefinition } from '@wix/viewer-service-renderer-configuration/definition'
+import { RendererConfigurationService } from '@wix/viewer-service-renderer-configuration/implementations'
+import { SdkStateDefinition } from '@wix/viewer-service-sdk-state/definition'
+import { SdkStateService } from '@wix/viewer-service-sdk-state/implementations'
+import { SiteScrollBlockerDefinition } from '@wix/viewer-service-site-scroll-blocker/definition'
+import { SiteScrollBlockerService } from '@wix/viewer-service-site-scroll-blocker/implementations'
+import type { Topology } from '@wix/viewer-service-topology/definition'
+import { TopologyDefinition } from '@wix/viewer-service-topology/definition'
+import { TopologyService } from '@wix/viewer-service-topology/implementations'
+import { TranslationsDefinition } from '@wix/viewer-service-translations/definition'
+import { TranslationsService } from '@wix/viewer-service-translations/implementations'
+import { UrlDefinition } from '@wix/viewer-service-url/definition'
+import { UrlService } from '@wix/viewer-service-url/implementations'
+import React, { type ComponentType, type ReactNode } from 'react'
+
+import { createAutoStubFallbackManager } from './service-stub'
+
+const PLACEHOLDER_SITE_URL = 'https://wix.com'
+const PLACEHOLDER_EXPERIMENTS = {
+  'specs.thunderbolt.isClassNameToRootEnabled': true,
+}
+const PLACEHOLDER_HOME_PAGE: Page = {
+  id: 'home',
+  title: 'Home',
+  path: '/',
+  popup: false,
+}
+const PLACEHOLDER_CURRENT_PAGE: Page = {
+  id: 'audio',
+  title: 'Audio',
+  path: '/shop/audio',
+  parentPageId: 'shop',
+  popup: false,
+}
+const PLACEHOLDER_PAGES_CONFIG: IPagesServiceConfig = {
+  pages: {
+    home: { title: 'Home', path: '/', popup: false },
+    shop: { title: 'Shop', path: '/shop', parentPageId: 'home', popup: false },
+    audio: { title: 'Audio', path: '/shop/audio', parentPageId: 'shop', popup: false },
+  },
+  mainPage: PLACEHOLDER_HOME_PAGE,
+  currentPage: PLACEHOLDER_CURRENT_PAGE,
+}
+
+/** Derived, so the deprecated pages service and its successor describe the same site. */
+const PLACEHOLDER_VIEWER_PAGES_CONFIG: IViewerPagesServiceConfig = {
+  pages: Object.fromEntries(
+    Object.entries(PLACEHOLDER_PAGES_CONFIG.pages).map(([pageId, { title, path, parentPageId }]) => [
+      pageId,
+      { title, path, parentPageId },
+    ]),
+  ),
+  currentPageId: PLACEHOLDER_PAGES_CONFIG.currentPage.id,
+  mainPageId: PLACEHOLDER_PAGES_CONFIG.mainPage.id,
+}
+
+const PLACEHOLDER_TOPOLOGY: Topology = {
+  mediaRootUrl: 'https://static.wixstatic.com/',
+  staticMediaUrl: 'https://static.wixstatic.com/media',
+  fileRepoUrl: 'https://static.wixstatic.com/ugd',
+  staticHTMLComponentUrl: 'https://static.wixstatic.com/html',
+  scriptsUrl: 'https://static.parastorage.com/',
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: service bindings are heterogeneous by construction
+type AnyServiceBinding = ServiceBinding<any, any>
+
+/** Anything omitted here resolves through {@link createAutoStubFallbackManager} instead. */
+function createServiceBindings(): AnyServiceBinding[] {
+  return [
+    {
+      definition: EnvironmentDefinition,
+      impl: EnvironmentService,
+      config: { experiments: PLACEHOLDER_EXPERIMENTS },
+    },
+    { definition: TranslationsDefinition, impl: TranslationsService, config: { translations: {} } },
+    {
+      definition: UrlDefinition,
+      impl: UrlService,
+      config: { externalBaseUrl: PLACEHOLDER_SITE_URL, requestUrl: PLACEHOLDER_SITE_URL },
+    },
+    { definition: LinkUtilsDefinition, impl: LinkUtilsService, config: {} },
+    { definition: AnchorsDefinition, impl: AnchorsService, config: {} },
+    { definition: SiteScrollBlockerDefinition, impl: SiteScrollBlockerService, config: {} },
+    { definition: ProvideCssDefinition, impl: ProvideCssService, config: {} },
+    { definition: RenderingContextDefinition, impl: RenderingContextService, config: {} },
+    { definition: ExperimentsDefinition, impl: ExperimentsService, config: { experiments: PLACEHOLDER_EXPERIMENTS } },
+    {
+      definition: ConfigurationDefinition,
+      impl: ConfigurationService,
+      config: { qaMode: false, trackClicksAnalytics: false, sandboxInHTMLComp: false },
+    },
+    { definition: SiteProvideCssDefinition, impl: SiteProvideCssService, config: {} },
+    { definition: DeviceInfoDefinition, impl: DeviceInfoService, config: {} },
+    { definition: EditorContextDefinition, impl: EditorContextService, config: { previewMode: false } },
+    {
+      definition: SiteUrlDefinition,
+      impl: SiteUrlService,
+      config: {
+        currentUrl: PLACEHOLDER_SITE_URL,
+        siteUrl: PLACEHOLDER_SITE_URL,
+        pages: [],
+        pageIdToPrefix: {},
+      },
+    },
+    { definition: PagesDefinition, impl: PagesService, config: PLACEHOLDER_PAGES_CONFIG },
+    { definition: ViewerPagesDefinition, impl: ViewerPagesService, config: PLACEHOLDER_VIEWER_PAGES_CONFIG },
+    { definition: LocaleDefinition, impl: LocaleService, config: { language: 'en', direction: 'ltr' } },
+    { definition: TopologyDefinition, impl: TopologyService, config: { topology: PLACEHOLDER_TOPOLOGY } },
+    {
+      definition: RendererConfigurationDefinition,
+      impl: RendererConfigurationService,
+      config: { isHipaaCompliant: false, currency: 'USD' },
+    },
+    { definition: SdkStateDefinition, impl: SdkStateService, config: {} },
+    { definition: NamedSignalsDefinition, impl: NamedSignalsService, config: {} },
+    { definition: ConsentPolicyDefinition, impl: ConsentPolicyService, config: { siteConsentPolicy: undefined } },
+    {
+      definition: SeoServiceDefinition,
+      impl: createSeoService,
+      config: { seoApi: { setVeloSeoTags: async () => {}, resetVeloSeoTags: async () => {} } },
+    },
+    { definition: ProvideComponentServiceDefinition, impl: ProvideComponentServiceFactory, config: {} },
+  ]
+}
+
+/** Dedupes per wrapper instance, so every extraction reports its own stubs. */
+function createStubbedServiceReporter(): (serviceId: string) => void {
+  const reportedServiceIds = new Set<string>()
+
+  return (serviceId) => {
+    if (reportedServiceIds.has(serviceId)) {
+      return
+    }
+    reportedServiceIds.add(serviceId)
+    console.warn(
+      `[zero-config] Service "${serviceId}" is not registered by the extraction wrapper and was replaced with an inert stub. Branches depending on it may be missing from the extracted manifest.`,
+    )
+  }
+}
+
+/** Local replacement for `@wix/builder-services-wrapper`'s `WixServicesWrapper`. */
+export function WixServicesWrapper({ children }: { children?: ReactNode }): React.ReactElement {
+  // Memoized: the manager eagerly constructs every registered service on creation.
+  const servicesManager = React.useMemo(
+    () =>
+      createServicesManager(
+        createServicesMap(createServiceBindings()),
+        createAutoStubFallbackManager({ onServiceStubbed: createStubbedServiceReporter() }),
+      ),
+    [],
+  )
+
+  return React.createElement(ServicesManagerProvider, { servicesManager }, children)
+}
+
+export function wrapWithWixServices(Component: ComponentType<unknown>): ComponentType<unknown> {
+  const WrappedComponent: ComponentType<unknown> = (props) =>
+    React.createElement(WixServicesWrapper, null, React.createElement(Component, props as Record<string, unknown>))
+  return WrappedComponent
+}

package/src/index.ts

@@ -1,4 +1,3 @@
-import { WixServicesWrapper } from '@wix/builder-services-wrapper'
 import type { EditorReactComponent } from '@wix/react-component-schema'
 import { Result, ResultAsync } from 'neverthrow'
 import React, { type ComponentType } from 'react'
@@ -9,6 +8,7 @@ import { buildContextProviderModules } from './extensions/context-providers/cont
 import { buildContextAwareWrapper, loadMockProviders } from './extensions/context-providers/mock-provider'
 import { buildRefElementContext } from './extensions/ref-elements/context'
 import type { RefElementContext } from './extensions/ref-elements/types'
+import { wrapWithWixServices } from './extensions/wix-services/wrapper'
 import type { ExtractionError } from './extraction-types'
 import type { RunExtractorsOptions } from './information-extractors/react'
 import { extractCssImports, extractDefaultComponentInfo } from './information-extractors/ts'
@@ -17,11 +17,7 @@ import { processComponent } from './manifest-pipeline'
 import { findComponent, findDefaultComponent, loadModuleForExtraction } from './module-loader'
 import { compileTsFile } from './ts-compiler'
 
-const defaultWrapper = (Component: ComponentType<unknown>): ComponentType<unknown> => {
-  const WrappedComponent: ComponentType<unknown> = (props) =>
-    React.createElement(WixServicesWrapper, null, React.createElement(Component, props as Record<string, unknown>))
-  return WrappedComponent
-}
+const defaultWrapper = wrapWithWixServices
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types