@world-engines/view-exposure 0.0.0

package/LICENSE

@@ -0,0 +1,46 @@
+WorldEngine 官方作者工具许可证
+
+版权所有 (c) 2026 Nixdorfer。保留所有权利。
+
+本仓库的源代码、构建材料及附带资源（统称“本作品”）不是开源软件，
+不适用任何 OSI 认证的开源许可证。
+
+一、官方作者工具分发许可
+
+版权所有者可以通过其官方网站、npm registry、签名安装包或其他官方渠道，
+复制并分发由本作品构建的 WorldEngine 作者工具及其必要运行资源
+（统称“官方作者工具”）。仅版权所有者或其书面指定的发布者享有此分发权。
+
+二、作者用户许可
+
+从官方渠道取得官方作者工具的作者用户，可以：
+
+1. 安装和运行官方作者工具；
+2. 使用官方作者工具创作、编辑、预览、导入、导出和提交其有权处理的内容；
+3. 为上述使用目的制作合理必要的本地备份副本。
+
+三、未授予的权利
+
+除第二条明确允许的行为外，本许可证不授予作者用户或其他第三方以下权利：
+
+1. 修改、改编、反编译、反汇编或制作官方作者工具的派生作品；
+2. 复制、镜像、转发、再上传、出售、出租、再分发或再许可官方作者工具；
+3. 使用本作品的源代码、构建材料或任何部分开发、提供或训练其他产品或服务；
+4. 删除或规避版权、许可、签名、访问控制或其他权利管理信息。
+
+法律强制允许且合同不得排除的权利不受上述限制影响。
+
+四、源代码查看
+
+第三方可以在已获合法访问权限的范围内查看本作品，用于审查、安全研究或学习参考；
+查看不授予运行、复制、修改、分发、再许可或用于其他产品与服务的权利。
+
+五、无担保与责任限制
+
+本作品与官方作者工具均按“现状”提供，不附带任何明示或暗示的担保。
+在适用法律允许的最大范围内，版权所有者不对因访问或使用本作品或官方作者工具
+造成的任何损失承担责任。
+
+六、终止
+
+违反本许可证将立即终止相应的访问与使用权；终止不影响版权所有者已经产生的权利和救济。

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { filterForLlm, filterForTrigger, directorViewToolDescriptors, parseViewExposureManifest, stableViewExposureHash, triggerViewActionRegistrations } from "./normalize.js";
+export { VIEW_EXPOSURE_LIMITS, VIEW_EXPOSURE_RESERVED_NAMES, VIEW_EXPOSURE_SCHEMA_VERSION, type ExposureRole, type DirectorViewToolDescriptor, type ExposureTarget, type LlmControlPolicy, type MessageAction, type MessagePolicy, type NormalizedViewExposureManifest, type PromptSlotAction, type PromptSlotPolicy, type StrictParametersSchema, type StrictSchema, type TriggerViewActionRegistration, type ViewExposureFunction, type ViewExposureManifest, type ViewExposureParseResult } from "./schema.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { filterForLlm, filterForTrigger, directorViewToolDescriptors, parseViewExposureManifest, stableViewExposureHash, triggerViewActionRegistrations } from "./normalize.js";
+export { VIEW_EXPOSURE_LIMITS, VIEW_EXPOSURE_RESERVED_NAMES, VIEW_EXPOSURE_SCHEMA_VERSION } from "./schema.js";

package/dist/normalize.d.ts

