@axintai/compiler 0.2.1 → 0.3.0

package/dist/core/index.js

@@ -38,6 +38,10 @@ function irTypeToSwift(type) {
       return `${irTypeToSwift(type.innerType)}?`;
     case "entity":
       return type.entityName;
+    case "entityQuery":
+      return `${type.entityName}Query`;
+    case "dynamicOptions":
+      return `[DynamicOptionsResult<${irTypeToSwift(type.valueType)}>]`;
     case "enum":
       return type.name;
   }
@@ -53,6 +57,9 @@ function parseIntentSource(source, filePath = "<stdin>") {
     // setParentNodes
     ts.ScriptKind.TS
   );
+  const entities = findDefineEntityCalls(sourceFile).map(
+    (call) => parseEntityDefinition(call, filePath, sourceFile)
+  );
   const defineIntentCall = findDefineIntentCall(sourceFile);
   if (!defineIntentCall) {
     throw new ParserError(
@@ -115,6 +122,10 @@ function parseIntentSource(source, filePath = "<stdin>") {
   const entitlements = readStringArray(entitlementsNode);
   const infoPlistNode = props.get("infoPlistKeys");
   const infoPlistKeys = readStringRecord(infoPlistNode);
+  const donateOnPerformNode = props.get("donateOnPerform");
+  const donateOnPerform = readBooleanLiteral(donateOnPerformNode);
+  const customResultTypeNode = props.get("customResultType");
+  const customResultType = readStringLiteral(customResultTypeNode);
   return {
     name,
     title,
@@ -126,7 +137,10 @@ function parseIntentSource(source, filePath = "<stdin>") {
     sourceFile: filePath,
     entitlements: entitlements.length > 0 ? entitlements : void 0,
     infoPlistKeys: Object.keys(infoPlistKeys).length > 0 ? infoPlistKeys : void 0,
-    isDiscoverable: isDiscoverable ?? void 0
+    isDiscoverable: isDiscoverable ?? void 0,
+    entities: entities.length > 0 ? entities : void 0,
+    donateOnPerform: donateOnPerform ?? void 0,
+    customResultType: customResultType ?? void 0
   };
 }
 function findDefineIntentCall(node) {
@@ -142,6 +156,18 @@ function findDefineIntentCall(node) {
   visit(node);
   return found;
 }
+function findDefineEntityCalls(node) {
+  const found = [];
+  const visit = (n) => {
+    if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && n.expression.text === "defineEntity") {
+      found.push(n);
+      return;
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(node);
+  return found;
+}
 function propertyMap(obj) {
   const map = /* @__PURE__ */ new Map();
   for (const prop of obj.properties) {
@@ -195,6 +221,77 @@ function readStringRecord(node) {
   }
   return rec;
 }
+function parseEntityDefinition(call, filePath, sourceFile) {
+  const arg = call.arguments[0];
+  if (!arg || !ts.isObjectLiteralExpression(arg)) {
+    throw new ParserError(
+      "AX015",
+      "defineEntity() must be called with an object literal",
+      filePath,
+      posOf(sourceFile, call),
+      "Pass an object: defineEntity({ name, display, properties, query })"
+    );
+  }
+  const props = propertyMap(arg);
+  const name = readStringLiteral(props.get("name"));
+  if (!name) {
+    throw new ParserError(
+      "AX016",
+      "Entity definition missing required field: name",
+      filePath,
+      posOf(sourceFile, arg),
+      'Add a name field: name: "Task"'
+    );
+  }
+  const displayNode = props.get("display");
+  if (!displayNode || !ts.isObjectLiteralExpression(displayNode)) {
+    throw new ParserError(
+      "AX017",
+      "Entity definition missing required field: display",
+      filePath,
+      posOf(sourceFile, arg),
+      'Add display field: display: { title: "name", subtitle: "status" }'
+    );
+  }
+  const displayProps = propertyMap(displayNode);
+  const displayRepresentation = {
+    title: readStringLiteral(displayProps.get("title")) || "name",
+    subtitle: readStringLiteral(displayProps.get("subtitle")) || void 0,
+    image: readStringLiteral(displayProps.get("image")) || void 0
+  };
+  const propertiesNode = props.get("properties");
+  const properties = propertiesNode ? extractParameters(propertiesNode, filePath, sourceFile) : [];
+  const queryTypeNode = props.get("query");
+  const queryTypeStr = readStringLiteral(queryTypeNode);
+  const queryType = validateQueryType(queryTypeStr, filePath, sourceFile, queryTypeNode);
+  return {
+    name,
+    displayRepresentation,
+    properties,
+    queryType
+  };
+}
+function validateQueryType(value, filePath, sourceFile, node) {
+  if (!value) {
+    throw new ParserError(
+      "AX018",
+      "Entity definition missing required field: query",
+      filePath,
+      node ? posOf(sourceFile, node) : void 0,
+      'Add query field: query: "string" (or "all", "id", "property")'
+    );
+  }
+  const valid = ["all", "id", "string", "property"];
+  if (!valid.includes(value)) {
+    throw new ParserError(
+      "AX019",
+      `Invalid query type: "${value}". Must be one of: all, id, string, property`,
+      filePath,
+      node ? posOf(sourceFile, node) : void 0
+    );
+  }
+  return value;
+}
 function extractParameters(node, filePath, sourceFile) {
   if (!ts.isObjectLiteralExpression(node)) {
     throw new ParserError(
@@ -210,20 +307,20 @@ function extractParameters(node, filePath, sourceFile) {
     if (!ts.isPropertyAssignment(prop)) continue;
     const paramName = propertyKeyName(prop.name);
     if (!paramName) continue;
-    const { typeName, description, configObject } = extractParamCall(
+    const { typeName, description, configObject, callExpr } = extractParamCall(
       prop.initializer,
       filePath,
       sourceFile
     );
-    const resolvedType = resolveParamType(typeName, filePath, sourceFile, prop);
+    const resolvedType = resolveParamType(typeName, filePath, sourceFile, prop, callExpr);
     const isOptional = configObject ? readBooleanLiteral(configObject.get("required")) === false : false;
     const defaultExpr = configObject?.get("default");
     const defaultValue = defaultExpr ? evaluateLiteral(defaultExpr) : void 0;
     const titleFromConfig = configObject ? readStringLiteral(configObject.get("title")) : null;
     const irType = isOptional ? {
       kind: "optional",
-      innerType: { kind: "primitive", value: resolvedType }
-    } : { kind: "primitive", value: resolvedType };
+      innerType: resolvedType
+    } : resolvedType;
     params.push({
       name: paramName,
       type: irType,
@@ -255,34 +352,98 @@ function extractParamCall(expr, filePath, sourceFile) {
     );
   }
   const typeName = expr.expression.name.text;
-  const descriptionArg = expr.arguments[0];
-  const configArg = expr.arguments[1];
+  let descriptionArg;
+  let configArg;
+  if (typeName === "entity" && expr.arguments.length >= 2) {
+    descriptionArg = expr.arguments[1];
+    configArg = expr.arguments[2];
+  } else if (typeName === "dynamicOptions" && expr.arguments.length >= 3) {
+    descriptionArg = expr.arguments[2];
+    configArg = expr.arguments[3];
+  } else {
+    descriptionArg = expr.arguments[0];
+    configArg = expr.arguments[1];
+  }
   const description = descriptionArg ? readStringLiteral(descriptionArg) : null;
   if (description === null) {
     throw new ParserError(
       "AX008",
-      `param.${typeName}() requires a string description as the first argument`,
+      `param.${typeName}() requires a string description`,
       filePath,
       posOf(sourceFile, expr),
       `Example: param.${typeName}("Human-readable description")`
     );
   }
   const configObject = configArg && ts.isObjectLiteralExpression(configArg) ? propertyMap(configArg) : null;
-  return { typeName, description, configObject };
+  return { typeName, description, configObject, callExpr: expr };
 }
-function resolveParamType(typeName, filePath, sourceFile, node) {
+function resolveParamType(typeName, filePath, sourceFile, node, callExpr) {
   if (PARAM_TYPES.has(typeName)) {
-    return typeName;
+    return { kind: "primitive", value: typeName };
   }
   if (typeName in LEGACY_PARAM_ALIASES) {
-    return LEGACY_PARAM_ALIASES[typeName];
+    return {
+      kind: "primitive",
+      value: LEGACY_PARAM_ALIASES[typeName]
+    };
+  }
+  if (typeName === "entity") {
+    if (!callExpr || callExpr.arguments.length === 0) {
+      throw new ParserError(
+        "AX020",
+        "param.entity() requires the entity name as the first argument",
+        filePath,
+        posOf(sourceFile, node),
+        'Example: param.entity("Task", "Reference an entity")'
+      );
+    }
+    const entityName = readStringLiteral(callExpr.arguments[0]);
+    if (!entityName) {
+      throw new ParserError(
+        "AX021",
+        "param.entity() requires a string entity name",
+        filePath,
+        posOf(sourceFile, node)
+      );
+    }
+    return {
+      kind: "entity",
+      entityName,
+      properties: []
+    };
+  }
+  if (typeName === "dynamicOptions") {
+    if (!callExpr || callExpr.arguments.length < 2) {
+      throw new ParserError(
+        "AX022",
+        "param.dynamicOptions() requires (providerName, paramType)",
+        filePath,
+        posOf(sourceFile, node),
+        'Example: param.dynamicOptions("PlaylistProvider", param.string(...))'
+      );
+    }
+    const providerName = readStringLiteral(callExpr.arguments[0]);
+    if (!providerName) {
+      throw new ParserError(
+        "AX023",
+        "param.dynamicOptions() provider name must be a string",
+        filePath,
+        posOf(sourceFile, node)
+      );
+    }
+    const valueType = { kind: "primitive", value: "string" };
+    return {
+      kind: "dynamicOptions",
+      valueType,
+      providerName
+    };
   }
   throw new ParserError(
     "AX005",
     `Unknown param type: param.${typeName}`,
     filePath,
     posOf(sourceFile, node),
-    `Supported types: ${[...PARAM_TYPES].join(", ")}`
+    `Supported types: ${[...PARAM_TYPES].join(", ")}, entity, dynamicOptions`
   );
 }
 function evaluateLiteral(node) {
@@ -400,6 +561,14 @@ function generateSwift(intent) {
   lines.push(`import AppIntents`);
   lines.push(`import Foundation`);
   lines.push(``);
+  if (intent.entities && intent.entities.length > 0) {
+    for (const entity of intent.entities) {
+      lines.push(generateEntity(entity));
+      lines.push(``);
+      lines.push(generateEntityQuery(entity));
+      lines.push(``);
+    }
+  }
   lines.push(`struct ${intent.name}Intent: AppIntent {`);
   lines.push(
     `    static let title: LocalizedStringResource = "${escapeSwiftString(intent.title)}"`
@@ -411,33 +580,115 @@ function generateSwift(intent) {
     lines.push(`    static let isDiscoverable: Bool = ${intent.isDiscoverable}`);
   }
   lines.push(``);
-  for (const param of intent.parameters) {
-    lines.push(generateParameter(param));
+  for (const param2 of intent.parameters) {
+    lines.push(generateParameter(param2));
   }
   if (intent.parameters.length > 0) {
     lines.push(``);
   }
-  const returnTypeSignature = generateReturnSignature(intent.returnType);
+  const returnTypeSignature = generateReturnSignature(
+    intent.returnType,
+    intent.customResultType
+  );
   lines.push(`    func perform() async throws -> ${returnTypeSignature} {`);
   lines.push(`        // TODO: Implement your intent logic here.`);
   if (intent.parameters.length > 0) {
     const paramList = intent.parameters.map((p) => `\\(${p.name})`).join(", ");
     lines.push(`        // Parameters available: ${paramList}`);
   }
-  lines.push(generatePerformReturn(intent.returnType));
+  if (intent.donateOnPerform) {
+    lines.push(`        `);
+    lines.push(`        // Donate this intent to Siri and Spotlight`);
+    lines.push(`        try? await IntentDonationManager.shared.donate(intent: self)`);
+  }
+  lines.push(generatePerformReturn(intent.returnType, intent.customResultType));
   lines.push(`    }`);
   lines.push(`}`);
   lines.push(``);
   return lines.join("\n");
 }
+function generateEntity(entity) {
+  const lines = [];
+  const propertyNames = new Set(entity.properties.map((p) => p.name));
+  lines.push(`struct ${entity.name}: AppEntity {`);
+  lines.push(`    static var defaultQuery = ${entity.name}Query()`);
+  lines.push(``);
+  const hasId = propertyNames.has("id");
+  if (!hasId) {
+    lines.push(`    var id: String`);
+  }
+  for (const prop of entity.properties) {
+    const swiftType = irTypeToSwift(prop.type);
+    lines.push(`    var ${prop.name}: ${swiftType}`);
+  }
+  lines.push(``);
+  lines.push(
+    `    static let typeDisplayRepresentation: TypeDisplayRepresentation = TypeDisplayRepresentation(`
+  );
+  lines.push(
+    `        name: LocalizedStringResource("${escapeSwiftString(entity.name)}")`
+  );
+  lines.push(`    )`);
+  lines.push(``);
+  lines.push(`    var displayRepresentation: DisplayRepresentation {`);
+  lines.push(`        DisplayRepresentation(`);
+  lines.push(
+    `            title: "\\(${entity.displayRepresentation.title})"${entity.displayRepresentation.subtitle || entity.displayRepresentation.image ? "," : ""}`
+  );
+  if (entity.displayRepresentation.subtitle) {
+    const hasImage = !!entity.displayRepresentation.image;
+    lines.push(
+      `            subtitle: "\\(${entity.displayRepresentation.subtitle})"${hasImage ? "," : ""}`
+    );
+  }
+  if (entity.displayRepresentation.image) {
+    lines.push(
+      `            image: .init(systemName: "${escapeSwiftString(entity.displayRepresentation.image)}")`
+    );
+  }
+  lines.push(`        )`);
+  lines.push(`    }`);
+  lines.push(`}`);
+  return lines.join("\n");
+}
+function generateEntityQuery(entity) {
+  const lines = [];
+  const queryType = entity.queryType;
+  lines.push(`struct ${entity.name}Query: EntityQuery {`);
+  lines.push(
+    `    func entities(for identifiers: [${entity.name}.ID]) async throws -> [${entity.name}] {`
+  );
+  lines.push(`        // TODO: Fetch entities by IDs`);
+  lines.push(`        return []`);
+  lines.push(`    }`);
+  lines.push(``);
+  if (queryType === "all") {
+    lines.push(`    func allEntities() async throws -> [${entity.name}] {`);
+    lines.push(`        // TODO: Return all entities`);
+    lines.push(`        return []`);
+    lines.push(`    }`);
+  } else if (queryType === "id") {
+    lines.push(`    // ID-based query is provided by the entities(for:) method above`);
+  } else if (queryType === "string") {
+    lines.push(
+      `    func entities(matching string: String) async throws -> [${entity.name}] {`
+    );
+    lines.push(`        // TODO: Search entities by string`);
+    lines.push(`        return []`);
+    lines.push(`    }`);
+  } else if (queryType === "property") {
+    lines.push(`    // Property-based query: implement using EntityPropertyQuery`);
+    lines.push(`    // Example: property.where { \\$0.status == "active" }`);
+  }
+  lines.push(`}`);
+  return lines.join("\n");
+}
 function generateInfoPlistFragment(intent) {
   const keys = intent.infoPlistKeys;
   if (!keys || Object.keys(keys).length === 0) return void 0;
   const lines = [];
   lines.push(`<?xml version="1.0" encoding="UTF-8"?>`);
-  lines.push(
-    `<!-- Info.plist fragment generated by Axint for ${intent.name}Intent -->`
-  );
+  lines.push(`<!-- Info.plist fragment generated by Axint for ${intent.name}Intent -->`);
   lines.push(`<!-- Merge these keys into your app's Info.plist. -->`);
   lines.push(`<plist version="1.0">`);
   lines.push(`<dict>`);
@@ -475,26 +726,29 @@ function generateEntitlementsFragment(intent) {
   lines.push(``);
   return lines.join("\n");
 }
-function generateParameter(param) {
-  const swiftType = irTypeToSwift(param.type);
+function generateParameter(param2) {
+  const swiftType = irTypeToSwift(param2.type);
   const lines = [];
   const attrs = [];
-  attrs.push(`title: "${escapeSwiftString(param.title)}"`);
-  if (param.description) {
-    attrs.push(`description: "${escapeSwiftString(param.description)}"`);
+  attrs.push(`title: "${escapeSwiftString(param2.title)}"`);
+  if (param2.description) {
+    attrs.push(`description: "${escapeSwiftString(param2.description)}"`);
   }
   const decorator = `    @Parameter(${attrs.join(", ")})`;
   lines.push(decorator);
-  if (param.defaultValue !== void 0) {
-    const defaultStr = formatSwiftDefault(param.defaultValue, param.type);
-    lines.push(`    var ${param.name}: ${swiftType} = ${defaultStr}`);
+  if (param2.defaultValue !== void 0) {
+    const defaultStr = formatSwiftDefault(param2.defaultValue, param2.type);
+    lines.push(`    var ${param2.name}: ${swiftType} = ${defaultStr}`);
   } else {
-    lines.push(`    var ${param.name}: ${swiftType}`);
+    lines.push(`    var ${param2.name}: ${swiftType}`);
   }
   lines.push(``);
   return lines.join("\n");
 }
-function generateReturnSignature(type) {
+function generateReturnSignature(type, customResultType) {
+  if (customResultType) {
+    return customResultType;
+  }
   if (type.kind === "primitive") {
     const swift = irTypeToSwift(type);
     return `some IntentResult & ReturnsValue<${swift}>`;
@@ -505,8 +759,11 @@ function generateReturnSignature(type) {
   }
   return `some IntentResult`;
 }
-function generatePerformReturn(type) {
+function generatePerformReturn(type, customResultType) {
   const indent = "        ";
+  if (customResultType) {
+    return `${indent}// TODO: Return a ${customResultType} instance`;
+  }
   if (type.kind === "primitive") {
     return `${indent}return .result(value: ${defaultLiteralFor(type.value)})`;
   }
@@ -579,21 +836,21 @@ function validateIntent(intent) {
       suggestion: "Add a description explaining what this intent does"
     });
   }
-  for (const param of intent.parameters) {
-    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(param.name)) {
+  for (const param2 of intent.parameters) {
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(param2.name)) {
       diagnostics.push({
         code: "AX103",
         severity: "error",
-        message: `Parameter name "${param.name}" is not a valid Swift identifier`,
+        message: `Parameter name "${param2.name}" is not a valid Swift identifier`,
         file: intent.sourceFile,
-        suggestion: `Rename to "${param.name.replace(/[^a-zA-Z0-9_]/g, "_")}"`
+        suggestion: `Rename to "${param2.name.replace(/[^a-zA-Z0-9_]/g, "_")}"`
       });
     }
-    if (!param.description || param.description.trim().length === 0) {
+    if (!param2.description || param2.description.trim().length === 0) {
       diagnostics.push({
         code: "AX104",
         severity: "warning",
-        message: `Parameter "${param.name}" has no description \u2014 Siri will display it without context`,
+        message: `Parameter "${param2.name}" has no description \u2014 Siri will display it without context`,
         file: intent.sourceFile,
         suggestion: "Add a description for better Siri/Shortcuts display"
       });
@@ -617,17 +874,17 @@ function validateIntent(intent) {
     });
   }
   const seen = /* @__PURE__ */ new Set();
-  for (const param of intent.parameters) {
-    if (seen.has(param.name)) {
+  for (const param2 of intent.parameters) {
+    if (seen.has(param2.name)) {
       diagnostics.push({
         code: "AX107",
         severity: "error",
-        message: `Duplicate parameter name "${param.name}"`,
+        message: `Duplicate parameter name "${param2.name}"`,
         file: intent.sourceFile,
         suggestion: "Each parameter in a single intent must have a unique name"
       });
     }
-    seen.add(param.name);
+    seen.add(param2.name);
   }
   for (const ent of intent.entitlements ?? []) {
     if (!/^[a-zA-Z0-9._-]+$/.test(ent) || !ent.includes(".")) {
@@ -651,6 +908,54 @@ function validateIntent(intent) {
       });
     }
   }
+  if (intent.entities) {
+    for (const entity of intent.entities) {
+      diagnostics.push(...validateEntity(entity, intent.sourceFile));
+    }
+  }
+  return diagnostics;
+}
+function validateEntity(entity, sourceFile) {
+  const diagnostics = [];
+  if (!entity.name || !/^[A-Z][a-zA-Z0-9]*$/.test(entity.name)) {
+    diagnostics.push({
+      code: "AX110",
+      severity: "error",
+      message: `Entity name "${entity.name}" must be PascalCase (e.g., "Task", "Playlist")`,
+      file: sourceFile,
+      suggestion: `Rename to "${toPascalCase(entity.name)}"`
+    });
+  }
+  if (entity.properties.length === 0) {
+    diagnostics.push({
+      code: "AX111",
+      severity: "error",
+      message: `Entity "${entity.name}" must have at least one property`,
+      file: sourceFile,
+      suggestion: "Add properties to define the entity's structure"
+    });
+  }
+  const titleProp = entity.displayRepresentation.title;
+  const propertyNames = new Set(entity.properties.map((p) => p.name));
+  if (titleProp && !propertyNames.has(titleProp)) {
+    diagnostics.push({
+      code: "AX112",
+      severity: "warning",
+      message: `Display title "${titleProp}" does not reference an existing property`,
+      file: sourceFile,
+      suggestion: `Available properties: ${[...propertyNames].join(", ")}`
+    });
+  }
+  const validQueryTypes = ["all", "id", "string", "property"];
+  if (!validQueryTypes.includes(entity.queryType)) {
+    diagnostics.push({
+      code: "AX113",
+      severity: "error",
+      message: `Entity query type "${entity.queryType}" is not valid`,
+      file: sourceFile,
+      suggestion: `Use one of: ${validQueryTypes.join(", ")}`
+    });
+  }
   return diagnostics;
 }
 function validateSwiftSource(swift) {
@@ -704,7 +1009,6 @@ function compileFile(filePath, options = {}) {
   return compileSource(source, filePath, options);
 }
 function compileSource(source, fileName = "<stdin>", options = {}) {
-  const diagnostics = [];
   let ir;
   try {
     ir = parseIntentSource(source, fileName);
@@ -726,6 +1030,10 @@ function compileSource(source, fileName = "<stdin>", options = {}) {
     }
     throw err;
   }
+  return compileFromIR(ir, options);
+}
+function compileFromIR(ir, options = {}) {
+  const diagnostics = [];
   const irDiagnostics = validateIntent(ir);
   diagnostics.push(...irDiagnostics);
   if (irDiagnostics.some((d) => d.severity === "error")) {
@@ -756,20 +1064,262 @@ function compileSource(source, fileName = "<stdin>", options = {}) {
     diagnostics
   };
 }
+var VALID_PRIMITIVES = /* @__PURE__ */ new Set([
+  "string",
+  "int",
+  "double",
+  "float",
+  "boolean",
+  "date",
+  "duration",
+  "url"
+]);
+function irFromJSON(data) {
+  const parameters = (data.parameters ?? []).map(
+    (p) => {
+      const param2 = p;
+      return {
+        name: param2.name,
+        type: normalizeIRType(param2.type),
+        title: param2.title ?? param2.description ?? "",
+        description: param2.description ?? "",
+        isOptional: param2.optional ?? param2.isOptional ?? false,
+        defaultValue: param2.default ?? param2.defaultValue
+      };
+    }
+  );
+  return {
+    name: data.name,
+    title: data.title,
+    description: data.description,
+    domain: data.domain,
+    parameters,
+    returnType: data.returnType ? normalizeIRType(data.returnType) : { kind: "primitive", value: "string" },
+    sourceFile: data.sourceFile ?? void 0,
+    entitlements: data.entitlements ?? void 0,
+    infoPlistKeys: data.infoPlistKeys ?? void 0,
+    isDiscoverable: data.isDiscoverable ?? true
+  };
+}
+function normalizeIRType(type) {
+  if (typeof type === "string") {
+    const normalized = type === "number" ? "int" : type;
+    if (VALID_PRIMITIVES.has(normalized)) {
+      return { kind: "primitive", value: normalized };
+    }
+    return { kind: "primitive", value: "string" };
+  }
+  if (type && typeof type === "object") {
+    const t = type;
+    if (t.kind === "primitive") return type;
+    if (t.kind === "array")
+      return { kind: "array", elementType: normalizeIRType(t.elementType) };
+    if (t.kind === "optional")
+      return { kind: "optional", innerType: normalizeIRType(t.innerType) };
+    if (t.kind === "entity") return type;
+    if (t.kind === "enum") return type;
+  }
+  return { kind: "primitive", value: "string" };
+}
+
+// src/core/eject.ts
+function ejectIntent(source, fileName, options = {}) {
+  const compileResult = compileSource(source, fileName, {
+    validate: true,
+    emitInfoPlist: true,
+    emitEntitlements: true
+  });
+  if (!compileResult.success || !compileResult.output) {
+    throw new Error(
+      `Compilation failed: ${compileResult.diagnostics.filter((d) => d.severity === "error").map((d) => d.message).join("; ")}`
+    );
+  }
+  const { ir, swiftCode, infoPlistFragment, entitlementsFragment } = compileResult.output;
+  const outDir = options.outDir ?? ".";
+  const ejectedSwift = transformSwiftForEject(swiftCode, ir);
+  const intentFileName = `${ir.name}Intent.swift`;
+  const swiftPath = `${outDir}/${intentFileName}`;
+  const plistPath = infoPlistFragment ? `${outDir}/${ir.name}Intent.plist.fragment.xml` : null;
+  const entitlementsPath = entitlementsFragment ? `${outDir}/${ir.name}Intent.entitlements.fragment.xml` : null;
+  const testPath = options.includeTests ? `${outDir}/${ir.name}IntentTests.swift` : null;
+  const result = {
+    swiftFile: {
+      path: swiftPath,
+      content: ejectedSwift
+    }
+  };
+  if (infoPlistFragment && plistPath) {
+    result.infoPlist = {
+      path: plistPath,
+      content: infoPlistFragment
+    };
+  }
+  if (entitlementsFragment && entitlementsPath) {
+    result.entitlements = {
+      path: entitlementsPath,
+      content: entitlementsFragment
+    };
+  }
+  if (options.includeTests && testPath) {
+    result.testFile = {
+      path: testPath,
+      content: generateTestFile(ir)
+    };
+  }
+  return result;
+}
+function transformSwiftForEject(swiftCode, ir) {
+  const lines = swiftCode.split("\n");
+  const result = [];
+  let inHeader = true;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (inHeader && line.startsWith("// ")) {
+      if (i === 0) {
+        result.push(`// ${ir.name}Intent.swift`);
+      } else if (line.includes("Generated by Axint")) {
+        result.push(
+          `// Originally generated by Axint (https://github.com/agenticempire/axint)`
+        );
+      } else if (line.includes("Do not edit manually")) {
+      } else {
+        result.push(line);
+      }
+    } else if (line === "") {
+      inHeader = false;
+      result.push(line);
+    } else {
+      inHeader = false;
+      if (line.includes("// TODO: Implement your intent logic here.")) {
+        result.push(`        // TODO: Implement your intent logic here.`);
+        result.push(`        //`);
+        result.push(
+          `        // For more information about App Intents, see:`
+        );
+        result.push(
+          `        // https://developer.apple.com/documentation/appintents`
+        );
+      } else {
+        result.push(line);
+      }
+    }
+  }
+  return result.join("\n");
+}
+function generateTestFile(ir) {
+  const lines = [];
+  lines.push(`// ${ir.name}IntentTests.swift`);
+  lines.push(`// Ejected from Axint`);
+  lines.push(``);
+  lines.push(`import XCTest`);
+  lines.push(`import AppIntents`);
+  lines.push(``);
+  lines.push(`final class ${ir.name}IntentTests: XCTestCase {`);
+  lines.push(``);
+  lines.push(`    func testIntentInitialization() throws {`);
+  lines.push(`        let intent = ${ir.name}Intent()`);
+  lines.push(`        XCTAssertEqual(${ir.name}Intent.title.stringValue, "${ir.title}")`);
+  lines.push(`    }`);
+  lines.push(``);
+  lines.push(`    func testIntentPerform() async throws {`);
+  lines.push(`        let intent = ${ir.name}Intent()`);
+  lines.push(`        // TODO: Set up intent parameters and test perform()`);
+  lines.push(`        // let result = try await intent.perform()`);
+  lines.push(`        // XCTAssertNotNil(result)`);
+  lines.push(`    }`);
+  lines.push(``);
+  lines.push(`}`);
+  lines.push(``);
+  return lines.join("\n");
+}
+
+// src/sdk/index.ts
+function make(type) {
+  return (description, config) => ({
+    type,
+    description,
+    ...config
+  });
+}
+var param = {
+  /** String parameter → Swift `String` */
+  string: make("string"),
+  /** 64-bit signed integer → Swift `Int` */
+  int: make("int"),
+  /** Double-precision float → Swift `Double` */
+  double: make("double"),
+  /** Single-precision float → Swift `Float` */
+  float: make("float"),
+  /** Boolean parameter → Swift `Bool` */
+  boolean: make("boolean"),
+  /** Date parameter → Swift `Date` */
+  date: make("date"),
+  /** Duration parameter → Swift `Measurement<UnitDuration>` */
+  duration: make("duration"),
+  /** URL parameter → Swift `URL` */
+  url: make("url"),
+  /**
+   * @deprecated Use `param.int` (or `param.double` / `param.float`) for
+   * explicit Swift numeric fidelity. `param.number` is kept as an alias
+   * for `param.int` to preserve v0.1.x compatibility and will be removed
+   * in v1.0.0.
+   */
+  number: make("number"),
+  /**
+   * Entity reference parameter. The entity name must match a
+   * `defineEntity()` call in the same file or project.
+   */
+  entity: (entityName, description, config) => ({
+    type: "entity",
+    entityName,
+    description,
+    ...config
+  }),
+  /**
+   * Parameter with dynamic option suggestions provided at runtime
+   * by a DynamicOptionsProvider. The `providerName` maps to a
+   * generated Swift `DynamicOptionsProvider` struct.
+   */
+  dynamicOptions: (providerName, innerParam) => {
+    const { type: innerType, description, ...rest } = innerParam;
+    return {
+      type: "dynamicOptions",
+      providerName,
+      innerType,
+      description,
+      ...rest
+    };
+  }
+};
+function defineIntent(config) {
+  return config;
+}
+function defineEntity(config) {
+  return config;
+}
 export {
   LEGACY_PARAM_ALIASES,
   PARAM_TYPES,
   ParserError,
   SWIFT_TYPE_MAP,
   compileFile,
+  compileFromIR,
   compileSource,
+  defineEntity,
+  defineIntent,
+  ejectIntent,
   escapeSwiftString,
   escapeXml,
   generateEntitlementsFragment,
+  generateEntity,
+  generateEntityQuery,
   generateInfoPlistFragment,
   generateSwift,
+  irFromJSON,
   irTypeToSwift,
+  param,
   parseIntentSource,
+  validateEntity,
   validateIntent,
   validateSwiftSource
 };