add resolveImports, fix bug

packages/@inlay/render/src/index.ts

···
 export type RenderOptions = {
   resolver: Resolver;
   maxDepth?: number;
+  resolveImports?: (imports: DidString[], nsid: string) => DidString[];
 };
 
 /**
···
       throw Error("Component depth limit exceeded");
     }
 
+    const effectiveImports = options.resolveImports
+      ? options.resolveImports(ctx.imports, type)
+      : ctx.imports;
     const { component, componentUri } = await resolveType(
       type,
-      ctx.imports,
+      effectiveImports,
       resolver
     );
     return await renderComponent(

packages/@inlay/render/src/validate.ts

···
       unknown
     >;
   } else if (component.view) {
-    // Synthesize validation from view entries (viewPrimitive + viewRecord)
+    // Synthesize validation from view entries.
+    // viewRecord → validate the view prop is an AT URI string.
+    // viewPrimitive → declare the prop exists (required) as unknown.
+    //   The primitive type is metadata for editor toolbox matching, not a
+    //   runtime constraint — a component accepting strings can also receive
+    //   elements, arrays, etc. via JSX children.
     const { prop: viewProp, accepts } = component.view;
     const primitives = accepts.filter((v) => viewPrimitiveSchema.isTypeOf(v));
     const records = accepts.filter((v) => viewRecordSchema.isTypeOf(v));
···
         { type: string; formats: Set<string> }
       >();
 
-      // viewPrimitive entries define typed props
-      for (const vp of primitives) {
-        const existing = propEntries.get(viewProp);
-        if (existing) {
-          if (vp.format) existing.formats.add(vp.format);
-        } else {
-          const formats = new Set<string>();
-          if (vp.format) formats.add(vp.format);
-          propEntries.set(viewProp, { type: vp.type, formats });
-        }
-      }
+      // viewPrimitive entries are NOT added to synthesized validation.
+      // The primitive type is metadata for editor toolbox matching; runtime
+      // validation of the view prop only applies when viewRecord constrains
+      // it to an AT URI string.
 
       // viewRecord entries imply a string prop (at-uri or did format)
       for (const vr of records) {

packages/@inlay/render/test/render.test.ts

···
 });
 
 // ============================================================================
+// 3b. resolveImports — caller-controlled import filtering
+// ============================================================================
+//
+// The resolveImports option lets the host rewrite the import list before
+// type resolution. It receives the component's imports and the NSID being
+// resolved, and returns the DID list that should actually be searched.
+
+describe("resolveImports", () => {
+  const FANCY_DID = "did:plc:fancy";
+  const CASUAL_DID = "did:plc:casual";
+
+  const fancyGreeting: ComponentRecord = {
+    $type: "at.inlay.component",
+    body: {
+      $type: "at.inlay.component#bodyTemplate",
+      node: serializeTree($(Text, { value: "Greetings, friend!" })),
+    },
+    imports: [HOST_DID],
+  };
+
+  const casualGreeting: ComponentRecord = {
+    $type: "at.inlay.component",
+    body: {
+      $type: "at.inlay.component#bodyTemplate",
+      node: serializeTree($(Text, { value: "Hi" })),
+    },
+    imports: [HOST_DID],
+  };
+
+  it("filters imports per NSID", async () => {
+    // Root imports both fancy and casual, but resolveImports drops fancy
+    // for Greeting — so casual wins even though fancy is listed first.
+    const rootComponent: ComponentRecord = {
+      $type: "at.inlay.component",
+      body: {
+        $type: "at.inlay.component#bodyTemplate",
+        node: serializeTree($(Greeting, {})),
+      },
+      imports: [FANCY_DID, CASUAL_DID],
+    };
+
+    const records = {
+      ...HOST_RECORDS,
+      [`at://${FANCY_DID}/at.inlay.component/${Greeting}`]: fancyGreeting,
+      [`at://${CASUAL_DID}/at.inlay.component/${Greeting}`]: casualGreeting,
+    };
+
+    const { options, log } = testResolver(records);
+    options.resolveImports = (imports, nsid) => {
+      if (nsid === Greeting) {
+        return imports.filter((d) => d !== FANCY_DID) as DidString[];
+      }
+      return imports;
+    };
+
+    const output = await renderToCompletion(
+      $(Root, {}),
+      options,
+      createContext(rootComponent, `at://${APP_DID}/at.inlay.component/${Root}`)
+    );
+
+    assert.deepEqual(output, h("span", { value: "Hi" }));
+    // Only casual DID is fetched for Greeting — fancy was filtered out
+    assertLog(log, [
+      `lexicon ${Root}`,
+      `fetch at://${CASUAL_DID}/at.inlay.component/${Greeting}`,
+      `lexicon ${Greeting}`,
+      `fetch at://${HOST_DID}/at.inlay.component/${Text}`,
+      `lexicon ${Text}`,
+    ]);
+  });
+
+  it("can reroute a nested type without affecting its parent", async () => {
+    // Root's template renders Greeting, whose template renders Text.
+    // resolveImports only redirects Text to a different DID — Greeting
+    // still resolves normally through casual, but Text picks up the
+    // alternate DID's implementation (a bold primitive instead of span).
+    const ALT_DID = "did:plc:alt";
+    const Bold = "test.host.Bold" as const;
+
+    const altText: ComponentRecord = {
+      $type: "at.inlay.component",
+      body: {
+        $type: "at.inlay.component#bodyTemplate",
+        node: serializeTree($(Bold, { value: "Hi" })),
+      },
+      imports: [ALT_DID],
+    };
+
+    const rootComponent: ComponentRecord = {
+      $type: "at.inlay.component",
+      body: {
+        $type: "at.inlay.component#bodyTemplate",
+        node: serializeTree($(Greeting, {})),
+      },
+      imports: [CASUAL_DID],
+    };
+
+    const { options } = testResolver({
+      ...HOST_RECORDS,
+      [`at://${CASUAL_DID}/at.inlay.component/${Greeting}`]: casualGreeting,
+      // Alt DID provides a different Text that wraps in Bold
+      [`at://${ALT_DID}/at.inlay.component/${Text}`]: altText,
+      [`at://${ALT_DID}/at.inlay.component/${Bold}`]: {
+        $type: "at.inlay.component",
+      },
+    });
+
+    options.resolveImports = (imports, nsid) => {
+      // Only redirect Text resolution to alt DID
+      if (nsid === Text) return [ALT_DID] as DidString[];
+      return imports;
+    };
+
+    const output = await renderToCompletion(
+      $(Root, {}),
+      options,
+      createContext(
+        rootComponent,
+        `at://${APP_DID}/at.inlay.component/${Root}`
+      ),
+      { [Bold]: async (el) => h("b", { ...el.props, key: el.key }) }
+    );
+
+    // Greeting resolved normally (casual → "Hi"), but its inner Text
+    // was rerouted to alt DID which wraps in Bold instead of span.
+    assert.deepEqual(output, h("b", { value: "Hi" }));
+  });
+
+  it("defaults to unmodified imports when not provided", async () => {
+    // Same setup as "first DID wins" — fancy is first and wins.
+    const rootComponent: ComponentRecord = {
+      $type: "at.inlay.component",
+      body: {
+        $type: "at.inlay.component#bodyTemplate",
+        node: serializeTree($(Greeting, {})),
+      },
+      imports: [FANCY_DID, CASUAL_DID],
+    };
+
+    const { options } = testResolver({
+      ...HOST_RECORDS,
+      [`at://${FANCY_DID}/at.inlay.component/${Greeting}`]: fancyGreeting,
+      [`at://${CASUAL_DID}/at.inlay.component/${Greeting}`]: casualGreeting,
+    });
+
+    // No resolveImports set — default behavior
+    const output = await renderToCompletion(
+      $(Root, {}),
+      options,
+      createContext(rootComponent, `at://${APP_DID}/at.inlay.component/${Root}`)
+    );
+
+    assert.deepEqual(output, h("span", { value: "Greetings, friend!" }));
+  });
+});
+
+// ============================================================================
 // 4. Import isolation — each component has its own package.json
 // ============================================================================
 //
···
     assertError(bad, "Input/uri must be a string", `    at ${Card}`);
   });
 
-  it("synthesizes validation from viewPrimitive", async () => {
+  it("viewPrimitive does not synthesize runtime validation", async () => {
+    // viewPrimitive describes what data types a component can display
+    // (for editor toolbox matching) but should NOT constrain prop types
+    // at runtime — a component accepting strings can also receive other
+    // values via JSX children or programmatic usage.
     const timestampComponent: ComponentRecord = {
       $type: "at.inlay.component",
       body: {
···
       `at://${APP_DID}/at.inlay.component/${Timestamp}`
     );
 
+    // String value works
     const ok = await renderToCompletion(
       $(Timestamp, { value: "2026-01-01T00:00:00Z" }),
       options,
···
     );
     assert.deepEqual(ok, h("span", {}));
 
-    const bad = await renderToCompletion(
+    // Non-string value also passes (no synthesized validation)
+    const alsoOk = await renderToCompletion(
       $(Timestamp, { value: 123 as unknown as string }),
       options,
       ctx
     );
-    assertError(bad, "Input/value must be a string", `    at ${Timestamp}`);
+    assert.deepEqual(alsoOk, h("span", {}));
   });
 
   it("validates collection constraints from viewRecord", async () => {