halfcode-compiler.xnl 0.1.1

package/dist/dist-Bkv7YeVi.js

@@ -0,0 +1,491 @@
+//#region ../../node_modules/.bun/xnl-core@0.1.12/node_modules/xnl-core/dist/index.js
+function positionToLineColumn(input, index) {
+	let line = 1;
+	let column = 1;
+	for (let i = 0; i < index && i < input.length; i++) if (input[i] === "\n") {
+		line += 1;
+		column = 1;
+	} else column += 1;
+	return {
+		line,
+		column
+	};
+}
+var XnlParseError = class extends Error {
+	constructor(code, message, input, position) {
+		const { line, column } = positionToLineColumn(input, position);
+		super(`${message} (at ${line}:${column})`);
+		this.code = code;
+		this.position = position;
+		this.line = line;
+		this.column = column;
+	}
+};
+function parseXnl(input, options = {}) {
+	const warnings = [];
+	return {
+		nodes: parseNodesFromString(input, warnings, options),
+		warnings
+	};
+}
+function parseNodesFromString(input, warnings, options = {}) {
+	const state = {
+		input,
+		pos: 0,
+		length: input.length,
+		warnings,
+		textBlockStyle: options.textBlockStyle ?? false
+	};
+	const nodes = [];
+	skipWhitespaceAndComments(state);
+	while (!eof(state)) {
+		nodes.push(parseNode(state));
+		skipWhitespaceAndComments(state);
+	}
+	return nodes;
+}
+function parseNode(state) {
+	consumeChar(state, "<", "UNEXPECTED_TOKEN", "Expected '<' to start a node");
+	const tag = readTagName(state);
+	skipWhitespaceAndComments(state);
+	const id = parseOptionalId(state);
+	const metadata = parseMetadata(state);
+	let attributes;
+	let body;
+	let extend;
+	let text;
+	let textMarker;
+	skipWhitespaceAndComments(state);
+	if (consumeIf(state, "?")) {
+		({text, textMarker} = parseTextBody(state, tag));
+		return {
+			kind: "TextElement",
+			tag,
+			id,
+			metadata,
+			attributes,
+			text,
+			textMarker
+		};
+	}
+	while (true) {
+		if (lookAhead(state, ">")) {
+			state.pos += 1;
+			return {
+				kind: "DataElement",
+				tag,
+				id,
+				metadata,
+				attributes,
+				body,
+				extend
+			};
+		}
+		if (lookAhead(state, "?")) {
+			state.pos += 1;
+			if (body || extend) throw error(state, "INVALID_CONTENT", `Text block not allowed with array/extend sections in <${tag}>`);
+			({text, textMarker} = parseTextBody(state, tag));
+			return {
+				kind: "TextElement",
+				tag,
+				id,
+				metadata,
+				attributes,
+				text,
+				textMarker
+			};
+		}
+		if (lookAhead(state, "{")) {
+			if (attributes) throw error(state, "INVALID_CONTENT", "Multiple attribute blocks are not allowed");
+			attributes = parseAttributeBlock(state, tag);
+			skipWhitespaceAndComments(state);
+			continue;
+		}
+		if (lookAhead(state, "[")) {
+			if (text) throw error(state, "INVALID_CONTENT", `Text block cannot include array block in <${tag}>`);
+			if (body) throw error(state, "INVALID_CONTENT", "Multiple array blocks are not allowed");
+			body = parseArrayBody(state, tag);
+			skipWhitespaceAndComments(state);
+			continue;
+		}
+		if (lookAhead(state, "(")) {
+			if (text) throw error(state, "INVALID_CONTENT", `Text block cannot include extend block in <${tag}>`);
+			if (extend) throw error(state, "INVALID_CONTENT", "Multiple extend blocks are not allowed");
+			extend = parseExtendBody(state, tag);
+			skipWhitespaceAndComments(state);
+			continue;
+		}
+		if (eof(state)) throw error(state, "UNEXPECTED_EOF", "Unexpected end of input");
+		throw error(state, "UNEXPECTED_TOKEN", `Unexpected token '${peek(state)}' while parsing node <${tag}>`);
+	}
+}
+function parseMetadata(state) {
+	const attrs = {};
+	while (true) {
+		skipWhitespaceAndComments(state);
+		if (lookAhead(state, "{") || lookAhead(state, "[") || lookAhead(state, "(") || lookAhead(state, "?") || lookAhead(state, ">")) break;
+		if (eof(state)) throw error(state, "UNEXPECTED_EOF", "Unexpected end while reading metadata");
+		const key = readKey(state, "Expected metadata key");
+		skipWhitespaceAndComments(state);
+		consumeChar(state, "=", "UNEXPECTED_TOKEN", "Expected '=' after metadata key");
+		skipWhitespaceAndComments(state);
+		attrs[key] = parseValueNode(state);
+	}
+	return attrs;
+}
+function parseAttributeBlock(state, name) {
+	consumeChar(state, "{", "UNEXPECTED_TOKEN", "Expected '{' to start attribute block");
+	const attrs = {};
+	while (true) {
+		skipWhitespaceAndComments(state);
+		if (consumeIf(state, "}")) return attrs;
+		if (eof(state)) throw error(state, "UNEXPECTED_EOF", `Missing closing '}' for attributes in <${name}>`);
+		const key = readKey(state, "Expected key in attribute block");
+		skipWhitespaceAndComments(state);
+		consumeChar(state, "=", "UNEXPECTED_TOKEN", "Expected '=' after key in attribute block");
+		skipWhitespaceAndComments(state);
+		attrs[key] = parseValueNode(state);
+	}
+}
+function parseArrayBody(state, name) {
+	consumeChar(state, "[", "UNEXPECTED_TOKEN", "Expected '[' to start array block");
+	const items = [];
+	while (true) {
+		skipWhitespaceAndComments(state);
+		if (consumeIf(state, "]")) return items;
+		if (eof(state)) throw error(state, "UNEXPECTED_EOF", `Missing closing ']' for array in <${name}>`);
+		if (lookAhead(state, "<")) items.push(parseNode(state));
+		else items.push(parseValueNode(state));
+	}
+}
+function parseExtendBody(state, name) {
+	consumeChar(state, "(", "UNEXPECTED_TOKEN", "Expected '(' to start extend block");
+	const children = {};
+	const order = [];
+	while (true) {
+		skipWhitespaceAndComments(state);
+		if (consumeIf(state, ")")) return {
+			children,
+			order
+		};
+		if (eof(state)) throw error(state, "UNEXPECTED_EOF", `Missing closing ')' for extend in <${name}>`);
+		if (!lookAhead(state, "<")) throw error(state, "INVALID_CONTENT", `Extend block inside <${name}> must contain child nodes`);
+		mergeChild(children, order, parseNode(state), name, state.warnings);
+	}
+}
+function parseOptionalId(state) {
+	if (!consumeIf(state, "#")) return void 0;
+	const word = parseWordLiteral(state);
+	skipWhitespaceAndComments(state);
+	return word;
+}
+function parseTextBody(state, name) {
+	const marker = readOptionalMarker(state);
+	consumeChar(state, ">", "UNEXPECTED_TOKEN", "Expected '>' after text marker");
+	const start = state.pos;
+	const expectedMarker = marker ?? "";
+	let searchPos = start;
+	let firstMismatchedCloser;
+	let firstMalformedCloser;
+	while (true) {
+		const idx = state.input.indexOf("</?", searchPos);
+		if (idx === -1) {
+			if (firstMismatchedCloser) {
+				state.pos = firstMismatchedCloser.pos;
+				throw error(state, "MISMATCHED_TAG", `Mismatched text marker for <${name}>: expected '${expectedMarker}' but found '${firstMismatchedCloser.foundMarker}'`);
+			}
+			if (firstMalformedCloser) {
+				state.pos = firstMalformedCloser.pos;
+				throw error(state, "UNEXPECTED_TOKEN", `Invalid closing text tag for <${name}>; expected '>' after marker '${firstMalformedCloser.foundMarker}'`);
+			}
+			throw error(state, "MISMATCHED_TAG", `Missing closing text tag </?${expectedMarker}> for <${name}>`);
+		}
+		const markerStart = idx + 3;
+		let i = markerStart;
+		while (i < state.length && isIdentifierChar(state.input[i])) i++;
+		const foundMarker = state.input.slice(markerStart, i);
+		if (state.input[i] !== ">") {
+			firstMalformedCloser ?? (firstMalformedCloser = {
+				pos: idx,
+				foundMarker
+			});
+			searchPos = markerStart;
+			continue;
+		}
+		if (expectedMarker !== foundMarker) {
+			firstMismatchedCloser ?? (firstMismatchedCloser = {
+				pos: idx,
+				foundMarker
+			});
+			searchPos = i + 1;
+			continue;
+		}
+		const closingIndent = indentationBefore(state.input, idx);
+		let content = stripComments(dedentContent(state.input.slice(start, idx), closingIndent));
+		if (state.textBlockStyle && content.endsWith("\n")) content = content.slice(0, -1);
+		state.pos = i + 1;
+		return {
+			text: content,
+			textMarker: marker ?? void 0
+		};
+	}
+}
+function mergeChild(children, order, node, parentName, warnings) {
+	if (children[node.tag]) {
+		warnings.push({
+			code: "DUPLICATE_CHILD",
+			message: `Duplicate child '${node.tag}' inside <${parentName} ( ... )> (later node overwrote earlier)`,
+			parentName,
+			childName: node.tag
+		});
+		const idx = order.indexOf(node.tag);
+		if (idx !== -1) order.splice(idx, 1);
+	}
+	children[node.tag] = node;
+	order.push(node.tag);
+}
+function parseValueNode(state) {
+	const ch = state.input[state.pos];
+	if (ch === "<") return parseNode(state);
+	if (ch === "{") return parseObjectLiteral(state);
+	if (ch === "[") return parseArrayLiteral(state);
+	if (ch === "'" || ch === "\"") return parseStringLiteral(state);
+	if (startsWithNumber(state)) return parseNumberLiteral(state);
+	if (startsWithBoolean(state)) return parseBooleanLiteral(state);
+	if (startsWithNull(state)) return parseNullLiteral(state);
+	if (isIdentifierStart(ch)) return parseWordLiteral(state);
+	throw error(state, "INVALID_LITERAL", `Unexpected literal starting with '${ch}'`);
+}
+function parseObjectLiteral(state) {
+	consumeChar(state, "{", "UNEXPECTED_TOKEN", "Expected '{' to start object literal");
+	const entries = {};
+	while (true) {
+		skipWhitespaceAndComments(state);
+		if (consumeIf(state, "}")) break;
+		const key = readKey(state, "Expected key in object literal");
+		skipWhitespaceAndComments(state);
+		consumeChar(state, "=", "UNEXPECTED_TOKEN", "Expected '=' after key in object literal");
+		skipWhitespaceAndComments(state);
+		entries[key] = parseValueNode(state);
+		skipWhitespaceAndComments(state);
+	}
+	return entries;
+}
+function parseArrayLiteral(state) {
+	consumeChar(state, "[", "UNEXPECTED_TOKEN", "Expected '[' to start array literal");
+	const items = [];
+	while (true) {
+		skipWhitespaceAndComments(state);
+		if (consumeIf(state, "]")) break;
+		items.push(parseValueNode(state));
+		skipWhitespaceAndComments(state);
+	}
+	return items;
+}
+function parseStringLiteral(state) {
+	const quote = consume(state);
+	let value = "";
+	while (!eof(state)) {
+		const ch = consume(state);
+		if (ch === quote) return value;
+		if (ch === "\\") {
+			const next = consume(state);
+			if (next === "n") value += "\n";
+			else if (next === "t") value += "	";
+			else if (next === "\"") value += "\"";
+			else if (next === "'") value += "'";
+			else value += next;
+		} else value += ch;
+	}
+	throw error(state, "UNEXPECTED_EOF", "Unterminated string literal");
+}
+function parseNumberLiteral(state) {
+	const start = state.pos;
+	if (state.input[state.pos] === "+" || state.input[state.pos] === "-") state.pos++;
+	while (isDigit(peek(state))) state.pos++;
+	if (peek(state) === ".") {
+		state.pos++;
+		if (!isDigit(peek(state))) throw error(state, "INVALID_LITERAL", "Invalid float literal");
+		while (isDigit(peek(state))) state.pos++;
+	}
+	if (peek(state) && (peek(state) === "e" || peek(state) === "E")) {
+		state.pos++;
+		if (peek(state) === "+" || peek(state) === "-") state.pos++;
+		if (!isDigit(peek(state))) throw error(state, "INVALID_LITERAL", "Invalid exponent in number");
+		while (isDigit(peek(state))) state.pos++;
+	}
+	const raw = state.input.slice(start, state.pos);
+	const value = Number(raw);
+	if (Number.isNaN(value)) throw error(state, "INVALID_LITERAL", "Invalid number literal");
+	return value;
+}
+function parseBooleanLiteral(state) {
+	if (lookAhead(state, "true")) {
+		state.pos += 4;
+		return true;
+	}
+	if (lookAhead(state, "false")) {
+		state.pos += 5;
+		return false;
+	}
+	throw error(state, "INVALID_LITERAL", "Invalid boolean literal");
+}
+function parseNullLiteral(state) {
+	consumeString(state, "null", "INVALID_LITERAL", "Invalid null literal");
+	return null;
+}
+function parseWordLiteral(state) {
+	const parts = [readIdentifier(state, "Expected identifier literal")];
+	while (lookAhead(state, ".")) {
+		state.pos += 1;
+		const next = readIdentifier(state, "Expected identifier segment after '.'");
+		parts.push(next);
+	}
+	return {
+		kind: "Word",
+		namespace: parts,
+		name: parts.pop()
+	};
+}
+function readOptionalMarker(state) {
+	if (!isMarkerStart(peek(state))) return void 0;
+	return readMarker(state);
+}
+function readMarker(state) {
+	const start = state.pos;
+	while (!eof(state) && isIdentifierChar(state.input[state.pos])) state.pos++;
+	return state.input.slice(start, state.pos);
+}
+function readKey(state, message) {
+	const ch = peek(state);
+	if (ch === "\"" || ch === "'") return parseStringLiteral(state);
+	return readIdentifier(state, message);
+}
+function readTagName(state) {
+	const parts = [readIdentifier(state, "Expected node name")];
+	while (lookAhead(state, ".")) {
+		state.pos += 1;
+		parts.push(readIdentifier(state, "Expected tag segment after '.'"));
+	}
+	return parts.join(".");
+}
+function readIdentifier(state, message) {
+	const start = state.pos;
+	const first = state.input[state.pos];
+	if (!isIdentifierStart(first)) throw error(state, "UNEXPECTED_TOKEN", message);
+	state.pos++;
+	while (!eof(state) && isIdentifierChar(state.input[state.pos])) state.pos++;
+	return state.input.slice(start, state.pos);
+}
+function startsWithNumber(state) {
+	const ch = state.input[state.pos];
+	if (ch === "+" || ch === "-") {
+		const next = peek(state, 1);
+		return next !== void 0 && isDigit(next);
+	}
+	return isDigit(ch);
+}
+function startsWithBoolean(state) {
+	return lookAhead(state, "true") || lookAhead(state, "false");
+}
+function startsWithNull(state) {
+	return lookAhead(state, "null");
+}
+function consumeIf(state, token) {
+	if (lookAhead(state, token)) {
+		state.pos += token.length;
+		return true;
+	}
+	return false;
+}
+function consumeString(state, token, code, message) {
+	if (!lookAhead(state, token)) throw error(state, code, message);
+	state.pos += token.length;
+}
+function lookAhead(state, token) {
+	return state.input.startsWith(token, state.pos);
+}
+function consumeChar(state, expected, code, message) {
+	const ch = consume(state);
+	if (ch !== expected) throw error(state, code, message);
+	return ch;
+}
+function consume(state) {
+	if (eof(state)) throw error(state, "UNEXPECTED_EOF", "Unexpected end of input");
+	const ch = state.input[state.pos];
+	state.pos += 1;
+	return ch;
+}
+function skipWhitespaceAndComments(state) {
+	while (!eof(state)) {
+		const ch = state.input[state.pos];
+		if (isWhitespace(ch)) {
+			state.pos++;
+			continue;
+		}
+		if (lookAhead(state, "<!--")) {
+			skipComment(state);
+			continue;
+		}
+		break;
+	}
+}
+function indentationBefore(input, index) {
+	const lastNewline = input.lastIndexOf("\n", index - 1);
+	if (lastNewline === -1) return "";
+	const indent = input.slice(lastNewline + 1, index);
+	return /^[ \t]*$/.test(indent) ? indent : "";
+}
+function dedentContent(content, indent) {
+	if (!content.includes("\n") || indent === "") return content;
+	const lines = content.split("\n");
+	const startIndex = lines[0].length === 0 ? 1 : 0;
+	return lines.slice(startIndex).map((line) => {
+		let remove = 0;
+		while (remove < indent.length && remove < line.length && line[remove] === indent[remove] && (indent[remove] === " " || indent[remove] === "	")) remove++;
+		return line.slice(remove);
+	}).join("\n");
+}
+function stripComments(content) {
+	return content.replace(/<!--[\\s\\S]*?-->/g, "");
+}
+function eof(state) {
+	return state.pos >= state.length;
+}
+function peek(state, offset = 0) {
+	const idx = state.pos + offset;
+	return idx < state.length ? state.input[idx] : void 0;
+}
+function isIdentifierStart(ch) {
+	if (!ch) return false;
+	return /[A-Za-z_]/.test(ch);
+}
+function isIdentifierChar(ch) {
+	if (!ch) return false;
+	return /[A-Za-z0-9_-]/.test(ch);
+}
+function isMarkerStart(ch) {
+	return isIdentifierStart(ch) || isDigit(ch);
+}
+function isWhitespace(ch) {
+	return ch === " " || ch === "	" || ch === "\n" || ch === "\r";
+}
+function isDigit(ch) {
+	return ch !== void 0 && ch >= "0" && ch <= "9";
+}
+function error(state, code, message) {
+	return new XnlParseError(code, message, state.input, state.pos);
+}
+function skipComment(state) {
+	if (!lookAhead(state, "<!--")) return;
+	const end = state.input.indexOf("-->", state.pos + 4);
+	if (end === -1) throw error(state, "UNEXPECTED_EOF", "Unterminated comment");
+	state.pos = end + 3;
+}
+function wordToString(word) {
+	if (!word) return void 0;
+	const str = [...(word.namespace ?? []).filter(Boolean), word.name].filter((p) => p !== void 0 && p !== null).join(".");
+	return str.length ? str : void 0;
+}
+//#endregion
+export { wordToString as n, parseXnl as t };

