@world-engines/project-host 0.1.0-alpha.0

package/dist/project-git-scenario-source.js

@@ -0,0 +1,240 @@
+import { randomUUID } from "node:crypto";
+import { AuthoringBridgeError } from "@world-engines/authoring-bridge";
+import { ScenarioPartSourceV1, SpatialWorldSourceV1 } from "@world-engines/protocol-ts/v1/scenario_part_source";
+import { computeCanonicalFileTreeDigest, decodeScenarioPartWesp, encodeWesp, sha256Hex, } from "@world-engines/project-format";
+import { LocalProjectHost } from "./project-host.js";
+const MAP_LAYOUT_PATH = "layout.section.json";
+const MAP_SPATIAL_PATH = "spatial-world.section.json";
+const DATABASE_PATH = "scenario-graph.json";
+const text = new TextEncoder();
+const decoder = new TextDecoder("utf-8", { fatal: true });
+async function assertCapture(expected) {
+    if (!Number.isSafeInteger(expected.project_revision) || expected.project_revision < 0 || typeof expected.source_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(expected.source_sha256)) {
+        fail("expected Git source capture 无效");
+    }
+    const digest = await computeCanonicalFileTreeDigest(Object.entries(expected.files).map(([path, bytesValue]) => ({ path, bytes: bytesValue })));
+    if (digest !== expected.digest)
+        fail("expected Git source capture digest 不匹配");
+}
+function fail(message) {
+    throw new AuthoringBridgeError("E_SCHEMA_INVALID", message);
+}
+function canonicalJson(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            fail("Git source JSON number 无效");
+        return JSON.stringify(Object.is(value, -0) ? 0 : value);
+    }
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (typeof value === "object") {
+        return `{${Object.entries(value)
+            .filter(([, child]) => child !== undefined)
+            .sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+            .map(([key, child]) => `${JSON.stringify(key)}:${canonicalJson(child)}`)
+            .join(",")}}`;
+    }
+    fail("Git source JSON value 无效");
+}
+function bytes(value) { return text.encode(canonicalJson(value)); }
+function json(value, field) {
+    try {
+        return JSON.parse(decoder.decode(value));
+    }
+    catch {
+        return fail(`${field} 必须是 UTF-8 JSON`);
+    }
+}
+function record(value, field) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        fail(`${field} 必须是 object`);
+    return value;
+}
+function array(value, field) {
+    if (!Array.isArray(value))
+        fail(`${field} 必须是 array`);
+    return value;
+}
+function requiredString(value, field) {
+    if (typeof value !== "string" || value.length === 0)
+        fail(`${field} 无效`);
+    return value;
+}
+function sameKeys(value, keys, field) {
+    const actual = Object.keys(value);
+    if (actual.length !== keys.length || actual.some((key) => !keys.includes(key)))
+        fail(`${field} 字段无效`);
+}
+function base64(bytesValue) { return Buffer.from(bytesValue).toString("base64"); }
+function base64Bytes(value, field) {
+    if (typeof value !== "string")
+        fail(`${field} 必须是 base64`);
+    const result = new Uint8Array(Buffer.from(value, "base64"));
+    if (base64(result).replace(/=+$/, "") !== value.replace(/=+$/, ""))
+        fail(`${field} 不是 canonical base64`);
+    return result;
+}
+function normalizeEntityForGit(value) {
+    const entity = { ...record(value, "logical_graph.entities[]") };
+    const id = requiredString(entity.entity_id ?? entity.id, "logical_graph entity id");
+    delete entity.id;
+    entity.entity_id = id;
+    return entity;
+}
+async function normalizeRelationForGit(value) {
+    const relation = { ...record(value, "logical_graph.relations[]") };
+    const from = requiredString(relation.from_id ?? relation.src, "logical_graph relation from_id");
+    const to = requiredString(relation.to_id ?? relation.dst, "logical_graph relation to_id");
+    const kind = requiredString(relation.kind, "logical_graph relation kind");
+    const relationId = relation.relation_id ?? relation.id
+        ?? `relation.local.${(await sha256Hex(bytes({ from_id: from, kind, to_id: to }))).slice(0, 32)}`;
+    requiredString(relationId, "logical_graph relation_id");
+    delete relation.id;
+    delete relation.src;
+    delete relation.dst;
+    relation.from_id = from;
+    relation.to_id = to;
+    relation.kind = kind;
+    if (relationId !== undefined)
+        relation.relation_id = relationId;
+    return relation;
+}
+function normalizeEntityForLocal(value) {
+    const entity = { ...record(value, "scenario-graph.entities[]") };
+    const id = requiredString(entity.entity_id, "scenario-graph entity_id");
+    delete entity.entity_id;
+    entity.id = id;
+    return entity;
+}
+function normalizeRelationForLocal(value) {
+    const relation = { ...record(value, "scenario-graph.relations[]") };
+    const from = requiredString(relation.from_id, "scenario-graph from_id");
+    const to = requiredString(relation.to_id, "scenario-graph to_id");
+    requiredString(relation.kind, "scenario-graph kind");
+    if (relation.relation_id !== undefined)
+        requiredString(relation.relation_id, "scenario-graph relation_id");
+    delete relation.from_id;
+    delete relation.to_id;
+    relation.src = from;
+    relation.dst = to;
+    return relation;
+}
+async function graphSnapshot(projectRevision, graph) {
+    const entities = array(graph.entities ?? [], "logical_graph.entities").map(normalizeEntityForGit);
+    const relations = await Promise.all(array(graph.relations ?? [], "logical_graph.relations").map(normalizeRelationForGit));
+    const state_sha256 = await sha256Hex(bytes({
+        entities: [...entities].sort((left, right) => String(left.entity_id).localeCompare(String(right.entity_id))),
+        relations: [...relations].sort((left, right) => String(left.relation_id ?? "").localeCompare(String(right.relation_id ?? ""))),
+    }));
+    return { revision: projectRevision, state_sha256, entities, relations };
+}
+function localLayoutToGitPayload(source) {
+    const layout = source.byteLength === 0 ? {} : record(json(source, "layout"), "layout");
+    const interaction = layout.interaction === undefined ? undefined : record(layout.interaction, "layout.interaction");
+    return bytes({
+        view_interaction_mobile: layout.view_interaction_mobile ?? interaction?.mobile ?? null,
+        view_interaction_pc: layout.view_interaction_pc ?? interaction?.pc ?? (interaction !== undefined && Object.keys(interaction).length > 0 ? interaction : null),
+    });
+}
+function gitPayloadToLocalLayout(previousSource, payload) {
+    const previous = previousSource.byteLength === 0 ? {} : record(json(previousSource, "layout"), "layout");
+    const target = record(json(payload, "layout Git payload"), "layout Git payload");
+    sameKeys(target, ["view_interaction_mobile", "view_interaction_pc"], "layout Git payload");
+    return bytes({ ...previous, view_interaction_mobile: target.view_interaction_mobile, view_interaction_pc: target.view_interaction_pc });
+}
+function parseMap(files) {
+    const names = Object.keys(files);
+    if ((names.length !== 1 && names.length !== 2) || !(MAP_LAYOUT_PATH in files) || names.some((name) => name !== MAP_LAYOUT_PATH && name !== MAP_SPATIAL_PATH))
+        fail("map Git tree 只能包含 layout 与可选 spatial-world");
+    const layoutEnvelope = record(json(files[MAP_LAYOUT_PATH], MAP_LAYOUT_PATH), MAP_LAYOUT_PATH);
+    sameKeys(layoutEnvelope, ["section_key", "media_type", "canonical_encoding", "payload_base64"], MAP_LAYOUT_PATH);
+    if (layoutEnvelope.section_key !== "layout" || typeof layoutEnvelope.media_type !== "string" || layoutEnvelope.media_type.length === 0 || typeof layoutEnvelope.canonical_encoding !== "string" || layoutEnvelope.canonical_encoding.length === 0)
+        fail("layout section descriptor 无效");
+    const layout = base64Bytes(layoutEnvelope.payload_base64, "layout payload_base64");
+    // Web Git 支持 opaque layout descriptor；Local WESP 没有 descriptor slot，因此只接受可以无损投影到 local layout 的 JSON section。
+    if (layoutEnvelope.media_type !== "application/json")
+        fail("Local WESP 不支持非 JSON layout Git section");
+    record(json(layout, "layout payload"), "layout payload");
+    if (!(MAP_SPATIAL_PATH in files))
+        return { layout };
+    const spatialEnvelope = record(json(files[MAP_SPATIAL_PATH], MAP_SPATIAL_PATH), MAP_SPATIAL_PATH);
+    sameKeys(spatialEnvelope, ["section_key", "media_type", "canonical_encoding", "payload_base64"], MAP_SPATIAL_PATH);
+    if (spatialEnvelope.section_key !== "spatial_world" || spatialEnvelope.media_type !== "application/x-protobuf" || spatialEnvelope.canonical_encoding !== "chat.v1.SpatialWorldSourceV1")
+        fail("spatial_world section descriptor 不支持");
+    const spatial = base64Bytes(spatialEnvelope.payload_base64, "spatial_world payload_base64");
+    try {
+        SpatialWorldSourceV1.decode(spatial);
+    }
+    catch {
+        fail("spatial_world protobuf 无效");
+    }
+    return { layout, spatial };
+}
+async function parseGraph(files) {
+    if (Object.keys(files).length !== 1 || !(DATABASE_PATH in files))
+        fail("database Git tree 必须只包含 scenario-graph.json");
+    const value = record(json(files[DATABASE_PATH], DATABASE_PATH), DATABASE_PATH);
+    sameKeys(value, ["entities", "relations", "revision", "state_sha256"], DATABASE_PATH);
+    if (!Number.isSafeInteger(value.revision) || value.revision < 0 || typeof value.state_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(value.state_sha256))
+        fail("scenario-graph metadata 无效");
+    const localShape = { entities: array(value.entities, "scenario-graph.entities").map(normalizeEntityForLocal), relations: array(value.relations, "scenario-graph.relations").map(normalizeRelationForLocal) };
+    const snapshot = await graphSnapshot(value.revision, localShape);
+    if (snapshot.state_sha256 !== value.state_sha256)
+        fail("scenario-graph state_sha256 不匹配");
+    return snapshot;
+}
+async function capture(root, kind) {
+    const host = await LocalProjectHost.open(root);
+    try {
+        const readback = await host.readSourceReadback();
+        const message = ScenarioPartSourceV1.decode(await decodeScenarioPartWesp(readback.source));
+        if (message.schema_version !== 1)
+            fail("ScenarioPartSourceV1 schema_version 不支持");
+        if (kind === "map") {
+            const files = {
+                [MAP_LAYOUT_PATH]: bytes({ section_key: "layout", media_type: "application/json", canonical_encoding: "canonical-json-v1", payload_base64: base64(localLayoutToGitPayload(message.layout)) }),
+                ...(message.spatial_world === undefined ? {} : { [MAP_SPATIAL_PATH]: bytes({ section_key: "spatial_world", media_type: "application/x-protobuf", canonical_encoding: "chat.v1.SpatialWorldSourceV1", payload_base64: base64(SpatialWorldSourceV1.encode(message.spatial_world).finish()) }) }),
+            };
+            return { readback, message, files };
+        }
+        const snapshot = await graphSnapshot(readback.project_revision, message.logical_graph.byteLength === 0 ? {} : record(json(message.logical_graph, "logical_graph"), "logical_graph"));
+        return { readback, message, files: { [DATABASE_PATH]: bytes(snapshot) } };
+    }
+    finally {
+        await host.close();
+    }
+}
+export async function captureScenarioGitSource(root, kind) {
+    const current = await capture(root, kind);
+    return Object.freeze({ files: current.files, digest: await computeCanonicalFileTreeDigest(Object.entries(current.files).map(([path, bytesValue]) => ({ path, bytes: bytesValue }))), project_revision: current.readback.project_revision, source_sha256: current.readback.source_sha256 });
+}
+export async function applyScenarioGitSource(root, kind, files, expected) {
+    await assertCapture(expected);
+    const current = await capture(root, kind);
+    const currentDigest = await computeCanonicalFileTreeDigest(Object.entries(current.files).map(([path, bytesValue]) => ({ path, bytes: bytesValue })));
+    if (current.readback.project_revision !== expected.project_revision || current.readback.source_sha256 !== expected.source_sha256 || currentDigest !== expected.digest) {
+        throw new AuthoringBridgeError("E_STALE_PROJECT_REVISION", "project git apply 的本地 source 已改变");
+    }
+    const next = ScenarioPartSourceV1.decode(await decodeScenarioPartWesp(current.readback.source));
+    if (kind === "map") {
+        const incoming = parseMap(files);
+        next.layout = gitPayloadToLocalLayout(next.layout, incoming.layout);
+        if (incoming.spatial !== undefined)
+            next.spatial_world = SpatialWorldSourceV1.decode(incoming.spatial);
+    }
+    else {
+        const incoming = await parseGraph(files);
+        const previousGraph = next.logical_graph.byteLength === 0 ? {} : record(json(next.logical_graph, "logical_graph"), "logical_graph");
+        next.logical_graph = bytes({ ...previousGraph, entities: incoming.entities.map(normalizeEntityForLocal), relations: incoming.relations.map(normalizeRelationForLocal) });
+    }
+    const source = await encodeWesp(ScenarioPartSourceV1.encode(next).finish());
+    const host = await LocalProjectHost.open(root);
+    try {
+        await host.writeScenario({ operation_id: `project_git_${kind}_${randomUUID()}`, expected_project_revision: expected.project_revision, expected_source_sha256: expected.source_sha256, source });
+    }
+    finally {
+        await host.close();
+    }
+}

