plugins:
  - name: '@lowdefy/blocks-antd'
    version: '4.0.0'
  - name: '@my-org/custom-blocks'
    version: '1.0.0'
    typePrefix: 'custom' # Optional namespace

build()
    ↓
buildRefs()           # Load config with plugin declarations
    ↓
buildTypes()          # Count which types are used
    ↓
buildImports()        # Generate import statements
    ↓
writePluginImports()  # Write import files

{
  'Button': {
    package: '@lowdefy/blocks-antd',
    originalTypeName: 'Button',
    version: '4.0.0'
  },
  'customTable': {
    package: '@my-org/custom-blocks',
    originalTypeName: 'Table',
    version: '1.0.0'
  }
}

{
  // Actions
  '@lowdefy/actions-core': { ... },
  '@lowdefy/actions-pdf-make': { ... },

  // Blocks
  '@lowdefy/blocks-basic': { ... },
  '@lowdefy/blocks-antd': { ... },
  '@lowdefy/blocks-echarts': { ... },

  // Connections
  '@lowdefy/connection-mongodb': { ... },
  '@lowdefy/connection-axios-http': { ... },

  // Operators
  '@lowdefy/operators-js': { ... },
  '@lowdefy/operators-nunjucks': { ... },

  // Auth
  '@lowdefy/plugin-next-auth': { ... },
  '@lowdefy/plugin-auth0': { ... }
}

context.typeCounters = {
  actions: { SetState: 5, Request: 12 },
  blocks: { Button: 8, TextInput: 15 },
  connections: { MongoDBCollection: 2 },
  requests: { MongoDBFind: 5, MongoDBInsertOne: 3 },
  operators: {
    client: { _state: 45, _if: 12 },
    server: { _secret: 3, _payload: 8 },
  },
  auth: {
    providers: { GoogleProvider: 1 },
    adapters: {},
    callbacks: {},
    events: {},
  },
};

@lowdefy/blocks-basic/
├── package.json
├── src/
│   ├── blocks.js          # Named exports for all block components
│   ├── metas.js           # Named exports for all block meta.js files
│   ├── types.js           # Type declarations (via extractBlockTypes)
│   └── blocks/
│       ├── Anchor/
│       │   ├── Anchor.js
│       │   └── meta.js   # Block metadata + property schema
│       ├── Box/
│       │   ├── Box.js
│       │   └── meta.js
│       └── Icon/
│           ├── Icon.js
│           └── meta.js
└── dist/

export { default as Anchor } from './blocks/Anchor/Anchor.js';
export { default as Box } from './blocks/Box/Box.js';
export { default as Icon } from './blocks/Icon/Icon.js';

export { default as Anchor } from './blocks/Anchor/meta.js';
export { default as Box } from './blocks/Box/meta.js';
export { default as Icon } from './blocks/Icon/meta.js';

import { extractBlockTypes } from '@lowdefy/block-utils';
import * as metas from './metas.js';

export default extractBlockTypes(metas);
// Returns: { blocks: ['Anchor', 'Box', 'Icon'], icons: {...}, blockMetas: {...} }

@lowdefy/connection-mongodb/
├── src/
│   ├── connections.js     # Named exports
│   ├── types.js           # Type declarations
│   └── connections/
│       └── MongoDBCollection/
│           ├── MongoDBCollection.js
│           ├── MongoDBFind/
│           │   └── MongoDBFind.js
│           └── MongoDBInsertOne/
│               └── MongoDBInsertOne.js

export { default as MongoDBCollection } from './connections/MongoDBCollection/MongoDBCollection.js';

export default {
  schema: {
    /* JSON Schema for connection properties */
  },
  requests: {
    MongoDBFind,
    MongoDBFindOne,
    MongoDBInsertOne,
    MongoDBUpdateOne,
    // ...
  },
};

@lowdefy/operators-js/
├── src/
│   ├── types.js
│   └── operators/
│       ├── build/         # Build-time operators
│       ├── client/        # Browser operators
│       ├── server/        # Backend operators
│       └── shared/        # Both client & server

export default {
  operators: {
    client: Object.keys(client),
    server: Object.keys(server),
  },
};

@lowdefy/actions-core/
├── src/
│   ├── actions.js         # Named exports for all actions
│   ├── schemas.js         # Named exports for all action schemas
│   ├── types.js           # Type declarations
│   └── actions/
│       ├── CallAPI/
│       │   ├── CallAPI.js
│       │   └── schema.js  # JSON schema for CallAPI params
│       ├── Request/
│       │   ├── Request.js
│       │   └── schema.js
│       └── SetState/
│           ├── SetState.js
│           └── schema.js

export { default as CallAPI } from './actions/CallAPI/CallAPI.js';
export { default as Request } from './actions/Request/Request.js';
export { default as SetState } from './actions/SetState/SetState.js';