package/dist/index-Ba5Gt9iW.d.ts

@@ -0,0 +1,67 @@
+//#region ../resource-core/src/index.d.ts
+type SourceShape = "single-file" | "directory" | "manifest";
+interface ResourceIdentity {
+  kind: string;
+  fqn?: string;
+  name?: string;
+}
+interface ResourceDescriptor extends ResourceIdentity {
+  description?: string;
+}
+interface ResourceMetadata {
+  apiVersion: string;
+  lifecycle?: string;
+  version?: string;
+}
+type ResourceScalar = string | number | boolean | null;
+interface ResourceValueList extends ReadonlyArray<ResourceValue> {}
+interface ResourceValueMap extends Readonly<Record<string, ResourceValue>> {}
+type ResourceValue = ResourceScalar | ResourceNode | ResourceValueList | ResourceValueMap;
+interface ResourceNode {
+  readonly tag: string;
+  readonly resourceId?: string;
+  readonly metadata: Readonly<Record<string, ResourceValue>>;
+  readonly properties: Readonly<Record<string, ResourceValue>>;
+  readonly body: readonly ResourceValue[];
+  readonly subdomains: Readonly<Record<string, ResourceNode>>;
+  readonly text?: string;
+}
+interface ResourceRecord extends ResourceDescriptor {
+  resourceId: string;
+  metadata: ResourceMetadata;
+  sourceShape: SourceShape;
+  logicalPath: string;
+  documentUri: string;
+  format: "xnl";
+  node: ResourceNode;
+}
+interface ResourceRegistry {
+  readonly byKind: ReadonlyMap<string, readonly ResourceRecord[]>;
+}
+interface ResourceTree {
+  manifest: ResourceRecord;
+  registry: ResourceRegistry;
+  diagnostics: readonly ResourceDiagnostic[];
+}
+interface ResourceDiagnostic {
+  code: string;
+  location: string;
+  message: string;
+  hint?: string;
+}
+interface LoadResourceTreeOptions {
+  rootDir: string;
+  manifestPath?: string;
+}
+interface ResourceTreeBuildResult {
+  diagnostics: ResourceDiagnostic[];
+  tree?: ResourceTree;
+}
+declare class ResourceValidationError extends Error {
+  readonly diagnostics: readonly ResourceDiagnostic[];
+  constructor(diagnostics: readonly ResourceDiagnostic[]);
+}
+declare function loadResourceTree(options: LoadResourceTreeOptions): Promise<ResourceTree>;
+declare function validateResourceTree(options: LoadResourceTreeOptions): Promise<ResourceDiagnostic[]>;
+//#endregion
+export { loadResourceTree as _, ResourceMetadata as a, ResourceRegistry as c, ResourceTreeBuildResult as d, ResourceValidationError as f, SourceShape as g, ResourceValueMap as h, ResourceIdentity as i, ResourceScalar as l, ResourceValueList as m, ResourceDescriptor as n, ResourceNode as o, ResourceValue as p, ResourceDiagnostic as r, ResourceRecord as s, LoadResourceTreeOptions as t, ResourceTree as u, validateResourceTree as v };