package/dist/project-git-view-source.d.ts

@@ -0,0 +1,13 @@
+export interface ViewGitCapture {
+    readonly files: Readonly<Record<string, Uint8Array>>;
+    /** 完整可版本化视图树（包括 lockfile）的 canonical SHA-256。 */
+    readonly digest: string;
+    readonly project_revision: number;
+    readonly source_sha256: string;
+}
+export declare function captureViewGitSource(root: string): Promise<ViewGitCapture>;
+/**
+ * 将已从 Git checkout 读出的完整视图 source tree 通过 Download Replace 的 writer lease
+ * 与 preimage/recovery 协议写入。调用方必须先完成仓库 ACL；这里不读取任何运行时 bundle。
+ */
+export declare function applyViewGitSource(root: string, files: Readonly<Record<string, Uint8Array>>, expected: ViewGitCapture): Promise<void>;

package/dist/project-git-view-source.js

@@ -0,0 +1,134 @@
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { AuthoringBridgeError } from "@world-engines/authoring-bridge";
+import { computeCanonicalFileTreeDigest } from "@world-engines/project-format";
+import { LocalProjectHost } from "./project-host.js";
+import { assertSafeExistingProjectPath } from "./safe-project-path.js";
+import { DownloadReplaceCoordinator, isProjectGitViewExcludedName } from "./transfer/download.js";
+const WINDOWS_DEVICE_NAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/iu;
+function sha256(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+function failPath(message) {
+    throw new AuthoringBridgeError("E_PATH_OUTSIDE_PROJECT", message);
+}
+/** Git tree 只承载作者源；不得把 hook、嵌套仓或构建产物写入本地项目。 */
+function assertGitViewPath(path) {
+    if (typeof path !== "string" || path.length === 0 || path.includes("\\") || path.startsWith("/") || /^[A-Za-z]:/.test(path)) {
+        return failPath("视图 Git 文件路径必须是安全的 POSIX 相对路径");
+    }
+    const parts = path.split("/");
+    if (parts.some((part) => {
+        const deviceStem = part.split(".", 1)[0].trimEnd();
+        return part === "" || part === "." || part === ".."
+            || isProjectGitViewExcludedName(part)
+            || /[<>:"|?*\u0000-\u001f]/u.test(part)
+            || /[. ]$/u.test(part)
+            || WINDOWS_DEVICE_NAME.test(deviceStem);
+    })) {
+        return failPath("视图 Git tree 不能包含控制目录、生成目录或路径逃逸");
+    }
+    return path;
+}
+async function listViewSourceFiles(root, directory, prefix = "") {
+    const canonical = await assertSafeExistingProjectPath(root, directory);
+    const entries = await readdir(canonical, { withFileTypes: true });
+    const output = [];
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        if (isProjectGitViewExcludedName(entry.name))
+            continue;
+        const absolute = join(canonical, entry.name);
+        const info = await lstat(absolute);
+        if (info.isSymbolicLink())
+            failPath(`拒绝符号链接、junction 或 reparse point：${absolute}`);
+        const path = assertGitViewPath(prefix === "" ? entry.name : `${prefix}/${entry.name}`);
+        if (info.isDirectory())
+            output.push(...await listViewSourceFiles(root, absolute, path));
+        else if (info.isFile())
+            output.push({ path, bytes: new Uint8Array(await readFile(await assertSafeExistingProjectPath(root, absolute))) });
+        else
+            failPath(`视图 Git tree 只允许普通文件和目录：${absolute}`);
+    }
+    return output;
+}
+async function capture(root) {
+    const host = await LocalProjectHost.open(root);
+    try {
+        const source = await host.readSourceReadback();
+        const viewRoot = await assertSafeExistingProjectPath(root, join(root, "view"));
+        const files = Object.fromEntries((await listViewSourceFiles(root, viewRoot)).map((file) => [file.path, file.bytes]));
+        return { files, project_revision: source.project_revision, source_sha256: source.source_sha256 };
+    }
+    finally {
+        await host.close();
+    }
+}
+async function digestFiles(files) {
+    return computeCanonicalFileTreeDigest(Object.entries(files)
+        .map(([path, bytes]) => ({ path: assertGitViewPath(path), bytes }))
+        .sort((left, right) => left.path.localeCompare(right.path)));
+}
+function validatedIncoming(files) {
+    const output = [];
+    const windowsPaths = new Set();
+    for (const [path, bytes] of Object.entries(files)) {
+        assertGitViewPath(path);
+        const windowsPath = path.toLowerCase();
+        if (windowsPaths.has(windowsPath))
+            throw new AuthoringBridgeError("E_PATH_OUTSIDE_PROJECT", `视图 Git tree 包含 Windows 路径冲突：${path}`);
+        windowsPaths.add(windowsPath);
+        if (!(bytes instanceof Uint8Array))
+            throw new AuthoringBridgeError("E_SCHEMA_INVALID", `视图 Git 文件不是字节数组：${path}`);
+        output.push({ path, bytes: new Uint8Array(bytes) });
+    }
+    return output.sort((left, right) => left.path.localeCompare(right.path));
+}
+function planFor(expected, incoming) {
+    const identity = {
+        expected_project_revision: expected.project_revision,
+        expected_source_sha256: expected.source_sha256,
+        expected_view_digest: expected.digest,
+        files: incoming.map((file) => [file.path, sha256(file.bytes)]),
+    };
+    const planDigest = sha256(new TextEncoder().encode(JSON.stringify(identity)));
+    return {
+        schema_version: 1,
+        operation_id: `project_git_view_${randomUUID()}`,
+        plan_digest: planDigest,
+        expected_project_revision: expected.project_revision,
+        selection: "view",
+        strict_source_cas: {
+            schema_version: 1,
+            expected_source_sha256: expected.source_sha256,
+            expected_view_source_tree_sha256: expected.digest,
+        },
+        view: {
+            install_dependencies: false,
+            files: incoming.map((file) => ({ path: file.path, content_base64: Buffer.from(file.bytes).toString("base64"), sha256: sha256(file.bytes) })),
+        },
+    };
+}
+export async function captureViewGitSource(root) {
+    const current = await capture(root);
+    return Object.freeze({
+        files: current.files,
+        digest: await digestFiles(current.files),
+        project_revision: current.project_revision,
+        source_sha256: current.source_sha256,
+    });
+}
+/**
+ * 将已从 Git checkout 读出的完整视图 source tree 通过 Download Replace 的 writer lease
+ * 与 preimage/recovery 协议写入。调用方必须先完成仓库 ACL；这里不读取任何运行时 bundle。
+ */
+export async function applyViewGitSource(root, files, expected) {
+    const incoming = validatedIncoming(files);
+    const current = await captureViewGitSource(root);
+    if (current.project_revision !== expected.project_revision || current.source_sha256 !== expected.source_sha256 || current.digest !== expected.digest) {
+        throw new AuthoringBridgeError("E_STALE_PROJECT_REVISION", "project git apply 的本地视图 source 已改变");
+    }
+    const plan = planFor(expected, incoming);
+    const coordinator = await DownloadReplaceCoordinator.open(root);
+    await coordinator.apply(plan, { operation_id: plan.operation_id, plan_digest: plan.plan_digest });
+}

package/dist/project-git.d.ts

@@ -0,0 +1,97 @@
+import type { ProjectTransferTransport } from "./transfer/transport.js";
+export declare const PROJECT_GIT_MANIFEST_PATH = ".worldengine/project-git/manifest.json";
+export declare const PROJECT_GIT_REPOSITORY_KINDS: readonly ["map", "database", "view"];
+export type ProjectGitRepositoryKind = typeof PROJECT_GIT_REPOSITORY_KINDS[number];
+export interface ProjectGitRepositoryRefV1 {
+    readonly kind: ProjectGitRepositoryKind;
+    readonly remote_path: string;
+    readonly commit: string | null;
+}
+export interface ProjectGitManifestBodyV1 {
+    readonly schema_version: 1;
+    readonly scenario_id: string;
+    readonly metadata: Readonly<{
+        title: string;
+        description: string;
+    }>;
+    readonly repositories: Readonly<Record<ProjectGitRepositoryKind, ProjectGitRepositoryRefV1>>;
+}
+/** Edge `GET /project-manifest` 的真实 response envelope。 */
+export interface ProjectGitManifestV1 {
+    readonly scenario_id: string;
+    readonly revision: number;
+    readonly manifest: ProjectGitManifestBodyV1;
+    readonly updated_by?: string | null;
+    readonly updated_at?: number | null;
+}
+export interface ProjectGitPermissionsV1 {
+    readonly map_read: boolean;
+    readonly map_write: boolean;
+    readonly database_read: boolean;
+    readonly database_write: boolean;
+    readonly view_read: boolean;
+    readonly view_write: boolean;
+    readonly metadata_write: boolean;
+}
+export interface ProjectGitTransportRequest {
+    readonly project_id: string;
+    readonly method: "GET" | "POST" | "PUT";
+    readonly path: string;
+    readonly content_type?: "application/x-ndjson; profile=\"chat-artifact-v5-submit-stream-v1\"" | "application/x-git-upload-pack-request" | "application/x-git-receive-pack-request";
+    readonly body?: unknown | Uint8Array;
+}
+export interface ProjectGitTransportResponse {
+    readonly status: number;
+    readonly body: unknown;
+}
+export interface ProjectGitTransport {
+    request(request: ProjectGitTransportRequest): Promise<ProjectGitTransportResponse>;
+}
+export interface ProjectGitCommandResult {
+    readonly status: "cloned" | "fetched" | "pushed";
+    readonly repository: ProjectGitRepositoryKind;
+    readonly local_path: string;
+    readonly head: string;
+}
+export interface ProjectGitSourceResult {
+    readonly status: "captured" | "apply_prepared" | "applied" | "source_inspected";
+    readonly repository: ProjectGitRepositoryKind;
+    readonly local_path: string;
+    readonly project_revision: number;
+    readonly source_digest: string;
+}
+interface ProjectIdentity {
+    readonly project_id: string;
+    readonly scenario_id: string;
+}
+export declare function validateProjectGitManifest(value: unknown, expected?: ProjectIdentity): ProjectGitManifestV1;
+export declare function projectGitTransport(transport: ProjectTransferTransport): ProjectGitTransport;
+export declare class ProjectGitClient {
+    readonly projectRoot: string;
+    readonly identity: ProjectIdentity;
+    private readonly transport;
+    private constructor();
+    static open(projectRoot: string, transport: ProjectGitTransport | undefined): Promise<ProjectGitClient>;
+    readManifest(): Promise<ProjectGitManifestV1>;
+    private readAccess;
+    private captureSource;
+    /** Native 在命令后只读核对同一实际作者源，避免复制 map/database/view 摘要算法。 */
+    inspect(kindValue: string): Promise<ProjectGitSourceResult>;
+    private withSourceLease;
+    private assertCleanRepository;
+    private saveSourcePreimage;
+    /** 导出真实作者源，不触碰 index；作者仍使用原始 Git add/commit/merge。 */
+    capture(kindValue: string): Promise<ProjectGitSourceResult>;
+    /** 在 fetch/merge 之前固定本地预影；后续本地编辑必须导致 apply 拒绝。 */
+    prepareApply(kindValue: string): Promise<ProjectGitSourceResult>;
+    apply(kindValue: string): Promise<ProjectGitSourceResult>;
+    private sourceResult;
+    pullManifest(): Promise<ProjectGitManifestV1>;
+    pushManifest(): Promise<ProjectGitManifestV1>;
+    private pullManifestFromValue;
+    clone(kindValue: string): Promise<ProjectGitCommandResult>;
+    fetch(kindValue: string): Promise<ProjectGitCommandResult>;
+    push(kindValue: string): Promise<ProjectGitCommandResult>;
+    private result;
+}
+export {};