forgeframe 0.0.6 → 0.0.10

package/dist/constants.d.ts

@@ -79,7 +79,7 @@ export declare const PROP_SERIALIZATION: {
     readonly JSON: "json";
     /** Base64 encoding for binary or large data */
     readonly BASE64: "base64";
-    /** Dot notation for nested objects (e.g., "a.b.c=value") */
+    /** Explicit framed-path encoding for nested objects */
     readonly DOTIFY: "dotify";
 };
 /**

package/dist/core/consumer/props-pipeline.d.ts

@@ -14,6 +14,14 @@ export interface ConsumerPropsUpdateHooks<P extends Record<string, unknown>> {
     sendPropsUpdateToHost: (nextProps: P) => Promise<void>;
     emitPropsUpdated: (nextProps: P) => void;
 }
+/**
+ * Hooks required to queue a host sync for the current props snapshot.
+ * @internal
+ */
+export interface ConsumerPropsSyncHooks<P extends Record<string, unknown>> {
+    shouldSendPropsToHost: () => boolean;
+    sendPropsUpdateToHost: (nextProps: P) => Promise<void>;
+}
 /**
  * Owns consumer prop normalization, validation, and update queueing.
  * @internal
@@ -39,6 +47,14 @@ export declare class ConsumerPropsPipeline<P extends Record<string, unknown>> {
      * Applies a props update and synchronizes it to the host when connected.
      */
     updateProps(newProps: Partial<P>, hooks: ConsumerPropsUpdateHooks<P>): Promise<void>;
+    /**
+     * Queues a host synchronization for the current props snapshot.
+     *
+     * @remarks
+     * This shares the same serialization queue as updateProps so function bridge
+     * batches cannot overlap with user-initiated prop updates.
+     */
+    syncCurrentPropsToHost(hooks: ConsumerPropsSyncHooks<P>): Promise<void>;
     /**
      * Queues prop updates when a previous host sync is in flight.
      */

package/dist/core/consumer/renderer.d.ts

@@ -32,6 +32,8 @@ export declare class ConsumerRenderer<P extends Record<string, unknown>> {
     container: HTMLElement | null;
     /** Prerender element currently displayed while host initializes. */
     prerenderElement: HTMLElement | null;
+    /** Wrapper element created and owned by the renderer. */
+    private ownedContainer;
     constructor(options: NormalizedOptions<P>, uid: string, getProps: () => P, resolveDimensions: () => Dimensions, callbacks: {
         close: () => Promise<void>;
         focus: () => Promise<void>;

package/dist/core/consumer/transport.d.ts

@@ -14,6 +14,7 @@ interface PeerRequest {
  * @internal
  */
 export interface ConsumerTransportHandlers<X> {
+    onInit?: () => void | Promise<void>;
     onClose: () => Promise<void>;
     onResize: (dimensions: Dimensions) => Promise<void>;
     onFocus: () => Promise<void>;

package/dist/core/consumer.d.ts

@@ -59,6 +59,8 @@ export declare class ConsumerComponent<P extends Record<string, unknown>, X = un
     /** @internal */
     private destroyed;
     /** @internal */
+    private closing;
+    /** @internal */
     private get props();
     /** @internal */
     private set props(value);
@@ -325,6 +327,16 @@ export declare class ConsumerComponent<P extends Record<string, unknown>, X = un
      * @internal
      */
     private setupMessageHandlers;
+    /**
+     * Synchronizes sameDomain props after the host proves its loaded origin via INIT.
+     * @internal
+     */
+    private syncSameDomainPropsAfterInit;
+    /**
+     * Returns true when any prop definition is restricted to same-origin hosts.
+     * @internal
+     */
+    private hasSameDomainPropDefinition;
     /**
      * Gets sibling component instances for a request.
      * @internal

package/dist/core/host.d.ts

@@ -47,6 +47,8 @@ export declare class HostComponent<P extends Record<string, unknown>> {
     /** @internal */
     private consumerDomain;
     /** @internal */
+    private consumerDomainVerified;
+    /** @internal */
     private messenger;
     /** @internal */
     private bridge;
@@ -93,6 +95,42 @@ export declare class HostComponent<P extends Record<string, unknown>> {
      * @internal
      */
     private validateConsumerDomain;
+    /**
+     * Reads a browser-verifiable consumer origin when available.
+     * @internal
+     */
+    private getVerifiedConsumerOrigin;
+    /**
+     * Updates the tracked consumer origin and keeps trusted messaging origins in sync.
+     * @internal
+     */
+    private setConsumerDomain;
+    /**
+     * Applies host configuration that may arrive after deferred pre-initialization.
+     * @internal
+     */
+    applyHostConfiguration(propDefinitions?: PropsDefinition<P>, allowedConsumerDomains?: DomainMatcher): void;
+    /**
+     * Resolves the consumer origin from browser-provided context and falls back to the
+     * claimed bootstrap origin only when no explicit allowlist is configured.
+     * @internal
+     */
+    private resolveConsumerDomain;
+    /**
+     * Rechecks allowlist constraints against a browser-verified consumer origin.
+     * @internal
+     */
+    assertAllowedConsumerDomain(allowedConsumerDomains: DomainMatcher): void;
+    /**
+     * Reads the consumer origin from the browser-provided referrer when available.
+     * @internal
+     */
+    private getReferrerOrigin;
+    /**
+     * Reads the consumer origin directly when same-origin access is available.
+     * @internal
+     */
+    private getAccessibleConsumerOrigin;
     /**
      * Returns the hostProps object.
      *
@@ -109,6 +147,12 @@ export declare class HostComponent<P extends Record<string, unknown>> {
      * @internal
      */
     private buildHostProps;
+    /**
+     * Relaxes required sameDomain props during bootstrap for verified same-origin hosts.
+     * Those props are synchronized after INIT through the live messaging channel.
+     * @internal
+     */
+    private getBootstrapValidationDefinitions;
     /**
      * Sends initialization message to the consumer.
      * @internal

package/dist/drivers/react.d.ts

@@ -17,7 +17,7 @@ interface ReactLike {
     };
     useEffect: (effect: () => void | (() => void), deps?: unknown[]) => void;
     useState: <T>(initial: T) => [T, (v: T) => void];
-    forwardRef: <T, P>(render: (props: P, ref: {
+    forwardRef: <T, P>(render: (props: P, ref: ((value: T | null) => void) | {
         current: T | null;
     } | null) => unknown) => unknown;
 }