package/dist/index-D-cBhQVw.d.ts

@@ -0,0 +1,38 @@
+import { t as ApplicationAssembly } from "./index-FdimP_SL.js";
+import { t as ResourceRegistry } from "./index-DuRG4TQo.js";
+//#region ../compiler-skill/src/index.d.ts
+interface SkillDescriptor {
+  name: string;
+  description: string;
+  instructions?: string;
+}
+interface SkillReference {
+  path: string;
+  content: string;
+}
+interface CompileSkillCapsuleInput {
+  skill: SkillDescriptor;
+  registry?: ResourceRegistry;
+  references?: readonly SkillReference[];
+  outputDir: string;
+}
+interface SkillCapsulePlan {
+  skillName: string;
+  outputRoot: string;
+  files: readonly string[];
+}
+interface CompileResourceSkillCapsuleInput {
+  assembly: ApplicationAssembly;
+  skillFqn: string;
+  outputDir: string;
+  schemas?: ReadonlyMap<string, unknown> | Record<string, unknown>;
+}
+declare function compileSkillCapsule(input: CompileSkillCapsuleInput): Promise<SkillCapsulePlan>;
+declare function compileResourceSkillCapsule(input: CompileResourceSkillCapsuleInput): Promise<SkillCapsulePlan>;
+declare const compilerSkillPackage: {
+  readonly role: "framework";
+  readonly area: "compiler-skill";
+  readonly owns: "standard Skill capsule projection";
+};
+//#endregion
+export { SkillReference as a, compilerSkillPackage as c, SkillDescriptor as i, CompileSkillCapsuleInput as n, compileResourceSkillCapsule as o, SkillCapsulePlan as r, compileSkillCapsule as s, CompileResourceSkillCapsuleInput as t };