@@ -0,0 +1,7 @@
+import { type NormalizedViewExposureManifest, type ViewExposureFunction, type ViewExposureManifest, type ViewExposureParseResult, type DirectorViewToolDescriptor, type TriggerViewActionRegistration } from "./schema.js";
+export declare const stableViewExposureHash: (manifest: ViewExposureManifest) => string;
+export declare const parseViewExposureManifest: (input: unknown) => ViewExposureParseResult;
+export declare const filterForLlm: (manifest: NormalizedViewExposureManifest) => ReadonlyArray<ViewExposureFunction>;
+export declare const filterForTrigger: (manifest: NormalizedViewExposureManifest) => ReadonlyArray<ViewExposureFunction>;
+export declare const directorViewToolDescriptors: (manifest: NormalizedViewExposureManifest) => ReadonlyArray<DirectorViewToolDescriptor>;
+export declare const triggerViewActionRegistrations: (manifest: NormalizedViewExposureManifest) => ReadonlyArray<TriggerViewActionRegistration>;

package/dist/normalize.js

@@ -0,0 +1,276 @@
+import { VIEW_EXPOSURE_LIMITS as LIMIT, VIEW_EXPOSURE_RESERVED_NAMES, VIEW_EXPOSURE_SCHEMA_VERSION } from "./schema.js";
+const NAME = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
+const ENDPOINT = /^[A-Za-z0-9][A-Za-z0-9._:/-]*$/;
+const EFFECT = /^[a-z][a-z0-9]*(?:\.[a-z][a-z0-9]*)*$/;
+const PROP = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+const TARGETS = new Set(["llm", "trigger", "both"]);
+const ROLES = ["system", "user", "assistant"];
+const PROMPT_ACTIONS = new Set(["read", "append", "replace", "remove"]);
+const MESSAGE_ACTIONS = new Set(["insert", "replace", "remove"]);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const utf8Bytes = (value) => {
+    let bytes = 0;
+    for (const char of value) {
+        const point = char.codePointAt(0) ?? 0;
+        bytes += point <= 0x7f ? 1 : point <= 0x7ff ? 2 : point <= 0xffff ? 3 : 4;
+    }
+    return bytes;
+};
+const fail = (error) => ({ ok: false, error });
+const text = (value, field, max, pattern) => {
+    if (typeof value !== "string")
+        throw new Error(`${field}_must_be_string`);
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+        throw new Error(`${field}_must_not_be_empty`);
+    if (trimmed.length > max)
+        throw new Error(`${field}_too_long`);
+    if (pattern !== undefined && !pattern.test(trimmed))
+        throw new Error(`${field}_invalid`);
+    return trimmed;
+};
+const exactKeys = (raw, allowed, field) => {
+    const set = new Set(allowed);
+    for (const key of Object.keys(raw))
+        if (!set.has(key))
+            throw new Error(`${field}_unknown_key:${key}`);
+};
+const normalizeSchema = (raw, depth, field) => {
+    if (depth > LIMIT.schemaDepth)
+        throw new Error(`${field}_too_deep`);
+    if (!isRecord(raw))
+        throw new Error(`${field}_must_be_object`);
+    const type = raw.type;
+    const description = raw.description === undefined
+        ? undefined
+        : text(raw.description, `${field}.description`, LIMIT.descriptionChars);
+    const base = description === undefined ? {} : { description };
+    if (type === "string") {
+        exactKeys(raw, ["type", "description", "enum"], field);
+        if (raw.enum === undefined)
+            return { type, ...base };
+        if (!Array.isArray(raw.enum) || raw.enum.length === 0 || raw.enum.length > LIMIT.enumValues) {
+            throw new Error(`${field}.enum_invalid`);
+        }
+        const values = raw.enum.map((v, index) => text(v, `${field}.enum[${index}]`, LIMIT.enumValueChars));
+        if (new Set(values).size !== values.length)
+            throw new Error(`${field}.enum_duplicate`);
+        return { type, ...base, enum: values };
+    }
+    if (type === "number" || type === "integer" || type === "boolean") {
+        exactKeys(raw, ["type", "description"], field);
+        return { type, ...base };
+    }
+    if (type === "array") {
+        exactKeys(raw, ["type", "description", "items"], field);
+        return { type, ...base, items: normalizeSchema(raw.items, depth + 1, `${field}.items`) };
+    }
+    if (type !== "object")
+        throw new Error(`${field}.type_unsupported`);
+    exactKeys(raw, ["type", "description", "properties", "required", "additionalProperties"], field);
+    if (!isRecord(raw.properties))
+        throw new Error(`${field}.properties_invalid`);
+    const keys = Object.keys(raw.properties).sort();
+    if (keys.length > LIMIT.schemaProperties)
+        throw new Error(`${field}.properties_too_many`);
+    for (const key of keys)
+        if (!PROP.test(key))
+            throw new Error(`${field}.property_name_invalid:${key}`);
+    if (!Array.isArray(raw.required) || raw.required.some((v) => typeof v !== "string")) {
+        throw new Error(`${field}.required_invalid`);
+    }
+    const required = [...raw.required].sort();
+    if (required.length !== keys.length || required.some((value, index) => value !== keys[index])) {
+        throw new Error(`${field}.required_must_cover_all_properties`);
+    }
+    if (raw.additionalProperties !== false)
+        throw new Error(`${field}.additional_properties_must_be_false`);
+    const properties = {};
+    for (const key of keys)
+        properties[key] = normalizeSchema(raw.properties[key], depth + 1, `${field}.${key}`);
+    return { type, ...base, properties, required, additionalProperties: false };
+};
+const normalizeFunction = (raw, index) => {
+    const field = `functions[${index}]`;
+    if (!isRecord(raw))
+        throw new Error(`${field}_must_be_object`);
+    exactKeys(raw, ["id", "name", "label", "description", "target", "parameters", "returns", "handler", "effects"], field);
+    const id = text(raw.id, `${field}.id`, LIMIT.idChars, ID);
+    const name = text(raw.name, `${field}.name`, LIMIT.nameChars, NAME);
+    if (VIEW_EXPOSURE_RESERVED_NAMES.has(name))
+        throw new Error(`${field}.name_reserved`);
+    if (!TARGETS.has(String(raw.target)))
+        throw new Error(`${field}.target_invalid`);
+    const parameters = normalizeSchema(raw.parameters, 1, `${field}.parameters`);
+    if (parameters.type !== "object")
+        throw new Error(`${field}.parameters_must_be_object`);
+    if (!isRecord(raw.handler))
+        throw new Error(`${field}.handler_invalid`);
+    exactKeys(raw.handler, ["endpoint"], `${field}.handler`);
+    if (!Array.isArray(raw.effects) || raw.effects.length > LIMIT.effects)
+        throw new Error(`${field}.effects_invalid`);
+    const effects = raw.effects.map((v, i) => text(v, `${field}.effects[${i}]`, 128, EFFECT)).sort();
+    if (new Set(effects).size !== effects.length)
+        throw new Error(`${field}.effects_duplicate`);
+    const returns = normalizeSchema(raw.returns, 1, `${field}.returns`);
+    const normalized = {
+        id,
+        name,
+        label: text(raw.label, `${field}.label`, LIMIT.labelChars),
+        description: text(raw.description, `${field}.description`, LIMIT.descriptionChars),
+        target: raw.target,
+        parameters: parameters,
+        returns,
+        handler: { endpoint: text(raw.handler.endpoint, `${field}.handler.endpoint`, LIMIT.endpointChars, ENDPOINT) },
+        effects
+    };
+    if (utf8Bytes(JSON.stringify(normalized.parameters)) > LIMIT.schemaBytes)
+        throw new Error(`${field}.parameters_too_large`);
+    if (utf8Bytes(JSON.stringify(returns)) > LIMIT.schemaBytes)
+        throw new Error(`${field}.returns_too_large`);
+    return normalized;
+};
+const stringActions = (raw, allowed, field) => {
+    if (!Array.isArray(raw) || raw.some((v) => typeof v !== "string" || !allowed.has(v)))
+        throw new Error(`${field}_invalid`);
+    const values = [...raw].sort();
+    if (new Set(values).size !== values.length)
+        throw new Error(`${field}_duplicate`);
+    return values;
+};
+const normalizeLlmControl = (raw, functionIds) => {
+    if (!isRecord(raw))
+        throw new Error("llmControl_must_be_object");
+    exactKeys(raw, ["promptSlots", "messagePolicy"], "llmControl");
+    if (!Array.isArray(raw.promptSlots) || raw.promptSlots.length > LIMIT.promptSlots)
+        throw new Error("promptSlots_invalid");
+    const promptSlots = raw.promptSlots.map((slot, index) => {
+        const field = `promptSlots[${index}]`;
+        if (!isRecord(slot))
+            throw new Error(`${field}_must_be_object`);
+        exactKeys(slot, ["id", "role", "actions", "maxChars"], field);
+        if (!ROLES.includes(slot.role))
+            throw new Error(`${field}.role_invalid`);
+        if (!Number.isInteger(slot.maxChars) || Number(slot.maxChars) < 1 || Number(slot.maxChars) > LIMIT.promptSlotChars)
+            throw new Error(`${field}.maxChars_invalid`);
+        return {
+            id: text(slot.id, `${field}.id`, LIMIT.idChars, ID),
+            role: slot.role,
+            actions: stringActions(slot.actions, PROMPT_ACTIONS, `${field}.actions`),
+            maxChars: Number(slot.maxChars)
+        };
+    }).sort((a, b) => a.id.localeCompare(b.id));
+    if (new Set(promptSlots.map((slot) => slot.id)).size !== promptSlots.length)
+        throw new Error("promptSlots_id_duplicate");
+    const policy = raw.messagePolicy;
+    if (!isRecord(policy))
+        throw new Error("messagePolicy_must_be_object");
+    exactKeys(policy, ["roles", "scope", "maxMessages", "maxCharsPerMessage", "allowToolCalls", "allowedToolIds"], "messagePolicy");
+    if (!isRecord(policy.roles))
+        throw new Error("messagePolicy.roles_invalid");
+    exactKeys(policy.roles, ROLES, "messagePolicy.roles");
+    if (policy.scope !== "view_overlay")
+        throw new Error("messagePolicy.scope_invalid");
+    if (!Number.isInteger(policy.maxMessages) || Number(policy.maxMessages) < 0 || Number(policy.maxMessages) > LIMIT.messageCount)
+        throw new Error("messagePolicy.maxMessages_invalid");
+    if (!Number.isInteger(policy.maxCharsPerMessage) || Number(policy.maxCharsPerMessage) < 1 || Number(policy.maxCharsPerMessage) > LIMIT.messageChars)
+        throw new Error("messagePolicy.maxCharsPerMessage_invalid");
+    if (typeof policy.allowToolCalls !== "boolean")
+        throw new Error("messagePolicy.allowToolCalls_invalid");
+    if (!Array.isArray(policy.allowedToolIds) || policy.allowedToolIds.length > LIMIT.allowedTools)
+        throw new Error("messagePolicy.allowedToolIds_invalid");
+    const allowedToolIds = policy.allowedToolIds.map((id, i) => text(id, `allowedToolIds[${i}]`, LIMIT.idChars, ID)).sort();
+    if (new Set(allowedToolIds).size !== allowedToolIds.length)
+        throw new Error("messagePolicy.allowedToolIds_duplicate");
+    for (const id of allowedToolIds)
+        if (!functionIds.has(id))
+            throw new Error(`messagePolicy.allowedToolId_unknown:${id}`);
+    if (!policy.allowToolCalls && allowedToolIds.length > 0)
+        throw new Error("messagePolicy.tools_disallowed_but_list_nonempty");
+    return {
+        promptSlots,
+        messagePolicy: {
+            roles: {
+                system: stringActions(policy.roles.system, MESSAGE_ACTIONS, "roles.system"),
+                user: stringActions(policy.roles.user, MESSAGE_ACTIONS, "roles.user"),
+                assistant: stringActions(policy.roles.assistant, MESSAGE_ACTIONS, "roles.assistant")
+            },
+            scope: "view_overlay",
+            maxMessages: Number(policy.maxMessages),
+            maxCharsPerMessage: Number(policy.maxCharsPerMessage),
+            allowToolCalls: policy.allowToolCalls,
+            allowedToolIds
+        }
+    };
+};
+const canonicalize = (value) => {
+    if (Array.isArray(value))
+        return value.map(canonicalize);
+    if (!isRecord(value))
+        return value;
+    const result = {};
+    for (const key of Object.keys(value).sort())
+        result[key] = canonicalize(value[key]);
+    return result;
+};
+export const stableViewExposureHash = (manifest) => {
+    const json = JSON.stringify(canonicalize(manifest));
+    let hash = 0xcbf29ce484222325n;
+    for (const char of json) {
+        const point = char.codePointAt(0) ?? 0;
+        hash ^= BigInt(point);
+        hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+    }
+    return `fnv1a64:${hash.toString(16).padStart(16, "0")}`;
+};
+export const parseViewExposureManifest = (input) => {
+    try {
+        if (utf8Bytes(typeof input === "string" ? input : JSON.stringify(input)) > LIMIT.manifestBytes)
+            return fail("manifest_too_large");
+        const raw = typeof input === "string" ? JSON.parse(input) : input;
+        if (!isRecord(raw))
+            return fail("manifest_must_be_object");
+        exactKeys(raw, ["schemaVersion", "viewId", "revision", "functions", "llmControl"], "manifest");
+        if (raw.schemaVersion !== VIEW_EXPOSURE_SCHEMA_VERSION)
+            return fail("schema_version_unsupported");
+        if (!Number.isSafeInteger(raw.revision) || Number(raw.revision) < 0)
+            return fail("revision_invalid");
+        if (!Array.isArray(raw.functions) || raw.functions.length > LIMIT.functions)
+            return fail("functions_invalid");
+        const functions = raw.functions.map(normalizeFunction).sort((a, b) => a.id.localeCompare(b.id));
+        if (new Set(functions.map((fn) => fn.id)).size !== functions.length)
+            return fail("function_id_duplicate");
+        if (new Set(functions.map((fn) => fn.name)).size !== functions.length)
+            return fail("function_name_duplicate");
+        const manifest = {
+            schemaVersion: VIEW_EXPOSURE_SCHEMA_VERSION,
+            viewId: text(raw.viewId, "viewId", LIMIT.idChars, ID),
+            revision: Number(raw.revision),
+            functions,
+            llmControl: normalizeLlmControl(raw.llmControl, new Set(functions.map((fn) => fn.id)))
+        };
+        const normalized = { ...manifest, stableHash: stableViewExposureHash(manifest) };
+        return { ok: true, manifest: normalized };
+    }
+    catch (error) {
+        return fail(error instanceof Error ? error.message : "manifest_invalid");
+    }
+};
+export const filterForLlm = (manifest) => manifest.functions.filter((fn) => fn.target === "llm" || fn.target === "both");
+export const filterForTrigger = (manifest) => manifest.functions.filter((fn) => fn.target === "trigger" || fn.target === "both");
+export const directorViewToolDescriptors = (manifest) => filterForLlm(manifest).map((fn) => ({
+    exposureId: fn.id,
+    name: fn.name,
+    description: fn.description,
+    parameters: fn.parameters,
+    returns: fn.returns,
+    manifestHash: manifest.stableHash,
+    manifestRevision: manifest.revision
+}));
+export const triggerViewActionRegistrations = (manifest) => filterForTrigger(manifest).map((fn) => ({
+    action: fn.name,
+    exposureId: fn.id,
+    manifestHash: manifest.stableHash,
+    manifestRevision: manifest.revision
+}));

