> ## Documentation Index
> Fetch the complete documentation index at: https://docs.attio.com/llms.txt
> Use this file to discover all available pages before exploring further.

# App configuration file

> Register all your entry points in one place (deprecated)

<Note>
  This page documents the deprecated legacy registration file, `app.ts`. It keeps working for
  existing apps, but every new app is scaffolded with the folder-based convention under
  `src/app/` and has no `app.ts` manifest (see [App structure](../extensions/overview)). To
  convert an existing app, use the
  [folder structure migration guide](../guides/folder-structure-migration). The two conventions
  can coexist while you migrate: once `src/app/` exists, `app.ts` is optional, and if the same
  extension id is registered in both places, the folder-based definition wins.
</Note>

The `app.ts` file provides a centralized way to register all of your app's **entry points** - the various features and UI components that integrate with Attio's interface.

This file should be located directly in the root of your `src` directory (`src/app.ts` or `src/app.tsx`).

## Basic structure

Every `app.ts` file follows this structure:

```typescript theme={"system"}
import type {App} from "attio"

// Import your entry points
import {myRecordAction} from "./my-record-action"
import {myWidget} from "./my-widget"

// Export the app configuration
export const app: App = {
  record: {
    actions: [myRecordAction],
    bulkActions: [],
    widgets: [myWidget],
  },
  callRecording: {
    insight: {
      textActions: [],
    },
    summary: {
      textActions: [],
    },
    transcript: {
      textActions: [],
    },
  },
}
```

## Entry point types

The `app.ts` file organizes entry points into logical categories:

### Record entry points

These appear on record pages (companies, people, deals, etc.):

[**`record.actions: Array<App.Record.Action>`**](../extensions/record-action)

[**`record.bulkActions: Array<App.Record.BulkAction>`**](../extensions/bulk-record-action)

[**`record.widgets: Array<App.Record.Widget>`**](../extensions/record-widget)

### Call recording entry points

These appear in call recording contexts:

[**`callRecording.insight.textActions: Array<App.CallRecording.Insight.TextSelectionAction>`**](../extensions/call-recording-insight-text-action)

[**`callRecording.summary.textActions: Array<App.CallRecording.Summary.TextSelectionAction>`**](../extensions/call-recording-summary-text-action)

[**`callRecording.transcript.textActions: Array<App.CallRecording.Transcript.TextSelectionAction>`**](../extensions/call-recording-transcript-text-action)

## Best practices

### 1. Use descriptive names

Use clear, descriptive names for your entry points:

```typescript theme={"system"}
// Good: Clear and specific
import {sendInvoiceAction} from "./actions/send-invoice"
import {customerSummaryWidget} from "./widgets/customer-summary"

// Avoid: Generic names
import {recordAction} from "./actions/send-invoice"
import {recordWidget} from "./widgets/customer-summary"
```

### 2. Organize your file structure

Match your file structure to the `app` object organization:

```text theme={"system"}
src/
  app.ts
  record/
    actions/
      send-invoice.ts
      export-to-crm.ts
    widgets/
      customer-summary.ts
      arr-display.ts
    bulk-actions/
      bulk-export.ts
  callRecording/
    summary/
      capture-feedback.ts
    transcript/
      highlight-action.ts
```

### 3. Keep app.ts simple

The `app.ts` file should primarily contain imports and the configuration object. Keep business logic in the individual entry point files.

### 4. One entry point per file

Each entry point should be defined in its own file and exported. This makes them easier to test and maintain.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.