package/dist/index-Dg0imcjf.d.ts

@@ -0,0 +1,31 @@
+//#region ../runtime-authoring/src/index.d.ts
+interface Logger {
+  info(message: string, fields?: Readonly<Record<string, unknown>>): void;
+  warn(message: string, fields?: Readonly<Record<string, unknown>>): void;
+  error(message: string, fields?: Readonly<Record<string, unknown>>): void;
+}
+interface RuntimeEffects {
+  logger: Logger;
+  invoke<TResult = unknown>(effectFqn: string, input: unknown): Promise<TResult>;
+}
+interface AuthoringRuntime<TContext extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>> {
+  context: TContext;
+  effects: RuntimeEffects;
+}
+interface AuthoringBindings {
+  readonly runtime: AuthoringRuntime;
+  readonly logger: Logger;
+  invokeEffect<TResult = unknown>(effectFqn: string, input: unknown): Promise<TResult>;
+}
+declare function runWithRuntime<T>(runtime: AuthoringRuntime, callback: () => T): T;
+declare function currentRuntime(): AuthoringRuntime;
+declare function createAuthoringBindings(runtime?: AuthoringRuntime<Readonly<Record<string, unknown>>>): AuthoringBindings;
+declare const logger: Logger;
+declare function invokeEffect<TResult = unknown>(effectFqn: string, input: unknown): Promise<TResult>;
+declare const runtimeAuthoringPackage: {
+  readonly role: "framework";
+  readonly area: "runtime-authoring";
+  readonly owns: "target-neutral deterministic-code runtime and effect boundary";
+};
+//#endregion
+export { createAuthoringBindings as a, logger as c, RuntimeEffects as i, runWithRuntime as l, AuthoringRuntime as n, currentRuntime as o, Logger as r, invokeEffect as s, AuthoringBindings as t, runtimeAuthoringPackage as u };

package/dist/index-DuRG4TQo.d.ts

@@ -0,0 +1,12 @@
+import { n as ResourceDescriptor } from "./index-Ba5Gt9iW.js";
+//#region ../resource-projection/src/index.d.ts
+interface ResourceRegistry {
+  readonly byKind: ReadonlyMap<string, readonly ResourceDescriptor[]>;
+}
+declare const resourceProjectionPackage: {
+  readonly role: "framework";
+  readonly area: "resource-projection";
+  readonly owns: "validated registry facts and target projection inputs";
+};
+//#endregion
+export { resourceProjectionPackage as n, ResourceRegistry as t };