package/dist/schema.d.ts

@@ -0,0 +1,111 @@
+export declare const VIEW_EXPOSURE_SCHEMA_VERSION: 1;
+export declare const VIEW_EXPOSURE_LIMITS: {
+    readonly manifestBytes: 65536;
+    readonly schemaBytes: 16384;
+    readonly schemaDepth: 6;
+    readonly schemaProperties: 32;
+    readonly functions: 64;
+    readonly enumValues: 64;
+    readonly enumValueChars: 256;
+    readonly idChars: 128;
+    readonly nameChars: 64;
+    readonly labelChars: 128;
+    readonly descriptionChars: 1024;
+    readonly endpointChars: 256;
+    readonly effects: 32;
+    readonly promptSlots: 16;
+    readonly promptSlotChars: 16384;
+    readonly messageCount: 64;
+    readonly messageChars: 16384;
+    readonly allowedTools: 64;
+};
+export declare const VIEW_EXPOSURE_RESERVED_NAMES: ReadonlySet<string>;
+export type ExposureTarget = "llm" | "trigger" | "both";
+export type ExposureRole = "system" | "user" | "assistant";
+export type PromptSlotAction = "read" | "append" | "replace" | "remove";
+export type MessageAction = "insert" | "replace" | "remove";
+export type StrictSchema = {
+    readonly type: "string";
+    readonly description?: string;
+    readonly enum?: ReadonlyArray<string>;
+} | {
+    readonly type: "number" | "integer" | "boolean";
+    readonly description?: string;
+} | {
+    readonly type: "array";
+    readonly description?: string;
+    readonly items: StrictSchema;
+} | {
+    readonly type: "object";
+    readonly description?: string;
+    readonly properties: Readonly<Record<string, StrictSchema>>;
+    readonly required: ReadonlyArray<string>;
+    readonly additionalProperties: false;
+};
+export type StrictParametersSchema = Extract<StrictSchema, {
+    readonly type: "object";
+}>;
+export interface ViewExposureFunction {
+    readonly id: string;
+    readonly name: string;
+    readonly label: string;
+    readonly description: string;
+    readonly target: ExposureTarget;
+    readonly parameters: StrictParametersSchema;
+    readonly returns: StrictSchema;
+    readonly handler: {
+        readonly endpoint: string;
+    };
+    readonly effects: ReadonlyArray<string>;
+}
+export interface PromptSlotPolicy {
+    readonly id: string;
+    readonly role: ExposureRole;
+    readonly actions: ReadonlyArray<PromptSlotAction>;
+    readonly maxChars: number;
+}
+export interface MessagePolicy {
+    readonly roles: Readonly<Record<ExposureRole, ReadonlyArray<MessageAction>>>;
+    readonly scope: "view_overlay";
+    readonly maxMessages: number;
+    readonly maxCharsPerMessage: number;
+    readonly allowToolCalls: boolean;
+    readonly allowedToolIds: ReadonlyArray<string>;
+}
+export interface LlmControlPolicy {
+    readonly promptSlots: ReadonlyArray<PromptSlotPolicy>;
+    readonly messagePolicy: MessagePolicy;
+}
+export interface ViewExposureManifest {
+    readonly schemaVersion: typeof VIEW_EXPOSURE_SCHEMA_VERSION;
+    readonly viewId: string;
+    readonly revision: number;
+    readonly functions: ReadonlyArray<ViewExposureFunction>;
+    readonly llmControl: LlmControlPolicy;
+}
+export interface NormalizedViewExposureManifest extends ViewExposureManifest {
+    readonly stableHash: string;
+}
+/** Director 可见的最小客户端桥元数据；刻意不包含 iframe endpoint 和 effects。 */
+export interface DirectorViewToolDescriptor {
+    readonly exposureId: string;
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: StrictParametersSchema;
+    readonly returns: StrictSchema;
+    readonly manifestHash: string;
+    readonly manifestRevision: number;
+}
+export interface TriggerViewActionRegistration {
+    readonly action: string;
+    readonly exposureId: string;
+    readonly manifestHash: string;
+    readonly manifestRevision: number;
+}
+export type ViewExposureParseResult = {
+    readonly ok: true;
+    readonly manifest: NormalizedViewExposureManifest;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};