const template = `
{%- for import in imports -%}
import { {{ import.originalTypeName }} as {{ import.typeName }} } from '{{ import.package }}/{{ importPath }}';
{% endfor -%}

export default {
  {% for import in imports -%}
  {{ import.typeName }},
  {% endfor -%}
};
`;

function initLowdefyContext({ auth, Components, config, lowdefy, router, stage, types, window }) {
  lowdefy._internal = {
    actions: types.actions,
    blockComponents: types.blocks,
    operators: types.operators,
    // ...
  };
}

const Component = lowdefy._internal.blockComponents[block.type];

if (!Component) {
  throw new Error(`Block type "${block.type}" not found`);
}

return <Component {...props} />;

function getConnection({ connections }, { connectionConfig }) {
  const connection = connections[connectionConfig.type];

  if (!connection) {
    throw new ConfigurationError(`Connection type "${connectionConfig.type}" not found.`);
  }

  return connection;
}

// In parser
const operator = this.operators[operatorName];
if (operator) {
  return operator({ params, location, context, ... });
}

plugins:
  - name: '@my-org/blocks'
    typePrefix: 'my'

1. lowdefy.yaml declares plugins
         ↓
2. Build loads plugin packages
         ↓
3. createPluginTypesMap() creates type → package mapping
         ↓
4. buildTypes() counts used types
         ↓
5. buildImports() generates import statements
         ↓
6. writePluginImports() writes import files
         ↓
7. Next.js bundles imports
         ↓
8. Runtime: types passed to initLowdefyContext()
         ↓
9. Runtime: types available in lowdefy._internal

// Connection schema — inline on the connection export
export default {
  schema: {
    type: 'object',
    properties: {
      databaseUri: { type: 'string' },
      collection: { type: 'string' },
      read: { type: 'boolean', default: true },
      write: { type: 'boolean', default: false }
    },
    required: ['databaseUri', 'collection']
  },
  requests: { ... }
}

// Request schema — attached to the resolver function
MongoDBFind.schema = {
  type: 'object',
  properties: {
    query: { type: 'object' },
    options: { type: 'object' },
  },
};

// Block meta (e.g., blocks/Button/meta.js) — schema generated by buildBlockSchema()
export default {
  category: 'display',
  icons: [],
  cssKeys: { element: 'The button element.' },
  events: { onClick: 'Called when button is clicked.' },
  properties: {
    type: 'object',
    additionalProperties: false,
    properties: {
      title: { type: 'string' },
      type: { type: 'string', enum: ['default', 'primary', 'dashed', 'link'] },
    },
  },
};

// Action schema (e.g., actions/SetState/schema.js)
export default {
  type: 'object',
  params: {
    type: 'object',
    description: 'Key-value pairs to set in state.',
  },
};

// Operator schema (e.g., operators/shared/get.schema.js)
export default {
  type: 'object',
  params: {
    type: 'object',
    required: ['from'],
    properties: {
      from: { description: 'Object or array to get value from.' },
      key: { type: 'string' },
      default: { description: 'Default value if key does not exist.' },
    },
    additionalProperties: false,
  },
};

{
  "exports": {
    "./metas": "./dist/metas.js",
    "./schemas": "./dist/schemas.js"
  }
}

// my-plugin/src/blocks/MyButton/MyButton.js
const MyButton = ({ blockId, properties, methods }) => {
  return (
    <button onClick={() => methods.triggerEvent({ name: 'onClick' })}>
      {properties.label}
    </button>
  );
};
export default MyButton;

// my-plugin/src/blocks/MyButton/meta.js
export default {
  category: 'display',
  icons: [],
  cssKeys: { element: 'The button element.' },
  events: { onClick: 'Called when MyButton is clicked.' },
  properties: {
    type: 'object',
    properties: {
      label: { type: 'string' },
    },
  },
};

// my-plugin/src/blocks.js
export { default as MyButton } from './blocks/MyButton/MyButton.js';

// my-plugin/src/metas.js
export { default as MyButton } from './blocks/MyButton/meta.js';

// my-plugin/src/types.js
import { extractBlockTypes } from '@lowdefy/block-utils';
import * as metas from './metas.js';
export default extractBlockTypes(metas);

// my-plugin/src/connections.js
export { default as MyAPI } from './connections/MyAPI.js';

// my-plugin/src/connections/MyAPI.js
export default {
  schema: {
    type: 'object',
    properties: {
      apiKey: { type: 'string' },
    },
  },
  requests: {
    MyAPIGet: async ({ connection, request }) => {
      const response = await fetch(request.url, {
        headers: { 'X-API-Key': connection.apiKey },
      });
      return response.json();
    },
  },
};

// my-plugin/src/operators/client/myOperator.js
function _myOperator({ params, location }) {
  return params.toUpperCase();
}
export default _myOperator;