@tequila99/githuman 0.11.2 → 0.12.0

package/dist/server/routes/events.js

@@ -30,7 +30,11 @@ export async function eventRoutes(app, opts) {
         const unsubscribe = eventBus.subscribe(event => {
             safeSend(reply.sse, {
                 event: event.type,
-                data: { reviewId: event.reviewId }
+                data: {
+                    reviewId: event.reviewId,
+                    storeId: event.storeId,
+                    storeEpoch: event.storeEpoch
+                }
             });
         });
         reply.sse.onClose(() => {

package/dist/server/services/agent/agent-session.js

@@ -1,4 +1,8 @@
+import { isLocalPiLaunch } from "../../adapters/pi-acp/launch.js";
+import { isRecord } from "../../../shared/utils/guards.js";
 import { AgentSessionError, AgentSessionStateError, AgentConfigError } from "../../errors/agents.js";
+import { ARTIFACT_TASK_PROMPT_HINT } from "../../../shared/artifact-tools/instructions.js";
+import { ARTIFACT_AGENT_KEY_ENV, ARTIFACT_MCP_SERVER_NAME } from "../../../shared/artifacts/mcp-constants.js";
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { rm } from 'node:fs/promises';
@@ -16,6 +20,8 @@ export const MAX_BUFFERED_EVENTS = 5_000;
 const STDERR_TAIL_CHARS = 2_000;
 /** How long a closed connection waits for the `exit` event that carries the reason. */
 const EXIT_GRACE_MS = 500;
+// Bound pending tool context retained only for server permission policies.
+const MAX_PERMISSION_TOOL_CALLS = 64;
 /** The option the server picks for an auto-approved request; never a rejection. */
 function autoApproveChoice(options) {
     return (options.find(o => o.kind === 'allow_once') ??
@@ -35,11 +41,14 @@ export class AgentSession {
     presetId;
     name;
     reviewId;
+    kind;
+    #turnTaskContext;
     #status = 'starting';
     /** Set when the user (or the server) ends the session: its exit is no failure. */
     #closing = false;
     #error = null;
     #autoApprove = false;
+    #permissionToolCalls = new Map();
     #child;
     #connection;
     #acpSessionId;
@@ -47,6 +56,8 @@ export class AgentSession {
     #image = false;
     #config = [];
     #stderrTail = '';
+    #mcpSecrets = [];
+    #hasArtifactMcp = false;
     /** Settles when the agent process has exited. */
     #exited = Promise.resolve();
     #ownEventId = 0;
@@ -61,10 +72,35 @@ export class AgentSession {
         this.presetId = options.preset.id;
         this.name = options.name;
         this.reviewId = options.reviewId ?? null;
+        this.kind = options.kind;
     }
     get status() {
         return this.#status;
     }
+    get turnTaskContext() {
+        return this.#turnTaskContext;
+    }
+    prepareTaskActivation(turnId, assignmentVersion, taskId, requestId) {
+        // Cancellation clears the context before the agent stops reporting busy.
+        if (!this.#turnTaskContext || this.#turnTaskContext.turnId !== turnId) {
+            throw new AgentSessionStateError('The response ended or its task context changed.');
+        }
+        const context = Object.freeze({
+            sessionId: this.id,
+            turnId,
+            assignmentVersion,
+            taskIds: Object.freeze([taskId]),
+            source: 'turn_activation',
+            activationRequestId: requestId
+        });
+        // The caller commits and applies synchronously, without yielding to cancellation or another prompt.
+        return {
+            context,
+            apply: () => {
+                this.#turnTaskContext = context;
+            }
+        };
+    }
     /** Whether the agent advertised `promptCapabilities.embeddedContext`. */
     get supportsEmbeddedContext() {
         return this.#embeddedContext;
@@ -76,8 +112,12 @@ export class AgentSession {
     info() {
         return {
             id: this.id,
+            ...(this.#options.taskIds
+                ? { taskIds: this.#options.taskIds(this.id) }
+                : {}),
             presetId: this.presetId,
             name: this.name,
+            ...(this.kind === undefined ? {} : { kind: this.kind }),
             status: this.#status,
             reviewId: this.reviewId,
             autoApprove: this.#autoApprove,
@@ -106,7 +146,7 @@ export class AgentSession {
         catch (error) {
             // An exit during the start already reported itself (`#onExit`).
             if (this.#error === null && !this.#closing) {
-                const message = errorMessage(error);
+                const message = this.#redact(errorMessage(error));
                 this.#error = message;
                 this.#emit({ type: 'error', message });
             }
@@ -115,16 +155,28 @@ export class AgentSession {
     }
     async #start() {
         const { preset, cwd } = this.#options;
+        const localPi = isLocalPiLaunch(preset);
+        if (preset.id === 'pi' && this.kind === 'validation' && !localPi) {
+            throw new AgentSessionError('Pi validation requires the trusted local GitHuman pi launcher. The configured command is available for chat only.');
+        }
         const child = spawn(preset.command, preset.args, {
             cwd,
             stdio: ['pipe', 'pipe', 'pipe'],
-            env: { ...process.env, ...preset.env }
+            env: {
+                ...process.env,
+                ...preset.env,
+                ...(localPi
+                    ? {
+                        GITHUMAN_PI_PROFILE: this.kind === 'validation' ? 'validator' : 'chat'
+                    }
+                    : {})
+            }
         });
         this.#child = child;
         this.#exited = new Promise(resolve => child.once('exit', resolve));
         child.stderr.setEncoding('utf-8');
         child.stderr.on('data', (chunk) => {
-            this.#stderrTail = (this.#stderrTail + chunk).slice(-STDERR_TAIL_CHARS);
+            this.#stderrTail = this.#redact(this.#stderrTail + chunk).slice(-STDERR_TAIL_CHARS);
         });
         // Swallow stdin EPIPE after the agent died; the closed connection reports it.
         child.stdin.on('error', () => { });
@@ -181,10 +233,28 @@ export class AgentSession {
         const prompt = init.agentCapabilities?.promptCapabilities;
         this.#embeddedContext = prompt?.embeddedContext === true;
         this.#image = prompt?.image === true;
+        const mcpServers = typeof this.#options.mcpServers === 'function'
+            ? this.#options.mcpServers(this.id)
+            : (this.#options.mcpServers ?? []);
+        this.#hasArtifactMcp = mcpServers.some(server => server.name === ARTIFACT_MCP_SERVER_NAME);
+        this.#mcpSecrets = mcpServers.flatMap(server => 'env' in server
+            ? server.env
+                .filter(entry => entry.name === ARTIFACT_AGENT_KEY_ENV)
+                .map(entry => entry.value)
+            : []);
         const created = await connection.agent.request(acp.methods.agent.session.new, {
             cwd: this.#options.cwd,
-            mcpServers: []
+            mcpServers
         });
+        if (isLocalPiLaunch(this.#options.preset)) {
+            const ack = created['_meta']?.githumanBridge;
+            if (!isRecord(ack) ||
+                ack.version !== 1 ||
+                ack.profile !== (this.kind === 'validation' ? 'validator' : 'chat') ||
+                ack.registryGeneration !== 1) {
+                throw new AgentSessionError('Pi bridge did not confirm its launch profile and MCP registry.');
+            }
+        }
         this.#acpSessionId = created.sessionId;
         this.#setConfig(mapConfigOptions(created.configOptions));
     }
@@ -223,7 +293,9 @@ export class AgentSession {
             this.#setConfig(mapConfigOptions(response.configOptions));
         }
         catch (error) {
-            throw new AgentSessionError(errorMessage(error), { cause: error });
+            throw new AgentSessionError(this.#redact(errorMessage(error)), {
+                cause: error
+            });
         }
     }
     /** The agent process ended: report why, unless the session itself ended it. */
@@ -257,8 +329,15 @@ export class AgentSession {
         }
         this.#markClosed();
     }
+    // Hides the session key in errors and stderr. Messages that the agent itself writes stay as they are.
+    #redact(text) {
+        for (const secret of this.#mcpSecrets) {
+            text = text.replaceAll(secret, '[redacted]');
+        }
+        return text;
+    }
     #exitMessage(code, signal) {
-        const tail = this.#stderrTail.trim();
+        const tail = this.#redact(this.#stderrTail.trim());
         return (`Agent exited (${signal ?? `code ${code}`})` +
             (tail === '' ? '' : `: ${tail.slice(-400)}`));
     }
@@ -268,13 +347,29 @@ export class AgentSession {
      */
     prompt(blocks, display) {
         const { connection, sessionId } = this.#readyChannel();
+        const assignment = this.#options.taskAssignment?.(this.id);
+        const turn = Object.freeze({
+            turnId: randomUUID(),
+            sessionId: this.id,
+            assignmentVersion: assignment?.version ?? 0,
+            source: 'turn_assignment',
+            taskIds: Object.freeze([...(assignment?.taskIds ?? [])])
+        });
+        this.#turnTaskContext = turn;
         this.#setStatus('busy');
         this.#emit({
             type: 'user',
             text: display.text,
             context: display.context ?? []
         });
-        void this.#runPrompt(connection, sessionId, blocks);
+        // Append the reminder without changing the user transcript or validator assignments.
+        const prompt = this.#hasArtifactMcp && !this.#options.permissionPolicy
+            ? [
+                ...blocks,
+                { type: 'text', text: ARTIFACT_TASK_PROMPT_HINT }
+            ]
+            : blocks;
+        void this.#runPrompt(connection, sessionId, prompt, turn.turnId);
     }
     /**
      * Throws when the session cannot take a prompt now. The route calls this
@@ -293,12 +388,14 @@ export class AgentSession {
         }
         return { connection, sessionId };
     }
-    async #runPrompt(connection, sessionId, blocks) {
+    async #runPrompt(connection, sessionId, blocks, turnId) {
         try {
             const response = await connection.agent.request(acp.methods.agent.session.prompt, { sessionId, prompt: blocks });
+            this.#clearTurnTaskContext(turnId);
             this.#emit({ type: 'stop', stopReason: response.stopReason });
         }
         catch (error) {
+            this.#clearTurnTaskContext(turnId);
             // A failure of the transport comes before the `exit` event, and only
             // that event can say why the agent died: let it report first.
             if (!(error instanceof acp.RequestError)) {
@@ -308,10 +405,14 @@ export class AgentSession {
                 ]);
             }
             if (!this.#isClosed() && this.#error === null) {
-                this.#emit({ type: 'error', message: errorMessage(error) });
+                this.#emit({
+                    type: 'error',
+                    message: this.#redact(errorMessage(error))
+                });
             }
         }
         finally {
+            this.#clearTurnTaskContext(turnId);
             // A request still open once the turn is over (it ended in an error, say)
             // is dead: answering it later would still make the agent act on it.
             this.#cancelPendingPermissions();
@@ -320,6 +421,11 @@ export class AgentSession {
             }
         }
     }
+    #clearTurnTaskContext(turnId) {
+        if (this.#turnTaskContext?.turnId === turnId) {
+            this.#turnTaskContext = undefined;
+        }
+    }
     /** A method, so TypeScript does not keep a stale narrowing across an `await`. */
     #isClosed() {
         return this.#status === 'closed';
@@ -328,6 +434,8 @@ export class AgentSession {
         if (this.#status !== 'busy' || !this.#connection || !this.#acpSessionId) {
             return;
         }
+        // Stop inheritance immediately; the agent may take time to finish cancellation.
+        this.#turnTaskContext = undefined;
         try {
             await this.#connection.agent.notify(acp.methods.agent.session.cancel, {
                 sessionId: this.#acpSessionId
@@ -336,7 +444,9 @@ export class AgentSession {
         catch (error) {
             // The connection closed since the check above: the turn is over anyway.
             if (!this.#isClosed()) {
-                throw new AgentSessionError(errorMessage(error), { cause: error });
+                throw new AgentSessionError(this.#redact(errorMessage(error)), {
+                    cause: error
+                });
             }
         }
     }
@@ -367,6 +477,9 @@ export class AgentSession {
         if (this.#status === 'closed') {
             throw new AgentSessionStateError('The session is closed');
         }
+        if (enabled && this.#options.permissionPolicy) {
+            throw new AgentSessionStateError('This session uses a fixed permission policy.');
+        }
         if (this.#autoApprove === enabled) {
             return;
         }
@@ -396,6 +509,9 @@ export class AgentSession {
         if (this.#status !== 'busy') {
             return Promise.resolve({ outcome: { outcome: 'cancelled' } });
         }
+        if (this.#options.permissionPolicy) {
+            return Promise.resolve(this.#policyPermission(params));
+        }
         const requestId = randomUUID();
         const request = mapPermissionRequest(requestId, params);
         if (this.#autoApprove) {
@@ -416,6 +532,40 @@ export class AgentSession {
             this.#emit(request);
         });
     }
+    #policyPermission(params) {
+        const previous = this.#permissionToolCalls.get(params.toolCall.toolCallId);
+        this.#permissionToolCalls.delete(params.toolCall.toolCallId);
+        let decision = {
+            allow: false,
+            reason: 'Permission policy could not verify this action.'
+        };
+        try {
+            decision = this.#options.permissionPolicy(params, previous);
+        }
+        catch {
+            // Policy failures must not create a manual prompt or grant an action.
+        }
+        const choice = decision.allow
+            ? params.options.find(option => option.kind === 'allow_once')
+            : undefined;
+        if (choice) {
+            this.#emit({ type: 'auto-approved', title: decision.reason });
+            return { outcome: { outcome: 'selected', optionId: choice.optionId } };
+        }
+        this.#emit({
+            type: 'tool',
+            toolCallId: params.toolCall.toolCallId,
+            title: 'Validation permission denied',
+            status: 'failed',
+            output: decision.allow
+                ? 'Permission policy requires an allow_once option.'
+                : decision.reason
+        });
+        const reject = params.options.find(option => option.kind === 'reject_once');
+        return reject
+            ? { outcome: { outcome: 'selected', optionId: reject.optionId } }
+            : { outcome: { outcome: 'cancelled' } };
+    }
     #onUpdate(update) {
         // Agents may speak outside a turn — pi greets with its version and skill
         // list right after session/new. That is noise in a chat transcript.
@@ -423,6 +573,24 @@ export class AgentSession {
             update.sessionUpdate === 'agent_message_chunk') {
             return;
         }
+        if (this.#options.permissionPolicy &&
+            this.#status === 'busy' &&
+            (update.sessionUpdate === 'tool_call' ||
+                update.sessionUpdate === 'tool_call_update')) {
+            if (update.status === 'completed' || update.status === 'failed') {
+                this.#permissionToolCalls.delete(update.toolCallId);
+            }
+            else {
+                const previous = this.#permissionToolCalls.get(update.toolCallId);
+                this.#permissionToolCalls.set(update.toolCallId, {
+                    ...previous,
+                    ...update
+                });
+                if (this.#permissionToolCalls.size > MAX_PERMISSION_TOOL_CALLS) {
+                    this.#permissionToolCalls.delete(this.#permissionToolCalls.keys().next().value);
+                }
+            }
+        }
         const event = mapSessionUpdate(update);
         if (event?.type === 'config') {
             // Keep `#config` current: `setConfig` checks values against it.
@@ -476,12 +644,14 @@ export class AgentSession {
         if (this.#status === 'closed') {
             return;
         }
+        this.#turnTaskContext = undefined;
         this.#setStatus('closed', this.#error ?? undefined);
         void rm(this.attachmentDir, { recursive: true, force: true }).catch(() => { });
         // Unanswered permission requests must not leave the agent blocked forever.
         this.#cancelPendingPermissions();
     }
     #cancelPendingPermissions() {
+        this.#permissionToolCalls.clear();
         // Each resolver removes itself from the map, which Map iteration allows.
         for (const pending of this.#pendingPermissions.values()) {
             pending.resolve({ outcome: { outcome: 'cancelled' } });

package/dist/server/services/agent/context-builder.js

@@ -1,3 +1,4 @@
+import { artifactBody } from "../../../shared/utils/artifact-body.js";
 import { MAX_ATTACHMENT_BYTES } from "../../../shared/agents/constants.js";
 import { AgentContextError } from "../../errors/agents.js";
 import { errorMessage } from "../../../shared/utils/error-message.js";
@@ -33,8 +34,9 @@ function fenceFor(text) {
  * goes in as an embedded resource when the agent supports it, otherwise as a
  * fenced block in a plain text part — same content either way.
  */
-function embed(deps, uri, title, mimeType, text) {
-    const body = truncateText(text, MAX_EMBEDDED_CHARS, omitted => `\n… [truncated by githuman: ${omitted} more characters]`);
+function embed(deps, uri, title, mimeType, text, prefix = '') {
+    const body = prefix +
+        truncateText(text, MAX_EMBEDDED_CHARS, omitted => `\n… [truncated by githuman: ${omitted} more characters]`);
     if (deps.embeddedContext) {
         return { type: 'resource', resource: { uri, mimeType, text: body } };
     }
@@ -173,7 +175,33 @@ async function buildNoteItem(item, deps) {
         throw asContextError(error);
     }
 }
+async function buildArtifactItem(item, deps) {
+    try {
+        const storage = deps.artifacts;
+        if (!storage || item.storeId !== storage.storeId) {
+            throw new AgentContextError('Artifact store is unavailable or has changed');
+        }
+        const { content, ...snapshot } = storage.graph.readDocumentContext(item.artifactId);
+        const { artifact } = snapshot;
+        const prefix = 'Artifact metadata snapshot (current; original frontmatter is historical):\n' +
+            JSON.stringify(snapshot) +
+            '\n\n' +
+            'Use artifacts.relations with direction and nextCursor to read remaining links. Read related documents explicitly via artifacts.get and artifacts.get_content; they are not embedded here.\n' +
+            'Cite documents with /#/artifacts?storeId=' +
+            encodeURIComponent(storage.storeId) +
+            '&selectedId=' +
+            encodeURIComponent(artifact.id) +
+            '. Related document citations use their own selectedId.\n' +
+            'Use artifacts.get_content with this artifact ID and offset=0 to read the full original UTF-8 file; follow nextOffset. bodyStartLine identifies the body. Cite artifact IDs and distinguish historical statuses from current accepted context.\n\nDocument body:\n';
+        return embed(deps, `githuman://artifact/${encodeURIComponent(item.storeId)}/${encodeURIComponent(artifact.id)}`, `Artifact ${artifact.title}:`, 'text/markdown', artifactBody(content.toString('utf8'), artifact.bodyStartLine), prefix);
+    }
+    catch (error) {
+        throw asContextError(error);
+    }
+}
 function buildItem(item, deps) {
+    if (item.kind === 'artifact')
+        return buildArtifactItem(item, deps);
     if (item.kind === 'note')
         return buildNoteItem(item, deps);
     if (item.kind === 'diff') {

package/dist/server/services/agent/session-registry.js

@@ -1,3 +1,8 @@
+import { randomBytes } from 'node:crypto';
+import { ARTIFACT_MCP_SERVER_NAME, ARTIFACT_AGENT_BEARER_PATTERN, ARTIFACT_AGENT_KEY_BYTES, ARTIFACT_AGENT_KEY_ENV, ARTIFACT_AGENT_URL_ENV } from "../../../shared/artifacts/mcp-constants.js";
+import { fileURLToPath } from 'node:url';
+import { sha256Hex } from "../../utils/hash.js";
+import { ForbiddenError } from "../../errors/http.js";
 import { UnknownAgentPresetError, TooManyAgentSessionsError } from "../../errors/agents.js";
 import { MAX_AGENT_SESSIONS } from "../../../shared/agents/constants.js";
 import { uniqueChatName } from "../../../shared/agents/chat-names.js";
@@ -7,13 +12,61 @@ export function createSessionRegistry(options) {
     const sessions = new Map();
     const unsubscribeSession = new Map();
     const listeners = new Set();
+    const keys = new Map();
+    const sessionKeys = new Map();
+    const deviceReleases = new Map();
+    const requests = new Map();
     let lastEventId = 0;
+    function revoke(id) {
+        const key = sessionKeys.get(id);
+        if (key)
+            keys.delete(key);
+        sessionKeys.delete(id);
+        deviceReleases.get(id)?.();
+        deviceReleases.delete(id);
+        for (const close of requests.get(id) ?? [])
+            close();
+        requests.delete(id);
+    }
+    function mcpServers(id) {
+        const url = options.artifactUrl?.();
+        if (!url)
+            return [];
+        if (sessions.get(id)?.status === 'closed') {
+            throw new ForbiddenError('Agent session is closed.');
+        }
+        // One live key per session: a second call replaces the first.
+        const previous = sessionKeys.get(id);
+        if (previous)
+            keys.delete(previous);
+        const key = randomBytes(ARTIFACT_AGENT_KEY_BYTES).toString('hex');
+        const hash = sha256Hex(key);
+        keys.set(hash, id);
+        sessionKeys.set(id, hash);
+        const extension = import.meta.url.endsWith('.ts') ? 'ts' : 'js';
+        return [
+            {
+                name: ARTIFACT_MCP_SERVER_NAME,
+                command: process.execPath,
+                args: [
+                    fileURLToPath(new URL(`../../../cli/index.${extension}`, import.meta.url)),
+                    'mcp',
+                    '--stdio'
+                ],
+                env: [
+                    { name: ARTIFACT_AGENT_URL_ENV, value: url },
+                    { name: ARTIFACT_AGENT_KEY_ENV, value: key }
+                ]
+            }
+        ];
+    }
     function broadcast(message) {
         for (const listener of listeners) {
             listener(message);
         }
     }
     function drop(id) {
+        revoke(id);
         unsubscribeSession.get(id)?.();
         unsubscribeSession.delete(id);
         sessions.delete(id);
@@ -27,8 +80,40 @@ export function createSessionRegistry(options) {
         }
     }
     return {
+        authenticateArtifactKey(authorization) {
+            options.connections?.recheck();
+            if (!authorization ||
+                !ARTIFACT_AGENT_BEARER_PATTERN.test(authorization)) {
+                return undefined;
+            }
+            const id = keys.get(sha256Hex(authorization.slice(7)));
+            if (!id || sessions.get(id)?.status === 'closed')
+                return undefined;
+            return id;
+        },
+        trackArtifactRequest(id, close) {
+            let pending = requests.get(id);
+            if (!pending) {
+                pending = new Set();
+                requests.set(id, pending);
+            }
+            pending.add(close);
+            let released = false;
+            // A response fires both finish and close, so the second call must do nothing.
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                pending.delete(close);
+                if (pending.size === 0 && requests.get(id) === pending) {
+                    requests.delete(id);
+                }
+            };
+        },
+        notifyTasksChanged: () => broadcast({ type: 'sessions' }),
+        notifyArtifactActionsChanged: () => broadcast({ type: 'artifact-actions' }),
         listPresets: () => options.presets.map(describePreset),
-        create(presetId, reviewId, name) {
+        create(presetId, reviewId, name, deviceId, permissionPolicy, kind) {
             const preset = options.presets.find(p => p.id === presetId);
             if (!preset) {
                 throw new UnknownAgentPresetError(`Unknown agent "${presetId}"`);
@@ -38,10 +123,17 @@ export function createSessionRegistry(options) {
             }
             const session = new AgentSession({
                 preset,
+                permissionPolicy,
+                mcpServers,
                 // Open chats are told apart by name: a taken one gets "(1)", "(2)", …
                 name: uniqueChatName(name?.trim() || preset.title, [...sessions.values()].map(s => s.name)),
                 cwd: options.repositoryPath,
                 reviewId,
+                ...(kind === undefined ? {} : { kind }),
+                ...(options.taskIds ? { taskIds: options.taskIds } : {}),
+                ...(options.taskAssignment
+                    ? { taskAssignment: options.taskAssignment }
+                    : {}),
                 nextEventId: () => ++lastEventId,
                 ...(options.bufferLimit === undefined
                     ? {}
@@ -49,17 +141,29 @@ export function createSessionRegistry(options) {
             });
             sessions.set(session.id, session);
             unsubscribeSession.set(session.id, session.onEvent(envelope => {
+                if (envelope.event.type === 'status' &&
+                    envelope.event.status === 'closed') {
+                    revoke(session.id);
+                }
                 broadcast({
                     type: 'event',
                     envelope: { ...envelope, sessionId: session.id }
                 });
             }));
+            if (deviceId !== undefined) {
+                const release = options.connections?.trackDevice(deviceId, () => session.close());
+                if (!release) {
+                    session.close();
+                    return session;
+                }
+                deviceReleases.set(session.id, release);
+            }
             broadcast({ type: 'sessions' });
             void session.start();
             return session;
         },
         get: id => sessions.get(id),
-        list: () => [...sessions.values()].map(s => s.info()),
+        list: () => [...sessions.values()].map(session => session.info()),
         close(id) {
             const session = sessions.get(id);
             if (!session) {

package/dist/server/services/agent/turn-task-context.js

@@ -0,0 +1 @@
+export {};