package/dist/schema.js

@@ -0,0 +1,28 @@
+export const VIEW_EXPOSURE_SCHEMA_VERSION = 1;
+export const VIEW_EXPOSURE_LIMITS = {
+    manifestBytes: 65_536,
+    schemaBytes: 16_384,
+    schemaDepth: 6,
+    schemaProperties: 32,
+    functions: 64,
+    enumValues: 64,
+    enumValueChars: 256,
+    idChars: 128,
+    nameChars: 64,
+    labelChars: 128,
+    descriptionChars: 1_024,
+    endpointChars: 256,
+    effects: 32,
+    promptSlots: 16,
+    promptSlotChars: 16_384,
+    messageCount: 64,
+    messageChars: 16_384,
+    allowedTools: 64
+};
+export const VIEW_EXPOSURE_RESERVED_NAMES = new Set([
+    "LS", "Read", "Write", "Edit", "Bash", "BashOutput", "KillShell",
+    "Grep", "Glob", "WebFetch", "WebSearch", "ask_user", "craft_tool",
+    "list_registered_tools", "unregister_tool", "world_event_emit", "graph_query",
+    "entity_get", "relation_list", "vector_search", "setEntityTrigger",
+    "setPropTrigger", "clearEntityTrigger", "clearPropTrigger"
+]);

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@world-engines/view-exposure",
+  "private": false,
+  "version": "0.0.0",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "worldengine_source_sha256": "16846a6350543f542f746d271a8ffd9c7045b73a572eeb9f8e736ebf4841e1e3",
+  "worldengine_source_identity_provenance": {
+    "schema": "worldengine-public-namespace-projection/v1",
+    "kind": "composite-source-identity; namespace projection; not-full-source-recompile",
+    "original_name": "@chat/view-exposure",
+    "original_archive_sha256": "7431c8f6a82b0b4f1dc360c0f39529063b115bc510e68140b6b5fbd6bfe796a9",
+    "original_source_sha256": "d4713218e9c323ce747b568e124189f5c9039d5de7c16c8e12f488754ba9db99",
+    "projected_name": "@world-engines/view-exposure",
+    "package_name_mapping": {
+      "@chat/blocks-editor": "@world-engines/blocks-editor",
+      "@chat/ladybug-bridge": "@world-engines/ladybug-bridge",
+      "@chat/monaco-host": "@world-engines/monaco-host",
+      "@chat/protocol-ts": "@world-engines/protocol-ts",
+      "@chat/scenario-author-source": "@world-engines/scenario-author-source",
+      "@chat/scenario-review-snapshot": "@world-engines/scenario-review-snapshot",
+      "@chat/tmw": "@world-engines/tmw",
+      "@chat/view-exposure": "@world-engines/view-exposure",
+      "@world-engines/chatplay-vite-plugin": "@world-engines/chatplay-vite-plugin",
+      "@worldengine/agent-kit": "@world-engines/agent-kit",
+      "@worldengine/authoring-bridge": "@world-engines/authoring-bridge",
+      "@worldengine/authoring-ui": "@world-engines/authoring-ui",
+      "@worldengine/create-project": "@world-engines/create-project",
+      "@worldengine/project-format": "@world-engines/project-format",
+      "@worldengine/project-host": "@world-engines/project-host",
+      "@worldengine/project-setup": "@world-engines/project-setup",
+      "@worldengine/spatial-authoring": "@world-engines/spatial-authoring",
+      "@worldengine/view-sdk": "@world-engines/view-sdk"
+    }
+  }
+}